@cloudbase/database 0.9.19 → 0.9.21

package/dist/esm/util.js

@@ -1,142 +1,142 @@
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-import { FieldType } from './constant';
-import { Point, LineString, Polygon, MultiPoint, MultiLineString, MultiPolygon } from './geo/index';
-import { ServerDate } from './serverDate/index';
-var Util = (function () {
-    function Util() {
-    }
-    Util.formatResDocumentData = function (documents) {
-        return documents.map(function (document) {
-            return Util.formatField(document);
-        });
-    };
-    Util.formatField = function (document) {
-        var keys = Object.keys(document);
-        var protoField = {};
-        if (Array.isArray(document)) {
-            protoField = [];
-        }
-        keys.forEach(function (key) {
-            var item = document[key];
-            var type = Util.whichType(item);
-            var realValue;
-            switch (type) {
-                case FieldType.GeoPoint:
-                    realValue = new Point(item.coordinates[0], item.coordinates[1]);
-                    break;
-                case FieldType.GeoLineString:
-                    realValue = new LineString(item.coordinates.map(function (point) { return new Point(point[0], point[1]); }));
-                    break;
-                case FieldType.GeoPolygon:
-                    realValue = new Polygon(item.coordinates.map(function (line) { return new LineString(line.map(function (_a) {
-                        var _b = __read(_a, 2), lng = _b[0], lat = _b[1];
-                        return new Point(lng, lat);
-                    })); }));
-                    break;
-                case FieldType.GeoMultiPoint:
-                    realValue = new MultiPoint(item.coordinates.map(function (point) { return new Point(point[0], point[1]); }));
-                    break;
-                case FieldType.GeoMultiLineString:
-                    realValue = new MultiLineString(item.coordinates.map(function (line) { return new LineString(line.map(function (_a) {
-                        var _b = __read(_a, 2), lng = _b[0], lat = _b[1];
-                        return new Point(lng, lat);
-                    })); }));
-                    break;
-                case FieldType.GeoMultiPolygon:
-                    realValue = new MultiPolygon(item.coordinates.map(function (polygon) {
-                        return new Polygon(polygon.map(function (line) { return new LineString(line.map(function (_a) {
-                            var _b = __read(_a, 2), lng = _b[0], lat = _b[1];
-                            return new Point(lng, lat);
-                        })); }));
-                    }));
-                    break;
-                case FieldType.Timestamp:
-                    realValue = new Date(item.$timestamp * 1000);
-                    break;
-                case FieldType.Object:
-                case FieldType.Array:
-                    realValue = Util.formatField(item);
-                    break;
-                case FieldType.ServerDate:
-                    realValue = new Date(item.$date);
-                    break;
-                default:
-                    realValue = item;
-            }
-            if (Array.isArray(protoField)) {
-                protoField.push(realValue);
-            }
-            else {
-                protoField[key] = realValue;
-            }
-        });
-        return protoField;
-    };
-    Util.whichType = function (obj) {
-        var type = Object.prototype.toString.call(obj).slice(8, -1);
-        if (type === FieldType.Timestamp) {
-            return FieldType.BsonDate;
-        }
-        if (type === FieldType.Object) {
-            if (obj instanceof Point) {
-                return FieldType.GeoPoint;
-            }
-            else if (obj instanceof Date) {
-                return FieldType.Timestamp;
-            }
-            else if (obj instanceof ServerDate) {
-                return FieldType.ServerDate;
-            }
-            if (obj.$timestamp) {
-                type = FieldType.Timestamp;
-            }
-            else if (obj.$date) {
-                type = FieldType.ServerDate;
-            }
-            else if (Point.validate(obj)) {
-                type = FieldType.GeoPoint;
-            }
-            else if (LineString.validate(obj)) {
-                type = FieldType.GeoLineString;
-            }
-            else if (Polygon.validate(obj)) {
-                type = FieldType.GeoPolygon;
-            }
-            else if (MultiPoint.validate(obj)) {
-                type = FieldType.GeoMultiPoint;
-            }
-            else if (MultiLineString.validate(obj)) {
-                type = FieldType.GeoMultiLineString;
-            }
-            else if (MultiPolygon.validate(obj)) {
-                type = FieldType.GeoMultiPolygon;
-            }
-        }
-        return type;
-    };
-    Util.generateDocId = function () {
-        var chars = 'ABCDEFabcdef0123456789';
-        var autoId = '';
-        for (var i = 0; i < 24; i++) {
-            autoId += chars.charAt(Math.floor(Math.random() * chars.length));
-        }
-        return autoId;
-    };
-    return Util;
-}());
-export { Util };
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+import { FieldType } from './constant';
+import { Point, LineString, Polygon, MultiPoint, MultiLineString, MultiPolygon } from './geo/index';
+import { ServerDate } from './serverDate/index';
+var Util = (function () {
+    function Util() {
+    }
+    Util.formatResDocumentData = function (documents) {
+        return documents.map(function (document) {
+            return Util.formatField(document);
+        });
+    };
+    Util.formatField = function (document) {
+        var keys = Object.keys(document);
+        var protoField = {};
+        if (Array.isArray(document)) {
+            protoField = [];
+        }
+        keys.forEach(function (key) {
+            var item = document[key];
+            var type = Util.whichType(item);
+            var realValue;
+            switch (type) {
+                case FieldType.GeoPoint:
+                    realValue = new Point(item.coordinates[0], item.coordinates[1]);
+                    break;
+                case FieldType.GeoLineString:
+                    realValue = new LineString(item.coordinates.map(function (point) { return new Point(point[0], point[1]); }));
+                    break;
+                case FieldType.GeoPolygon:
+                    realValue = new Polygon(item.coordinates.map(function (line) { return new LineString(line.map(function (_a) {
+                        var _b = __read(_a, 2), lng = _b[0], lat = _b[1];
+                        return new Point(lng, lat);
+                    })); }));
+                    break;
+                case FieldType.GeoMultiPoint:
+                    realValue = new MultiPoint(item.coordinates.map(function (point) { return new Point(point[0], point[1]); }));
+                    break;
+                case FieldType.GeoMultiLineString:
+                    realValue = new MultiLineString(item.coordinates.map(function (line) { return new LineString(line.map(function (_a) {
+                        var _b = __read(_a, 2), lng = _b[0], lat = _b[1];
+                        return new Point(lng, lat);
+                    })); }));
+                    break;
+                case FieldType.GeoMultiPolygon:
+                    realValue = new MultiPolygon(item.coordinates.map(function (polygon) {
+                        return new Polygon(polygon.map(function (line) { return new LineString(line.map(function (_a) {
+                            var _b = __read(_a, 2), lng = _b[0], lat = _b[1];
+                            return new Point(lng, lat);
+                        })); }));
+                    }));
+                    break;
+                case FieldType.Timestamp:
+                    realValue = new Date(item.$timestamp * 1000);
+                    break;
+                case FieldType.Object:
+                case FieldType.Array:
+                    realValue = Util.formatField(item);
+                    break;
+                case FieldType.ServerDate:
+                    realValue = new Date(item.$date);
+                    break;
+                default:
+                    realValue = item;
+            }
+            if (Array.isArray(protoField)) {
+                protoField.push(realValue);
+            }
+            else {
+                protoField[key] = realValue;
+            }
+        });
+        return protoField;
+    };
+    Util.whichType = function (obj) {
+        var type = Object.prototype.toString.call(obj).slice(8, -1);
+        if (type === FieldType.Timestamp) {
+            return FieldType.BsonDate;
+        }
+        if (type === FieldType.Object) {
+            if (obj instanceof Point) {
+                return FieldType.GeoPoint;
+            }
+            else if (obj instanceof Date) {
+                return FieldType.Timestamp;
+            }
+            else if (obj instanceof ServerDate) {
+                return FieldType.ServerDate;
+            }
+            if (obj.$timestamp) {
+                type = FieldType.Timestamp;
+            }
+            else if (obj.$date) {
+                type = FieldType.ServerDate;
+            }
+            else if (Point.validate(obj)) {
+                type = FieldType.GeoPoint;
+            }
+            else if (LineString.validate(obj)) {
+                type = FieldType.GeoLineString;
+            }
+            else if (Polygon.validate(obj)) {
+                type = FieldType.GeoPolygon;
+            }
+            else if (MultiPoint.validate(obj)) {
+                type = FieldType.GeoMultiPoint;
+            }
+            else if (MultiLineString.validate(obj)) {
+                type = FieldType.GeoMultiLineString;
+            }
+            else if (MultiPolygon.validate(obj)) {
+                type = FieldType.GeoMultiPolygon;
+            }
+        }
+        return type;
+    };
+    Util.generateDocId = function () {
+        var chars = 'ABCDEFabcdef0123456789';
+        var autoId = '';
+        for (var i = 0; i < 24; i++) {
+            autoId += chars.charAt(Math.floor(Math.random() * chars.length));
+        }
+        return autoId;
+    };
+    return Util;
+}());
+export { Util };

