FM / src

/var/www/greso.tech/server/nsm/node_modules/@google-cloud/firestore/build/src/

/var/www/greso.tech/server/nsm/node_modules/@google-cloud/firestore/build/src

Name	Size	Mode	Actions
v1/	-	0755	rm
v1beta1/	-	0755	rm
backoff.d.ts	5547	0644	edit dl rm
backoff.js	7650	0644	edit dl rm
bulk-writer.d.ts	19230	0644	edit dl rm
bulk-writer.js	36112	0644	edit dl rm
bundle.d.ts	835	0644	edit dl rm
bundle.js	8427	0644	edit dl rm
collection-group.d.ts	3602	0644	edit dl rm
collection-group.js	4553	0644	edit dl rm
convert.d.ts	2776	0644	edit dl rm
convert.js	7168	0644	edit dl rm
document-change.d.ts	5033	0644	edit dl rm
document-change.js	5284	0644	edit dl rm
document-reader.d.ts	1842	0644	edit dl rm
document-reader.js	5394	0644	edit dl rm
document.d.ts	18149	0644	edit dl rm
document.js	30404	0644	edit dl rm
field-value.d.ts	8598	0644	edit dl rm
field-value.js	13884	0644	edit dl rm
filter.d.ts	6832	0644	edit dl rm
filter.js	6973	0644	edit dl rm
geo-point.d.ts	2644	0644	edit dl rm
geo-point.js	3217	0644	edit dl rm
index.d.ts	38229	0644	edit dl rm
index.js	63443	0644	edit dl rm
logger.d.ts	1310	0644	edit dl rm
logger.js	2112	0644	edit dl rm
order.d.ts	1096	0644	edit dl rm
order.js	7525	0644	edit dl rm
path.d.ts	12118	0644	edit dl rm
path.js	18995	0644	edit dl rm
pool.d.ts	4432	0644	edit dl rm
pool.js	10116	0644	edit dl rm
query-partition.d.ts	4011	0644	edit dl rm
query-partition.js	5761	0644	edit dl rm
rate-limiter.d.ts	3015	0644	edit dl rm
rate-limiter.js	5850	0644	edit dl rm
recursive-delete.d.ts	5714	0644	edit dl rm
recursive-delete.js	10040	0644	edit dl rm
reference.d.ts	53096	0644	edit dl rm
reference.js	103221	0644	edit dl rm
serializer.d.ts	2942	0644	edit dl rm
serializer.js	12817	0644	edit dl rm
status-code.d.ts	1121	0644	edit dl rm
status-code.js	712	0644	edit dl rm
timestamp.d.ts	6987	0644	edit dl rm
timestamp.js	9697	0644	edit dl rm
transaction.d.ts	10098	0644	edit dl rm
transaction.js	19139	0644	edit dl rm
types.d.ts	3992	0644	edit dl rm
types.js	1387	0644	edit dl rm
util.d.ts	4066	0644	edit dl rm
util.js	7373	0644	edit dl rm
validate.d.ts	6527	0644	edit dl rm
validate.js	12314	0644	edit dl rm
watch.d.ts	9738	0644	edit dl rm
watch.js	24988	0644	edit dl rm
write-batch.d.ts	10521	0644	edit dl rm
write-batch.js	27233	0644	edit dl rm

Edit: /var/www/greso.tech/server/nsm/node_modules/@google-cloud/firestore/build/src/serializer.js (12817B)

"use strict";
/*!
 * Copyright 2019 Google Inc. 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.validateUserInput = exports.Serializer = void 0;
const convert_1 = require("./convert");
const field_value_1 = require("./field-value");
const geo_point_1 = require("./geo-point");
const index_1 = require("./index");
const path_1 = require("./path");
const timestamp_1 = require("./timestamp");
const util_1 = require("./util");
const validate_1 = require("./validate");
/**
 * The maximum depth of a Firestore object.
 *
 * @private
 * @internal
 */
const MAX_DEPTH = 20;
/**
 * Serializer that is used to convert between JavaScript types and their
 * Firestore Protobuf representation.
 *
 * @private
 * @internal
 */
