Software: Apache/2.4.41 (Ubuntu). PHP/8.0.30 

uname -a: Linux apirnd 5.4.0-204-generic #224-Ubuntu SMP Thu Dec 5 13:38:28 UTC 2024 x86_64 

uid=33(www-data) gid=33(www-data) groups=33(www-data) 

Safe-mode: OFF (not secure)

/var/www/html/sync/node_modules/@google-cloud/firestore/build/src/   drwxr-xr-x
Free 13.05 GB of 57.97 GB (22.51%)
                            Encoder    Tools    Proc.    FTP brute    Sec.    SQL    PHP-code    Update    Self remove    Logout    

Viewing file:     aggregate.js (4.42 KB)      -rw-r--r--

"use strict";
/**
 * Copyright 2023 Google LLC. All Rights Reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
Object.defineProperty(exports, "__esModule", { value: true });
exports.AggregateField = exports.Aggregate = void 0;
const path_1 = require("./path");
const assert = require("assert");
/**
 * Concrete implementation of the Aggregate type.
 */
class Aggregate {
    constructor(alias, aggregateType, fieldPath) {
        this.alias = alias;
        this.aggregateType = aggregateType;
        this.fieldPath = fieldPath;
    }
    /**
     * Converts this object to the proto representation of an Aggregate.
     * @internal
     */
    toProto() {
        const proto = {};
        if (this.aggregateType === 'count') {
            proto.count = {};
        }
        else if (this.aggregateType === 'sum') {
            assert(this.fieldPath !== undefined, 'Missing field path for sum aggregation.');
            proto.sum = {
                field: {
                    fieldPath: path_1.FieldPath.fromArgument(this.fieldPath).formattedName,
                },
            };
        }
        else if (this.aggregateType === 'avg') {
            assert(this.fieldPath !== undefined, 'Missing field path for average aggregation.');
            proto.avg = {
                field: {
                    fieldPath: path_1.FieldPath.fromArgument(this.fieldPath).formattedName,
                },
            };
        }
        else {
            throw new Error(`Aggregate type ${this.aggregateType} unimplemented.`);
        }
        proto.alias = this.alias;
        return proto;
    }
}
exports.Aggregate = Aggregate;
/**
 * Represents an aggregation that can be performed by Firestore.
 */
class AggregateField {
    /**
     * Create a new AggregateField<T>
     * @param aggregateType Specifies the type of aggregation operation to perform.
     * @param field Optionally specifies the field that is aggregated.
     * @internal
     */
    constructor(aggregateType, field) {
        this.aggregateType = aggregateType;
        /** A type string to uniquely identify instances of this class. */
        this.type = 'AggregateField';
        this._field = field;
    }
    /**
     * Compares this object with the given object for equality.
     *
     * This object is considered "equal" to the other object if and only if
     * `other` performs the same kind of aggregation on the same field (if any).
     *
     * @param other The object to compare to this object for equality.
     * @return `true` if this object is "equal" to the given object, as
     * defined above, or `false` otherwise.
     */
    isEqual(other) {
        return (other instanceof AggregateField &&
            this.aggregateType === other.aggregateType &&
            ((this._field === undefined && other._field === undefined) ||
                (this._field !== undefined &&
                    other._field !== undefined &&
                    path_1.FieldPath.fromArgument(this._field).isEqual(path_1.FieldPath.fromArgument(other._field)))));
    }
    /**
     * Create an AggregateField object that can be used to compute the count of
     * documents in the result set of a query.
     */
    static count() {
        return new AggregateField('count');
    }
    /**
     * Create an AggregateField object that can be used to compute the average of
     * a specified field over a range of documents in the result set of a query.
     * @param field Specifies the field to average across the result set.
     */
    static average(field) {
        return new AggregateField('avg', field);
    }
    /**
     * Create an AggregateField object that can be used to compute the sum of
     * a specified field over a range of documents in the result set of a query.
     * @param field Specifies the field to sum across the result set.
     */
    static sum(field) {
        return new AggregateField('sum', field);
    }
}
exports.AggregateField = AggregateField;
//# sourceMappingURL=aggregate.js.map