package/dist/esm/utils/error.d.ts

@@ -1,37 +1,37 @@
-export interface ICloudSDKError extends Error {
-    errCode: number;
-    errMsg: string;
-}
-export declare class CloudSDKError extends Error {
-    errCode: string;
-    errMsg: string;
-    requestID?: string;
-    constructor(options: IErrorConstructorOptions);
-    message: string;
-}
-interface IErrorConstructorOptions {
-    errCode?: string;
-    errMsg: string;
-}
-export declare function isSDKError(error: any): error is CloudSDKError;
-export interface IGenericError<T extends string, P = any> extends Error {
-    type: T;
-    payload: P;
-    generic: boolean;
-}
-export declare const isGenericError: <T extends string, P>(e: any) => e is IGenericError<T, P>;
-export declare class TimeoutError extends Error implements IGenericError<'timeout', null> {
-    type: "timeout";
-    payload: any;
-    generic: boolean;
-    constructor(message: string);
-}
-export declare const isTimeoutError: (e: any) => e is TimeoutError;
-export declare class CancelledError extends Error implements IGenericError<'cancelled', null> {
-    type: "cancelled";
-    payload: any;
-    generic: boolean;
-    constructor(message: string);
-}
-export declare const isCancelledError: (e: any) => e is CancelledError;
-export {};
+export interface ICloudSDKError extends Error {
+    errCode: number;
+    errMsg: string;
+}
+export declare class CloudSDKError extends Error {
+    errCode: string;
+    errMsg: string;
+    requestID?: string;
+    constructor(options: IErrorConstructorOptions);
+    message: string;
+}
+interface IErrorConstructorOptions {
+    errCode?: string;
+    errMsg: string;
+}
+export declare function isSDKError(error: any): error is CloudSDKError;
+export interface IGenericError<T extends string, P = any> extends Error {
+    type: T;
+    payload: P;
+    generic: boolean;
+}
+export declare const isGenericError: <T extends string, P>(e: any) => e is IGenericError<T, P>;
+export declare class TimeoutError extends Error implements IGenericError<'timeout', null> {
+    type: "timeout";
+    payload: any;
+    generic: boolean;
+    constructor(message: string);
+}
+export declare const isTimeoutError: (e: any) => e is TimeoutError;
+export declare class CancelledError extends Error implements IGenericError<'cancelled', null> {
+    type: "cancelled";
+    payload: any;
+    generic: boolean;
+    constructor(message: string);
+}
+export declare const isCancelledError: (e: any) => e is CancelledError;
+export {};

package/dist/esm/utils/error.js

@@ -1,82 +1,82 @@
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-import { isString } from './type';
-import { ERR_CODE } from '../config/error.config';
-var CloudSDKError = (function (_super) {
-    __extends(CloudSDKError, _super);
-    function CloudSDKError(options) {
-        var _this = _super.call(this, options.errMsg) || this;
-        _this.errCode = 'UNKNOWN_ERROR';
-        Object.defineProperties(_this, {
-            message: {
-                get: function () {
-                    return ("errCode: " + this.errCode + " " + (ERR_CODE[this.errCode] ||
-                        '') + " | errMsg: " + this.errMsg);
-                },
-                set: function (msg) {
-                    this.errMsg = msg;
-                }
-            }
-        });
-        _this.errCode = options.errCode || 'UNKNOWN_ERROR';
-        _this.errMsg = options.errMsg;
-        return _this;
-    }
-    Object.defineProperty(CloudSDKError.prototype, "message", {
-        get: function () {
-            return "errCode: " + this.errCode + " | errMsg: " + this.errMsg;
-        },
-        set: function (msg) {
-            this.errMsg = msg;
-        },
-        enumerable: true,
-        configurable: true
-    });
-    return CloudSDKError;
-}(Error));
-export { CloudSDKError };
-export function isSDKError(error) {
-    return (error && error instanceof Error && isString(error.errMsg));
-}
-export var isGenericError = function (e) { return e.generic; };
-var TimeoutError = (function (_super) {
-    __extends(TimeoutError, _super);
-    function TimeoutError(message) {
-        var _this = _super.call(this, message) || this;
-        _this.type = 'timeout';
-        _this.payload = null;
-        _this.generic = true;
-        return _this;
-    }
-    return TimeoutError;
-}(Error));
-export { TimeoutError };
-export var isTimeoutError = function (e) {
-    return e.type === 'timeout';
-};
-var CancelledError = (function (_super) {
-    __extends(CancelledError, _super);
-    function CancelledError(message) {
-        var _this = _super.call(this, message) || this;
-        _this.type = 'cancelled';
-        _this.payload = null;
-        _this.generic = true;
-        return _this;
-    }
-    return CancelledError;
-}(Error));
-export { CancelledError };
-export var isCancelledError = function (e) {
-    return e.type === 'cancelled';
-};
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+import { isString } from './type';
+import { ERR_CODE } from '../config/error.config';
+var CloudSDKError = (function (_super) {
+    __extends(CloudSDKError, _super);
+    function CloudSDKError(options) {
+        var _this = _super.call(this, options.errMsg) || this;
+        _this.errCode = 'UNKNOWN_ERROR';
+        Object.defineProperties(_this, {
+            message: {
+                get: function () {
+                    return ("errCode: " + this.errCode + " " + (ERR_CODE[this.errCode] ||
+                        '') + " | errMsg: " + this.errMsg);
+                },
+                set: function (msg) {
+                    this.errMsg = msg;
+                }
+            }
+        });
+        _this.errCode = options.errCode || 'UNKNOWN_ERROR';
+        _this.errMsg = options.errMsg;
+        return _this;
+    }
+    Object.defineProperty(CloudSDKError.prototype, "message", {
+        get: function () {
+            return "errCode: " + this.errCode + " | errMsg: " + this.errMsg;
+        },
+        set: function (msg) {
+            this.errMsg = msg;
+        },
+        enumerable: true,
+        configurable: true
+    });
+    return CloudSDKError;
+}(Error));
+export { CloudSDKError };
+export function isSDKError(error) {
+    return (error && error instanceof Error && isString(error.errMsg));
+}
+export var isGenericError = function (e) { return e.generic; };
+var TimeoutError = (function (_super) {
+    __extends(TimeoutError, _super);
+    function TimeoutError(message) {
+        var _this = _super.call(this, message) || this;
+        _this.type = 'timeout';
+        _this.payload = null;
+        _this.generic = true;
+        return _this;
+    }
+    return TimeoutError;
+}(Error));
+export { TimeoutError };
+export var isTimeoutError = function (e) {
+    return e.type === 'timeout';
+};
+var CancelledError = (function (_super) {
+    __extends(CancelledError, _super);
+    function CancelledError(message) {
+        var _this = _super.call(this, message) || this;
+        _this.type = 'cancelled';
+        _this.payload = null;
+        _this.generic = true;
+        return _this;
+    }
+    return CancelledError;
+}(Error));
+export { CancelledError };
+export var isCancelledError = function (e) {
+    return e.type === 'cancelled';
+};

package/dist/esm/utils/symbol.d.ts

@@ -1,8 +1,8 @@
-declare class HiddenSymbol {
-    constructor(target: any);
-}
-export declare class InternalSymbol extends HiddenSymbol {
-    constructor(target: any, __mark__: any);
-    static for(target: any): InternalSymbol;
-}
-export default InternalSymbol;
+declare class HiddenSymbol {
+    constructor(target: any);
+}
+export declare class InternalSymbol extends HiddenSymbol {
+    constructor(target: any, __mark__: any);
+    static for(target: any): InternalSymbol;
+}
+export default InternalSymbol;

package/dist/esm/utils/symbol.js

@@ -1,55 +1,55 @@
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var _symbols = [];
-var __internalMark__ = {};
-var HiddenSymbol = (function () {
-    function HiddenSymbol(target) {
-        Object.defineProperties(this, {
-            target: {
-                enumerable: false,
-                writable: false,
-                configurable: false,
-                value: target,
-            },
-        });
-    }
-    return HiddenSymbol;
-}());
-var InternalSymbol = (function (_super) {
-    __extends(InternalSymbol, _super);
-    function InternalSymbol(target, __mark__) {
-        var _this = this;
-        if (__mark__ !== __internalMark__) {
-            throw new TypeError('InternalSymbol cannot be constructed with new operator');
-        }
-        _this = _super.call(this, target) || this;
-        return _this;
-    }
-    InternalSymbol.for = function (target) {
-        for (var i = 0, len = _symbols.length; i < len; i++) {
-            if (_symbols[i].target === target) {
-                return _symbols[i].instance;
-            }
-        }
-        var symbol = new InternalSymbol(target, __internalMark__);
-        _symbols.push({
-            target: target,
-            instance: symbol,
-        });
-        return symbol;
-    };
-    return InternalSymbol;
-}(HiddenSymbol));
-export { InternalSymbol };
-export default InternalSymbol;
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var _symbols = [];
+var __internalMark__ = {};
+var HiddenSymbol = (function () {
+    function HiddenSymbol(target) {
+        Object.defineProperties(this, {
+            target: {
+                enumerable: false,
+                writable: false,
+                configurable: false,
+                value: target,
+            },
+        });
+    }
+    return HiddenSymbol;
+}());
+var InternalSymbol = (function (_super) {
+    __extends(InternalSymbol, _super);
+    function InternalSymbol(target, __mark__) {
+        var _this = this;
+        if (__mark__ !== __internalMark__) {
+            throw new TypeError('InternalSymbol cannot be constructed with new operator');
+        }
+        _this = _super.call(this, target) || this;
+        return _this;
+    }
+    InternalSymbol.for = function (target) {
+        for (var i = 0, len = _symbols.length; i < len; i++) {
+            if (_symbols[i].target === target) {
+                return _symbols[i].instance;
+            }
+        }
+        var symbol = new InternalSymbol(target, __internalMark__);
+        _symbols.push({
+            target: target,
+            instance: symbol,
+        });
+        return symbol;
+    };
+    return InternalSymbol;
+}(HiddenSymbol));
+export { InternalSymbol };
+export default InternalSymbol;