class Serializer {
    constructor(firestore) {
        // Instead of storing the `firestore` object, we store just a reference to
        // its `.doc()` method. This avoid a circular reference, which breaks
        // JSON.stringify().
        this.createReference = path => firestore.doc(path);
        this.createInteger = n => firestore._settings.useBigInt ? BigInt(n) : Number(n);
        this.allowUndefined = !!firestore._settings.ignoreUndefinedProperties;
    }
    /**
     * Encodes a JavaScript object into the Firestore 'Fields' representation.
     *
     * @private
     * @internal
     * @param obj The object to encode.
     * @returns The Firestore 'Fields' representation
     */
    encodeFields(obj) {
        const fields = {};
        for (const prop of Object.keys(obj)) {
            const val = this.encodeValue(obj[prop]);
            if (val) {
                fields[prop] = val;
            }
        }
        return fields;
    }
    /**
     * Encodes a JavaScript value into the Firestore 'Value' representation.
     *
     * @private
     * @internal
     * @param val The object to encode
     * @returns The Firestore Proto or null if we are deleting a field.
     */
    encodeValue(val) {
        if (val instanceof field_value_1.FieldTransform) {
            return null;
        }
        if (typeof val === 'string') {
            return {
                stringValue: val,
            };
        }
        if (typeof val === 'boolean') {
            return {
                booleanValue: val,
            };
        }
        if (typeof val === 'number') {
            const isNegativeZero = val === 0 && 1 / val === 1 / -0;
            if (Number.isSafeInteger(val) && !isNegativeZero) {
                return {
                    integerValue: val,
                };
            }
            else {
                return {
                    doubleValue: val,
                };
            }
        }
        if (typeof val === 'bigint') {
            return {
                integerValue: val.toString(),
            };
        }
        if (val instanceof Date) {
            const timestamp = timestamp_1.Timestamp.fromDate(val);
            return {
                timestampValue: {
                    seconds: timestamp.seconds,
                    nanos: timestamp.nanoseconds,
                },
            };
        }
        if (isMomentJsType(val)) {
            const timestamp = timestamp_1.Timestamp.fromDate(val.toDate());
            return {
                timestampValue: {
                    seconds: timestamp.seconds,
                    nanos: timestamp.nanoseconds,
                },
            };
        }
        if (val === null) {
            return {
                nullValue: 'NULL_VALUE',
            };
        }
        if (val instanceof Buffer || val instanceof Uint8Array) {
            return {
                bytesValue: val,
            };
        }
        if ((0, util_1.isObject)(val)) {
            const toProto = val['toProto'];
            if (typeof toProto === 'function') {
                return toProto.bind(val)();
            }
        }
        if (Array.isArray(val)) {
            const array = {
                arrayValue: {},
            };
            if (val.length > 0) {
                array.arrayValue.values = [];
                for (let i = 0; i < val.length; ++i) {
                    const enc = this.encodeValue(val[i]);
                    if (enc) {
                        array.arrayValue.values.push(enc);
                    }
                }
            }
            return array;
        }
        if (typeof val === 'object' && (0, util_1.isPlainObject)(val)) {
            const map = {
                mapValue: {},
            };
            // If we encounter an empty object, we always need to send it to make sure
            // the server creates a map entry.
            if (!(0, util_1.isEmpty)(val)) {
                map.mapValue.fields = this.encodeFields(val);
                if ((0, util_1.isEmpty)(map.mapValue.fields)) {
                    return null;
                }
            }
            return map;
        }
        if (val === undefined && this.allowUndefined) {
            return null;
        }
        throw new Error(`Cannot encode value: ${val}`);
    }
    /**
     * Decodes a single Firestore 'Value' Protobuf.
     *
     * @private
     * @internal
     * @param proto A Firestore 'Value' Protobuf.
     * @returns The converted JS type.
     */
    decodeValue(proto) {
        const valueType = (0, convert_1.detectValueType)(proto);
        switch (valueType) {
            case 'stringValue': {
                return proto.stringValue;
            }
            case 'booleanValue': {
                return proto.booleanValue;
            }
            case 'integerValue': {
                return this.createInteger(proto.integerValue);
            }
            case 'doubleValue': {
                return proto.doubleValue;
            }
            case 'timestampValue': {
                return timestamp_1.Timestamp.fromProto(proto.timestampValue);
            }
            case 'referenceValue': {
                const resourcePath = path_1.QualifiedResourcePath.fromSlashSeparatedString(proto.referenceValue);
                return this.createReference(resourcePath.relativeName);
            }
            case 'arrayValue': {
                const array = [];
                if (Array.isArray(proto.arrayValue.values)) {
                    for (const value of proto.arrayValue.values) {
                        array.push(this.decodeValue(value));
                    }
                }
                return array;
            }
            case 'nullValue': {
                return null;
            }
            case 'mapValue': {
                const obj = {};
                const fields = proto.mapValue.fields;
                if (fields) {
                    for (const prop of Object.keys(fields)) {
                        obj[prop] = this.decodeValue(fields[prop]);
                    }
                }
                return obj;
            }
            case 'geoPointValue': {
                return geo_point_1.GeoPoint.fromProto(proto.geoPointValue);
            }
            case 'bytesValue': {
                return proto.bytesValue;
            }
            default: {
                throw new Error('Cannot decode type from Firestore Value: ' + JSON.stringify(proto));
            }
        }
    }
}
exports.Serializer = Serializer;
/**
 * Validates a JavaScript value for usage as a Firestore value.
 *
 * @private
 * @internal
 * @param arg The argument name or argument index (for varargs methods).
 * @param value JavaScript value to validate.
 * @param desc A description of the expected type.
 * @param path The field path to validate.
 * @param options Validation options
 * @param level The current depth of the traversal. This is used to decide
 * whether undefined values or deletes are allowed.
 * @param inArray Whether we are inside an array.
 * @throws when the object is invalid.
 */
