@cloudbase/database 1.4.1 → 1.4.2

package/dist/commonjs/geo/lineString.js

@@ -1,57 +1,57 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const symbol_1 = require("../helper/symbol");
-const point_1 = require("./point");
-const type_1 = require("../utils/type");
-class LineString {
-    constructor(points) {
-        if (!type_1.isArray(points)) {
-            throw new TypeError(`"points" must be of type Point[]. Received type ${typeof points}`);
-        }
-        if (points.length < 2) {
-            throw new Error('"points" must contain 2 points at least');
-        }
-        points.forEach(point => {
-            if (!(point instanceof point_1.Point)) {
-                throw new TypeError(`"points" must be of type Point[]. Received type ${typeof point}[]`);
-            }
-        });
-        this.points = points;
-    }
-    parse(key) {
-        return {
-            [key]: {
-                type: 'LineString',
-                coordinates: this.points.map(point => point.toJSON().coordinates)
-            }
-        };
-    }
-    toJSON() {
-        return {
-            type: 'LineString',
-            coordinates: this.points.map(point => point.toJSON().coordinates)
-        };
-    }
-    static validate(lineString) {
-        if (lineString.type !== 'LineString' || !type_1.isArray(lineString.coordinates)) {
-            return false;
-        }
-        for (let point of lineString.coordinates) {
-            if (!type_1.isNumber(point[0]) || !type_1.isNumber(point[1])) {
-                return false;
-            }
-        }
-        return true;
-    }
-    static isClosed(lineString) {
-        const firstPoint = lineString.points[0];
-        const lastPoint = lineString.points[lineString.points.length - 1];
-        if (firstPoint.latitude === lastPoint.latitude && firstPoint.longitude === lastPoint.longitude) {
-            return true;
-        }
-    }
-    get _internalType() {
-        return symbol_1.SYMBOL_GEO_LINE_STRING;
-    }
-}
-exports.LineString = LineString;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const symbol_1 = require("../helper/symbol");
+const point_1 = require("./point");
+const type_1 = require("../utils/type");
+class LineString {
+    constructor(points) {
+        if (!type_1.isArray(points)) {
+            throw new TypeError(`"points" must be of type Point[]. Received type ${typeof points}`);
+        }
+        if (points.length < 2) {
+            throw new Error('"points" must contain 2 points at least');
+        }
+        points.forEach(point => {
+            if (!(point instanceof point_1.Point)) {
+                throw new TypeError(`"points" must be of type Point[]. Received type ${typeof point}[]`);
+            }
+        });
+        this.points = points;
+    }
+    parse(key) {
+        return {
+            [key]: {
+                type: 'LineString',
+                coordinates: this.points.map(point => point.toJSON().coordinates)
+            }
+        };
+    }
+    toJSON() {
+        return {
+            type: 'LineString',
+            coordinates: this.points.map(point => point.toJSON().coordinates)
+        };
+    }
+    static validate(lineString) {
+        if (lineString.type !== 'LineString' || !type_1.isArray(lineString.coordinates)) {
+            return false;
+        }
+        for (let point of lineString.coordinates) {
+            if (!type_1.isNumber(point[0]) || !type_1.isNumber(point[1])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    static isClosed(lineString) {
+        const firstPoint = lineString.points[0];
+        const lastPoint = lineString.points[lineString.points.length - 1];
+        if (firstPoint.latitude === lastPoint.latitude && firstPoint.longitude === lastPoint.longitude) {
+            return true;
+        }
+    }
+    get _internalType() {
+        return symbol_1.SYMBOL_GEO_LINE_STRING;
+    }
+}
+exports.LineString = LineString;

package/dist/commonjs/geo/multiLineString.d.ts

@@ -1,18 +1,18 @@
-import { LineString } from './lineString';
-import { ISerializedMultiLineString } from './interface';
-export declare class MultiLineString {
-    readonly lines: LineString[];
-    constructor(lines: LineString[]);
-    parse(key: any): {
-        [x: number]: {
-            type: string;
-            coordinates: number[][][];
-        };
-    };
-    toJSON(): {
-        type: string;
-        coordinates: number[][][];
-    };
-    static validate(multiLineString: ISerializedMultiLineString): boolean;
-    readonly _internalType: import("../utils/symbol").InternalSymbol;
-}
+import { LineString } from './lineString';
+import { ISerializedMultiLineString } from './interface';
+export declare class MultiLineString {
+    readonly lines: LineString[];
+    constructor(lines: LineString[]);
+    parse(key: any): {
+        [x: number]: {
+            type: string;
+            coordinates: number[][][];
+        };
+    };
+    toJSON(): {
+        type: string;
+        coordinates: number[][][];
+    };
+    static validate(multiLineString: ISerializedMultiLineString): boolean;
+    readonly _internalType: import("../utils/symbol").InternalSymbol;
+}

package/dist/commonjs/geo/multiLineString.js

@@ -1,56 +1,56 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const symbol_1 = require("../helper/symbol");
-const type_1 = require("../utils/type");
-const lineString_1 = require("./lineString");
-class MultiLineString {
-    constructor(lines) {
-        if (!type_1.isArray(lines)) {
-            throw new TypeError(`"lines" must be of type LineString[]. Received type ${typeof lines}`);
-        }
-        if (lines.length === 0) {
-            throw new Error('Polygon must contain 1 linestring at least');
-        }
-        lines.forEach(line => {
-            if (!(line instanceof lineString_1.LineString)) {
-                throw new TypeError(`"lines" must be of type LineString[]. Received type ${typeof line}[]`);
-            }
-        });
-        this.lines = lines;
-    }
-    parse(key) {
-        return {
-            [key]: {
-                type: 'MultiLineString',
-                coordinates: this.lines.map(line => {
-                    return line.points.map(point => [point.longitude, point.latitude]);
-                })
-            }
-        };
-    }
-    toJSON() {
-        return {
-            type: 'MultiLineString',
-            coordinates: this.lines.map(line => {
-                return line.points.map(point => [point.longitude, point.latitude]);
-            })
-        };
-    }
-    static validate(multiLineString) {
-        if (multiLineString.type !== 'MultiLineString' || !type_1.isArray(multiLineString.coordinates)) {
-            return false;
-        }
-        for (let line of multiLineString.coordinates) {
-            for (let point of line) {
-                if (!type_1.isNumber(point[0]) || !type_1.isNumber(point[1])) {
-                    return false;
-                }
-            }
-        }
-        return true;
-    }
-    get _internalType() {
-        return symbol_1.SYMBOL_GEO_MULTI_LINE_STRING;
-    }
-}
-exports.MultiLineString = MultiLineString;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const symbol_1 = require("../helper/symbol");
+const type_1 = require("../utils/type");
+const lineString_1 = require("./lineString");
+class MultiLineString {
+    constructor(lines) {
+        if (!type_1.isArray(lines)) {
+            throw new TypeError(`"lines" must be of type LineString[]. Received type ${typeof lines}`);
+        }
+        if (lines.length === 0) {
+            throw new Error('Polygon must contain 1 linestring at least');
+        }
+        lines.forEach(line => {
+            if (!(line instanceof lineString_1.LineString)) {
+                throw new TypeError(`"lines" must be of type LineString[]. Received type ${typeof line}[]`);
+            }
+        });
+        this.lines = lines;
+    }
+    parse(key) {
+        return {
+            [key]: {
+                type: 'MultiLineString',
+                coordinates: this.lines.map(line => {
+                    return line.points.map(point => [point.longitude, point.latitude]);
+                })
+            }
+        };
+    }
+    toJSON() {
+        return {
+            type: 'MultiLineString',
+            coordinates: this.lines.map(line => {
+                return line.points.map(point => [point.longitude, point.latitude]);
+            })
+        };
+    }
+    static validate(multiLineString) {
+        if (multiLineString.type !== 'MultiLineString' || !type_1.isArray(multiLineString.coordinates)) {
+            return false;
+        }
+        for (let line of multiLineString.coordinates) {
+            for (let point of line) {
+                if (!type_1.isNumber(point[0]) || !type_1.isNumber(point[1])) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    get _internalType() {
+        return symbol_1.SYMBOL_GEO_MULTI_LINE_STRING;
+    }
+}
+exports.MultiLineString = MultiLineString;

package/dist/commonjs/geo/multiPoint.d.ts

@@ -1,18 +1,18 @@
-import { Point } from './point';
-import { ISerializedMultiPoint } from './interface';
-export declare class MultiPoint {
-    readonly points: Point[];
-    constructor(points: Point[]);
-    parse(key: any): {
-        [x: number]: {
-            type: string;
-            coordinates: number[][];
-        };
-    };
-    toJSON(): {
-        type: string;
-        coordinates: number[][];
-    };
-    static validate(multiPoint: ISerializedMultiPoint): boolean;
-    readonly _internalType: import("../utils/symbol").InternalSymbol;
-}
+import { Point } from './point';
+import { ISerializedMultiPoint } from './interface';
+export declare class MultiPoint {
+    readonly points: Point[];
+    constructor(points: Point[]);
+    parse(key: any): {
+        [x: number]: {
+            type: string;
+            coordinates: number[][];
+        };
+    };
+    toJSON(): {
+        type: string;
+        coordinates: number[][];
+    };
+    static validate(multiPoint: ISerializedMultiPoint): boolean;
+    readonly _internalType: import("../utils/symbol").InternalSymbol;
+}

package/dist/commonjs/geo/multiPoint.js

@@ -1,50 +1,50 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const symbol_1 = require("../helper/symbol");
-const point_1 = require("./point");
-const type_1 = require("../utils/type");
-class MultiPoint {
-    constructor(points) {
-        if (!type_1.isArray(points)) {
-            throw new TypeError(`"points" must be of type Point[]. Received type ${typeof points}`);
-        }
-        if (points.length === 0) {
-            throw new Error('"points" must contain 1 point at least');
-        }
-        points.forEach(point => {
-            if (!(point instanceof point_1.Point)) {
-                throw new TypeError(`"points" must be of type Point[]. Received type ${typeof point}[]`);
-            }
-        });
-        this.points = points;
-    }
-    parse(key) {
-        return {
-            [key]: {
-                type: 'MultiPoint',
-                coordinates: this.points.map(point => point.toJSON().coordinates)
-            }
-        };
-    }
-    toJSON() {
-        return {
-            type: 'MultiPoint',
-            coordinates: this.points.map(point => point.toJSON().coordinates)
-        };
-    }
-    static validate(multiPoint) {
-        if (multiPoint.type !== 'MultiPoint' || !type_1.isArray(multiPoint.coordinates)) {
-            return false;
-        }
-        for (let point of multiPoint.coordinates) {
-            if (!type_1.isNumber(point[0]) || !type_1.isNumber(point[1])) {
-                return false;
-            }
-        }
-        return true;
-    }
-    get _internalType() {
-        return symbol_1.SYMBOL_GEO_MULTI_POINT;
-    }
-}
-exports.MultiPoint = MultiPoint;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const symbol_1 = require("../helper/symbol");
+const point_1 = require("./point");
+const type_1 = require("../utils/type");
+class MultiPoint {
+    constructor(points) {
+        if (!type_1.isArray(points)) {
+            throw new TypeError(`"points" must be of type Point[]. Received type ${typeof points}`);
+        }
+        if (points.length === 0) {
+            throw new Error('"points" must contain 1 point at least');
+        }
+        points.forEach(point => {
+            if (!(point instanceof point_1.Point)) {
+                throw new TypeError(`"points" must be of type Point[]. Received type ${typeof point}[]`);
+            }
+        });
+        this.points = points;
+    }
+    parse(key) {
+        return {
+            [key]: {
+                type: 'MultiPoint',
+                coordinates: this.points.map(point => point.toJSON().coordinates)
+            }
+        };
+    }
+    toJSON() {
+        return {
+            type: 'MultiPoint',
+            coordinates: this.points.map(point => point.toJSON().coordinates)
+        };
+    }
+    static validate(multiPoint) {
+        if (multiPoint.type !== 'MultiPoint' || !type_1.isArray(multiPoint.coordinates)) {
+            return false;
+        }
+        for (let point of multiPoint.coordinates) {
+            if (!type_1.isNumber(point[0]) || !type_1.isNumber(point[1])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    get _internalType() {
+        return symbol_1.SYMBOL_GEO_MULTI_POINT;
+    }
+}
+exports.MultiPoint = MultiPoint;

package/dist/commonjs/geo/multiPolygon.d.ts

@@ -1,18 +1,18 @@
-import { Polygon } from './polygon';
-import { ISerializedMultiPolygon } from './interface';
-export declare class MultiPolygon {
-    readonly polygons: Polygon[];
-    constructor(polygons: Polygon[]);
-    parse(key: any): {
-        [x: number]: {
-            type: string;
-            coordinates: number[][][][];
-        };
-    };
-    toJSON(): {
-        type: string;
-        coordinates: number[][][][];
-    };
-    static validate(multiPolygon: ISerializedMultiPolygon): boolean;
-    readonly _internalType: import("../utils/symbol").InternalSymbol;
-}
+import { Polygon } from './polygon';
+import { ISerializedMultiPolygon } from './interface';
+export declare class MultiPolygon {
+    readonly polygons: Polygon[];
+    constructor(polygons: Polygon[]);
+    parse(key: any): {
+        [x: number]: {
+            type: string;
+            coordinates: number[][][][];
+        };
+    };
+    toJSON(): {
+        type: string;
+        coordinates: number[][][][];
+    };
+    static validate(multiPolygon: ISerializedMultiPolygon): boolean;
+    readonly _internalType: import("../utils/symbol").InternalSymbol;
+}

package/dist/commonjs/geo/multiPolygon.js

@@ -1,62 +1,62 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const symbol_1 = require("../helper/symbol");
-const type_1 = require("../utils/type");
-const polygon_1 = require("./polygon");
-class MultiPolygon {
-    constructor(polygons) {
-        if (!type_1.isArray(polygons)) {
-            throw new TypeError(`"polygons" must be of type Polygon[]. Received type ${typeof polygons}`);
-        }
-        if (polygons.length === 0) {
-            throw new Error('MultiPolygon must contain 1 polygon at least');
-        }
-        for (let polygon of polygons) {
-            if (!(polygon instanceof polygon_1.Polygon)) {
-                throw new TypeError(`"polygon" must be of type Polygon[]. Received type ${typeof polygon}[]`);
-            }
-        }
-        this.polygons = polygons;
-    }
-    parse(key) {
-        return {
-            [key]: {
-                type: 'MultiPolygon',
-                coordinates: this.polygons.map(polygon => {
-                    return polygon.lines.map(line => {
-                        return line.points.map(point => [point.longitude, point.latitude]);
-                    });
-                })
-            }
-        };
-    }
-    toJSON() {
-        return {
-            type: 'MultiPolygon',
-            coordinates: this.polygons.map(polygon => {
-                return polygon.lines.map(line => {
-                    return line.points.map(point => [point.longitude, point.latitude]);
-                });
-            })
-        };
-    }
-    static validate(multiPolygon) {
-        if (multiPolygon.type !== 'MultiPolygon' || !type_1.isArray(multiPolygon.coordinates)) {
-            return false;
-        }
-        for (let polygon of multiPolygon.coordinates) {
-            for (let line of polygon) {
-                for (let point of line) {
-                    if (!type_1.isNumber(point[0]) || !type_1.isNumber(point[1])) {
-                        return false;
-                    }
-                }
-            }
-        }
-        return true;
-    }
-    get _internalType() {
-        return symbol_1.SYMBOL_GEO_MULTI_POLYGON;
-    }
-}
-exports.MultiPolygon = MultiPolygon;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const symbol_1 = require("../helper/symbol");
+const type_1 = require("../utils/type");
+const polygon_1 = require("./polygon");
+class MultiPolygon {
+    constructor(polygons) {
+        if (!type_1.isArray(polygons)) {
+            throw new TypeError(`"polygons" must be of type Polygon[]. Received type ${typeof polygons}`);
+        }
+        if (polygons.length === 0) {
+            throw new Error('MultiPolygon must contain 1 polygon at least');
+        }
+        for (let polygon of polygons) {
+            if (!(polygon instanceof polygon_1.Polygon)) {
+                throw new TypeError(`"polygon" must be of type Polygon[]. Received type ${typeof polygon}[]`);
+            }
+        }
+        this.polygons = polygons;
+    }
+    parse(key) {
+        return {
+            [key]: {
+                type: 'MultiPolygon',
+                coordinates: this.polygons.map(polygon => {
+                    return polygon.lines.map(line => {
+                        return line.points.map(point => [point.longitude, point.latitude]);
+                    });
+                })
+            }
+        };
+    }
+    toJSON() {
+        return {
+            type: 'MultiPolygon',
+            coordinates: this.polygons.map(polygon => {
+                return polygon.lines.map(line => {
+                    return line.points.map(point => [point.longitude, point.latitude]);
+                });
+            })
+        };
+    }
+    static validate(multiPolygon) {
+        if (multiPolygon.type !== 'MultiPolygon' || !type_1.isArray(multiPolygon.coordinates)) {
+            return false;
+        }
+        for (let polygon of multiPolygon.coordinates) {
+            for (let line of polygon) {
+                for (let point of line) {
+                    if (!type_1.isNumber(point[0]) || !type_1.isNumber(point[1])) {
+                        return false;
+                    }
+                }
+            }
+        }
+        return true;
+    }
+    get _internalType() {
+        return symbol_1.SYMBOL_GEO_MULTI_POLYGON;
+    }
+}
+exports.MultiPolygon = MultiPolygon;

package/dist/commonjs/geo/point.d.ts

@@ -1,19 +1,19 @@
-import { ISerializedPoint } from './interface';
-export declare class Point {
-    readonly latitude: number;
-    readonly longitude: number;
-    constructor(longitude: number, latitude: number);
-    parse(key: any): {
-        [x: number]: {
-            type: string;
-            coordinates: number[];
-        };
-    };
-    toJSON(): {
-        type: string;
-        coordinates: number[];
-    };
-    toReadableString(): string;
-    static validate(point: ISerializedPoint): boolean;
-    readonly _internalType: import("../utils/symbol").InternalSymbol;
-}
+import { ISerializedPoint } from './interface';
+export declare class Point {
+    readonly latitude: number;
+    readonly longitude: number;
+    constructor(longitude: number, latitude: number);
+    parse(key: any): {
+        [x: number]: {
+            type: string;
+            coordinates: number[];
+        };
+    };
+    toJSON(): {
+        type: string;
+        coordinates: number[];
+    };
+    toReadableString(): string;
+    static validate(point: ISerializedPoint): boolean;
+    readonly _internalType: import("../utils/symbol").InternalSymbol;
+}