@cloudbase/database 1.4.1 → 1.4.3-alpha.0

package/dist/esm/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/esm/geo/multiLineString.js

@@ -1,53 +1,53 @@
-import { SYMBOL_GEO_MULTI_LINE_STRING } from '../helper/symbol';
-import { isArray, isNumber } from '../utils/type';
-import { LineString } from './lineString';
-export class MultiLineString {
-    constructor(lines) {
-        if (!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)) {
-                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' || !isArray(multiLineString.coordinates)) {
-            return false;
-        }
-        for (let line of multiLineString.coordinates) {
-            for (let point of line) {
-                if (!isNumber(point[0]) || !isNumber(point[1])) {
-                    return false;
-                }
-            }
-        }
-        return true;
-    }
-    get _internalType() {
-        return SYMBOL_GEO_MULTI_LINE_STRING;
-    }
-}
+import { SYMBOL_GEO_MULTI_LINE_STRING } from '../helper/symbol';
+import { isArray, isNumber } from '../utils/type';
+import { LineString } from './lineString';
+export class MultiLineString {
+    constructor(lines) {
+        if (!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)) {
+                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' || !isArray(multiLineString.coordinates)) {
+            return false;
+        }
+        for (let line of multiLineString.coordinates) {
+            for (let point of line) {
+                if (!isNumber(point[0]) || !isNumber(point[1])) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+    get _internalType() {
+        return SYMBOL_GEO_MULTI_LINE_STRING;
+    }
+}

package/dist/esm/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/esm/geo/multiPoint.js

@@ -1,47 +1,47 @@
-import { SYMBOL_GEO_MULTI_POINT } from '../helper/symbol';
-import { Point } from './point';
-import { isArray, isNumber } from '../utils/type';
-export class MultiPoint {
-    constructor(points) {
-        if (!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)) {
-                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' || !isArray(multiPoint.coordinates)) {
-            return false;
-        }
-        for (let point of multiPoint.coordinates) {
-            if (!isNumber(point[0]) || !isNumber(point[1])) {
-                return false;
-            }
-        }
-        return true;
-    }
-    get _internalType() {
-        return SYMBOL_GEO_MULTI_POINT;
-    }
-}
+import { SYMBOL_GEO_MULTI_POINT } from '../helper/symbol';
+import { Point } from './point';
+import { isArray, isNumber } from '../utils/type';
+export class MultiPoint {
+    constructor(points) {
+        if (!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)) {
+                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' || !isArray(multiPoint.coordinates)) {
+            return false;
+        }
+        for (let point of multiPoint.coordinates) {
+            if (!isNumber(point[0]) || !isNumber(point[1])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    get _internalType() {
+        return SYMBOL_GEO_MULTI_POINT;
+    }
+}

package/dist/esm/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/esm/geo/multiPolygon.js

@@ -1,59 +1,59 @@
-import { SYMBOL_GEO_MULTI_POLYGON } from '../helper/symbol';
-import { isArray, isNumber } from '../utils/type';
-import { Polygon } from './polygon';
-export class MultiPolygon {
-    constructor(polygons) {
-        if (!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)) {
-                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' || !isArray(multiPolygon.coordinates)) {
-            return false;
-        }
-        for (let polygon of multiPolygon.coordinates) {
-            for (let line of polygon) {
-                for (let point of line) {
-                    if (!isNumber(point[0]) || !isNumber(point[1])) {
-                        return false;
-                    }
-                }
-            }
-        }
-        return true;
-    }
-    get _internalType() {
-        return SYMBOL_GEO_MULTI_POLYGON;
-    }
-}
+import { SYMBOL_GEO_MULTI_POLYGON } from '../helper/symbol';
+import { isArray, isNumber } from '../utils/type';
+import { Polygon } from './polygon';
+export class MultiPolygon {
+    constructor(polygons) {
+        if (!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)) {
+                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' || !isArray(multiPolygon.coordinates)) {
+            return false;
+        }
+        for (let polygon of multiPolygon.coordinates) {
+            for (let line of polygon) {
+                for (let point of line) {
+                    if (!isNumber(point[0]) || !isNumber(point[1])) {
+                        return false;
+                    }
+                }
+            }
+        }
+        return true;
+    }
+    get _internalType() {
+        return SYMBOL_GEO_MULTI_POLYGON;
+    }
+}

package/dist/esm/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;
+}

package/dist/esm/geo/point.js

@@ -1,40 +1,40 @@
-import { Validate } from '../validate';
-import { SYMBOL_GEO_POINT } from '../helper/symbol';
-import { isArray } from '../utils/type';
-export class Point {
-    constructor(longitude, latitude) {
-        Validate.isGeopoint('longitude', longitude);
-        Validate.isGeopoint('latitude', latitude);
-        this.longitude = longitude;
-        this.latitude = latitude;
-    }
-    parse(key) {
-        return {
-            [key]: {
-                type: 'Point',
-                coordinates: [this.longitude, this.latitude]
-            }
-        };
-    }
-    toJSON() {
-        return {
-            type: 'Point',
-            coordinates: [
-                this.longitude,
-                this.latitude,
-            ],
-        };
-    }
-    toReadableString() {
-        return `[${this.longitude},${this.latitude}]`;
-    }
-    static validate(point) {
-        return point.type === 'Point' &&
-            isArray(point.coordinates) &&
-            Validate.isGeopoint('longitude', point.coordinates[0]) &&
-            Validate.isGeopoint('latitude', point.coordinates[1]);
-    }
-    get _internalType() {
-        return SYMBOL_GEO_POINT;
-    }
-}
+import { Validate } from '../validate';
+import { SYMBOL_GEO_POINT } from '../helper/symbol';
+import { isArray } from '../utils/type';
+export class Point {
+    constructor(longitude, latitude) {
+        Validate.isGeopoint('longitude', longitude);
+        Validate.isGeopoint('latitude', latitude);
+        this.longitude = longitude;
+        this.latitude = latitude;
+    }
+    parse(key) {
+        return {
+            [key]: {
+                type: 'Point',
+                coordinates: [this.longitude, this.latitude]
+            }
+        };
+    }
+    toJSON() {
+        return {
+            type: 'Point',
+            coordinates: [
+                this.longitude,
+                this.latitude,
+            ],
+        };
+    }
+    toReadableString() {
+        return `[${this.longitude},${this.latitude}]`;
+    }
+    static validate(point) {
+        return point.type === 'Point' &&
+            isArray(point.coordinates) &&
+            Validate.isGeopoint('longitude', point.coordinates[0]) &&
+            Validate.isGeopoint('latitude', point.coordinates[1]);
+    }
+    get _internalType() {
+        return SYMBOL_GEO_POINT;
+    }
+}

package/dist/esm/geo/polygon.d.ts

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