function validateUserInput(arg, value, desc, options, path, level, inArray) {
    if (path && path.size - 1 > MAX_DEPTH) {
        throw new Error(`${(0, validate_1.invalidArgumentMessage)(arg, desc)} Input object is deeper than ${MAX_DEPTH} levels or contains a cycle.`);
    }
    level = level || 0;
    inArray = inArray || false;
    const fieldPathMessage = path ? ` (found in field "${path}")` : '';
    if (Array.isArray(value)) {
        for (let i = 0; i < value.length; ++i) {
            validateUserInput(arg, value[i], desc, options, path ? path.append(String(i)) : new path_1.FieldPath(String(i)), level + 1, 
            /* inArray= */ true);
        }
    }
    else if ((0, util_1.isPlainObject)(value)) {
        for (const prop of Object.keys(value)) {
            validateUserInput(arg, value[prop], desc, options, path ? path.append(new path_1.FieldPath(prop)) : new path_1.FieldPath(prop), level + 1, inArray);
        }
    }
    else if (value === undefined) {
        if (options.allowUndefined && level === 0) {
            throw new Error(`${(0, validate_1.invalidArgumentMessage)(arg, desc)} "undefined" values are only ignored inside of objects.`);
        }
        else if (!options.allowUndefined) {
            throw new Error(`${(0, validate_1.invalidArgumentMessage)(arg, desc)} Cannot use "undefined" as a Firestore value${fieldPathMessage}. ` +
                'If you want to ignore undefined values, enable `ignoreUndefinedProperties`.');
        }
    }
    else if (value instanceof field_value_1.DeleteTransform) {
        if (inArray) {
            throw new Error(`${(0, validate_1.invalidArgumentMessage)(arg, desc)} ${value.methodName}() cannot be used inside of an array${fieldPathMessage}.`);
        }
        else if (options.allowDeletes === 'none') {
            throw new Error(`${(0, validate_1.invalidArgumentMessage)(arg, desc)} ${value.methodName}() must appear at the top-level and can only be used in update() ` +
                `or set() with {merge:true}${fieldPathMessage}.`);
        }
        else if (options.allowDeletes === 'root') {
            if (level === 0) {
                // Ok (update() with UpdateData).
            }
            else if (level === 1 && (path === null || path === void 0 ? void 0 : path.size) === 1) {
                // Ok (update with varargs).
            }
            else {
                throw new Error(`${(0, validate_1.invalidArgumentMessage)(arg, desc)} ${value.methodName}() must appear at the top-level and can only be used in update() ` +
                    `or set() with {merge:true}${fieldPathMessage}.`);
            }
        }
    }
    else if (value instanceof field_value_1.FieldTransform) {
        if (inArray) {
            throw new Error(`${(0, validate_1.invalidArgumentMessage)(arg, desc)} ${value.methodName}() cannot be used inside of an array${fieldPathMessage}.`);
        }
        else if (!options.allowTransforms) {
            throw new Error(`${(0, validate_1.invalidArgumentMessage)(arg, desc)} ${value.methodName}() can only be used in set(), create() or update()${fieldPathMessage}.`);
        }
    }
    else if (value instanceof path_1.FieldPath) {
        throw new Error(`${(0, validate_1.invalidArgumentMessage)(arg, desc)} Cannot use object of type "FieldPath" as a Firestore value${fieldPathMessage}.`);
    }
    else if (value instanceof index_1.DocumentReference) {
        // Ok.
    }
    else if (value instanceof geo_point_1.GeoPoint) {
        // Ok.
    }
    else if (value instanceof timestamp_1.Timestamp || value instanceof Date) {
        // Ok.
    }
    else if (isMomentJsType(value)) {
        // Ok.
    }
    else if (value instanceof Buffer || value instanceof Uint8Array) {
        // Ok.
    }
    else if (value === null) {
        // Ok.
    }
    else if (typeof value === 'object') {
        throw new Error((0, validate_1.customObjectMessage)(arg, value, path));
    }
}
exports.validateUserInput = validateUserInput;
/**
 * Returns true if value is a MomentJs date object.
 * @private
 * @internal
 */
function isMomentJsType(value) {
    return (typeof value === 'object' &&
        value !== null &&
        value.constructor &&
        value.constructor.name === 'Moment' &&
        typeof value.toDate === 'function');
}
//# sourceMappingURL=serializer.js.map

cmd: