@mapcreator/api 2.8.0 → 3.0.0

package/dist/resources/base/ResourceBase.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ResourceBase.d.ts","sourceRoot":"","sources":["../../../src/resources/base/ResourceBase.js"],"names":[],"mappings":"AA6CA;;;GAGG;AACH;IAoFE;;;OAGG;IACH,kCAEC;IAED;;;;OAIG;IACH,kCAEC;IAED;;;OAGG;IACH,oCAEC;IAED;;;;OAIG;IACH,iDAEC;IAED;;;OAGG;IACH,+BAEC;IA3HD;;;OAGG;IACH,iBAHW,UAAU,cA4DpB;IAUD;;;OAGG;IACH,yBAMC;IAlBD;;;OAGG;IACH,sBAEC;IAnCC,qBAAiC;IACjC,gBAAqB;IACrB,iBAAe;IAwBf,uBAA+D;IAiEjE;;;OAGG;IACH,oCA2BC;IAED;;;;;OAKG;IACH,iBAIC;IAED;;;OAGG;IACH,eAFW,MAAM,MAAM,CAAC,GAAC,MAAM,GAAC,IAAI,QAenC;IAED;;;OAGG;IACH,SAFa,YAAY,CAYxB;IAED;;;;;OAKG;IACH,+DAaC;IAED;;;;OAIG;IACH,uBAwBC;IAED;;;;;;OAMG;IACH,2BALW,MAAM,mBAahB;IAED;;;OAGG;IACH,uBAEC;IAED;;;OAGG;IACH,kBAWC;IAJG,aAAe;IAMnB;;;OAGG;IACH,sBAIC;IAED;;;OAGG;IACH,2BAOC;IAED;;;OAGG;IACH,YAFa,MAAM,CAIlB;IAED;;;;OAIG;IACH,yBAHW,OAAO,GACL,EAAE,CAoBd;IAED;;;;;;;OAOG;IACH,qCANW,MAAM,sBAAoB,kCAE1B,MAAM,GACJ,mBAAmB,CAa/B;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,eAlBW,MAAM,QAAM;YAEL,MAAM;QACX,mBAAmB,CA2C/B;CACF"}

package/dist/resources/index.d.ts

@@ -0,0 +1,45 @@
+export { default as Choropleth } from "./Choropleth";
+export { default as Color } from "./Color";
+export { default as Contract } from "./Contract";
+export { default as Dimension } from "./Dimension";
+export { default as DimensionSet } from "./DimensionSet";
+export { default as Domain } from "./Domain";
+export { default as Faq } from "./Faq";
+export { default as Feature } from "./Feature";
+export { default as Font } from "./Font";
+export { default as FontFamily } from "./FontFamily";
+export { default as Highlight } from "./Highlight";
+export { default as InsetMap } from "./InsetMap";
+export { default as Job } from "./Job";
+export { default as JobResult } from "./JobResult";
+export { default as JobRevision } from "./JobRevision";
+export { default as JobShare } from "./JobShare";
+export { default as JobType } from "./JobType";
+export { default as Language } from "./Language";
+export { default as Layer } from "./Layer";
+export { default as LayerFaq } from "./LayerFaq";
+export { default as Mapstyle } from "./Mapstyle";
+export { default as MapstyleSet } from "./MapstyleSet";
+export { default as Message } from "./Message";
+export { default as Notification } from "./Notification";
+export { default as Organisation } from "./Organisation";
+export { default as Permission } from "./Permission";
+export { default as ProductTour } from "./ProductTour";
+export { default as ProductTourStep } from "./ProductTourStep";
+export { default as Role } from "./Role";
+export { default as Svg } from "./Svg";
+export { default as SvgSet } from "./SvgSet";
+export { default as Tag } from "./Tag";
+export { default as TagType } from "./TagType";
+export { default as User } from "./User";
+export { default as VectorHighlight } from "./VectorHighlight";
+export { default as VectorChoropleth } from "./VectorChoropleth";
+export namespace base {
+    export { CrudBase };
+    export { CrudSetBase };
+    export { ResourceBase };
+}
+import CrudBase from "./base/CrudBase";
+import CrudSetBase from "./base/CrudSetBase";
+import ResourceBase from "./base/ResourceBase";
+//# sourceMappingURL=index.d.ts.map

package/dist/storage/CookiesDriver.d.ts

@@ -0,0 +1,37 @@
+/**
+ * @private
+ * @todo fix
+ */
+export default class CookiesDriver extends DataStoreContract {
+    constructor(prefix?: string);
+    __prefix: string;
+    /**
+     * Cookie name prefix
+     * @returns {String} - Prefix
+     * @private
+     */
+    private get _prefix();
+    /**
+     * Store a value in the storage
+     * @param {String} name - value name
+     * @param {*} value - value
+     * @param {Date|String} [expires=2050-01-01] - Expiration date
+     */
+    set(name: string, value: any, expires?: Date | string): void;
+    /**
+     * @inheritDoc
+     */
+    get(name: any): any;
+    /**
+     * @inheritDoc
+     */
+    remove(name: any): void;
+    /**
+     * Extract cookies and turn them into a object
+     * @returns {Object} - cookies
+     * @private
+     */
+    private _toObject;
+}
+import DataStoreContract from "./DataStoreContract";
+//# sourceMappingURL=CookiesDriver.d.ts.map

package/dist/storage/DataStoreContract.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @private
+ */
+export default class DataStoreContract {
+    /**
+     * If the driver is currently available
+     * @returns {boolean} - Driver availability
+     */
+    static get available(): boolean;
+    /**
+     * If the storage is secure
+     * @returns {boolean} - Secure storage
+     */
+    static get secure(): boolean;
+    /**
+     * Store a value in the storage
+     * @param {String} name - value name
+     * @param {*} value - value
+     * @abstract
+     */
+    set(name: string, value: any): void;
+    /**
+     * Get a value from the store
+     * @param {String} name - value name
+     * @returns {String} - value
+     * @abstract
+     */
+    get(name: string): string;
+    /**
+     * Remove a value from the store
+     * @param {String} name - value name
+     * @abstract
+     */
+    remove(name: string): void;
+    /**
+     * Clear storage
+     */
+    clear(): void;
+    /**
+     * Storage keys
+     * @returns {Array<String>} - Stored keys
+     * @abstract
+     */
+    keys(): Array<string>;
+}
+//# sourceMappingURL=DataStoreContract.d.ts.map

package/dist/storage/DummyDriver.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Used for storing data during tests
+ * @private
+ */
+export default class DummyDriver extends DataStoreContract {
+    static _data: {};
+    /**
+     * Get a value from the store
+     * @param {String} name - value name
+     * @returns {*} - value
+     */
+    get(name: string): any;
+}
+import DataStoreContract from "./DataStoreContract";
+//# sourceMappingURL=DummyDriver.d.ts.map

package/dist/storage/FileDriver.d.ts

@@ -0,0 +1,54 @@
+/**
+ * @private
+ */
+export default class FileDriver extends DataStoreContract {
+    /**
+     * @param {String} path - File storage path
+     * @inheritDoc
+     */
+    constructor(path?: string);
+    _path: string;
+    /**
+     * File storage path
+     * @param {String} value - path
+     */
+    set path(arg: string);
+    /**
+     * File storage path
+     * @returns {String} - path
+     */
+    get path(): string;
+    /**
+     * @inheritDoc
+     */
+    set(name: any, value: any): void;
+    /**
+     * @inheritDoc
+     */
+    get(name: any): any;
+    /**
+     * @inheritDoc
+     */
+    remove(name: any): void;
+    /**
+     * Read file and parse
+     * @returns {Object<String, String>} - Key, value object
+     * @private
+     */
+    private _read;
+    /**
+     * Write data to file
+     * @param {Object<String, String>} obj - Key, value object
+     * @private
+     */
+    private _write;
+    /**
+     * Get fs instance
+     * @returns {fs} - fs instance
+     * @private
+     */
+    private get _fs();
+    __fs: any;
+}
+import DataStoreContract from "./DataStoreContract";
+//# sourceMappingURL=FileDriver.d.ts.map

package/dist/storage/LocalStorageDriver.d.ts

@@ -0,0 +1,13 @@
+/**
+ * @private
+ */
+export default class LocalStorageDriver extends DataStoreContract {
+    /**
+     * LocalStorage name prefix
+     * @returns {String} - Prefix
+     * @private
+     */
+    private static get _prefix();
+}
+import DataStoreContract from "./DataStoreContract";
+//# sourceMappingURL=LocalStorageDriver.d.ts.map

package/dist/storage/StorageManager.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @private
+ */
+export default class StorageManager extends StaticClass {
+    /**
+     * Available storage drivers
+     * @returns {Array.<function>} - Available storage drivers
+     */
+    static get available(): Function[];
+    /**
+     * Get LocalStorageDriver instance
+     * @returns {LocalStorageDriver} - Instance
+     */
+    static get localStorage(): LocalStorageDriver;
+    /**
+     * Get CookiesDriver instance
+     * @returns {CookiesDriver} - Instance
+     */
+    static get cookies(): CookiesDriver;
+    /**
+     * Get FileDriver instance
+     * @returns {FileDriver} - Instance
+     */
+    static get file(): FileDriver;
+    /**
+     * Get DummyDriver instance
+     * @returns {DummyDriver} - Instance
+     */
+    static get dummy(): DummyDriver;
+    /**
+     * Returns the best available storage driver. For a secure driver use {@link StorageManager#secure}
+     * @returns {DataStoreContract} - Best available storage driver
+     */
+    static get best(): DataStoreContract;
+    /**
+     * Returns the a secure storage driver
+     * @returns {DataStoreContract} - Secure storage driver
+     */
+    static get secure(): DataStoreContract;
+}
+import StaticClass from "../utils/StaticClass";
+import LocalStorageDriver from "./LocalStorageDriver";
+import CookiesDriver from "./CookiesDriver";
+import FileDriver from "./FileDriver";
+import DummyDriver from "./DummyDriver";
+//# sourceMappingURL=StorageManager.d.ts.map

package/dist/traits/HandlesImages.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Adds the imageHandler to a resource
+ *
+ * @mixin
+ */
+export default class HandlesImages extends Trait {
+    /**
+     * Handler for item image management
+     * @returns {ImageHandler} - Image handler
+     */
+    get imageHandler(): ImageHandler;
+}
+import Trait from "./Trait";
+import ImageHandler from "../ImageHandler";
+//# sourceMappingURL=HandlesImages.d.ts.map

package/dist/traits/Injectable.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Adds the possibility to inject proxies/methods
+ *
+ * @mixin
+ */
+export default class Injectable extends Trait {
+    /**
+     * Inject a proxy property into future instances
+     *
+     * @param {string|object} name - Name of the property
+     * @param {function?} value - Either a resource or a function that returns a proxy
+     *
+     * @example
+     *
+     * Mapcreator.injectProxy({Domain});
+     *
+     * // After creating new api instance
+     *
+     * api.domains // returns proxy
+     */
+    static injectProxy(name: string | object, value: Function | null): void;
+    /**
+     * Inject a property into future instances
+     *
+     * @param {string|object} name - Name of the property
+     * @param {function?} value - Any function that does not return a proxy
+     *
+     */
+    static inject(name: string | object, value: Function | null): void;
+    /**
+     * Prevent a property from being injected
+     * @param {string} name - Name of the property
+     */
+    static uninject(name: string): void;
+    /**
+     * Inject a proxy
+     * @param {string} name - Name of the property
+     * @param {function?} value - Either a resource or a function that returns a proxy
+     */
+    injectProxy(name: string, value: Function | null): void;
+    /**
+     * Inject a property into the instance
+     *
+     * @param {string|object} name - Name of the property
+     * @param {function?} value - Any function that does not return a proxy
+     *
+     */
+    inject(name: string | object, value: Function | null): void;
+    /**
+     * Revert a proxy injection in instance, won't delete non-injected properties
+     *
+     * @param {string} name - property name
+     * @throws Error when the property was not injected
+     */
+    uninject(name: string): void;
+    _injectProxy(name: any, value: any): void;
+    _inject(name: any, value: any, getter?: boolean): void;
+}
+import Trait from "./Trait";
+//# sourceMappingURL=Injectable.d.ts.map

package/dist/traits/OwnableResource.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Provides a {@link ResourceBase} with functions for dealing with being ownable by an organisation
+ * @mixin
+ */
+export default class OwnableResource extends Trait {
+    /**
+     * Get the list of associated organisations
+     * @returns {SimpleResourceProxy} - A proxy for accessing the resource
+     */
+    get organisations(): SimpleResourceProxy;
+    /**
+     * If the resource can be owned by an organisation
+     * @returns {boolean} - Can be owned by an organisation
+     */
+    get ownable(): boolean;
+}
+import Trait from "./Trait";
+//# sourceMappingURL=OwnableResource.d.ts.map

package/dist/traits/Trait.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Trait interface
+ * @interface
+ * @mixin
+ */
+export default class Trait {
+    /**
+     * Optional initialization method
+     */
+    initializer(): void;
+}
+//# sourceMappingURL=Trait.d.ts.map

package/dist/utils/Logger.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Simple logger implementation
+ */
+export default class Logger {
+    /**
+     * Create a Logger instance
+     * @param {string} [logLevel=warn] - Log level
+     */
+    constructor(logLevel?: string);
+    /**
+     * Set the current log level
+     * @param {string} value - log level
+     * @throws {Logger#getLogLevels}
+     */
+    set logLevel(arg: string);
+    /**
+     * Get the current log level
+     * @returns {string} - log level
+     */
+    get logLevel(): string;
+    /**
+     * Get available log levels
+     * @returns {Array<string>} - Log levels
+     */
+    getLogLevels(): Array<string>;
+    /**
+     * Log a message
+     * @param {string} message - Message to be logged
+     * @param {string} level - Log level
+     */
+    log(message: string, level?: string): void;
+    /**
+     * Log a debug message
+     * @param {string} message - Message to be logged
+     */
+    debug(message: string): void;
+    /**
+     * Log an informative message
+     * @param {string} message - Message to be logged
+     */
+    info(message: string): void;
+    /**
+     * Log a warning message
+     * @param {string} message - Message to be logged
+     */
+    warn(message: string): void;
+    /**
+     * Log an error message
+     * @param {string} message - Message to be logged
+     */
+    error(message: string): void;
+    _logLevel: string;
+    _shouldLog(level: any): boolean;
+}
+//# sourceMappingURL=Logger.d.ts.map

package/dist/utils/Singleton.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Singletons will always return the same instance
+ *
+ * @private
+ */
+export default class Singleton {
+    _instanceCount: number;
+}
+//# sourceMappingURL=Singleton.d.ts.map

package/dist/utils/StaticClass.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Disables the constructor and throws a {@link StaticClassError} when an instance is created.
+ * @protected
+ */
+export default class StaticClass {
+}
+//# sourceMappingURL=StaticClass.d.ts.map

package/dist/utils/Unobservable.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Makes an object and it's children unobservable by frameworks like Vuejs
+ * @protected
+ */
+export default class Unobservable {
+    /**
+     * Overrides the `Object.prototype.toString.call(obj)` result
+     * @returns {string} - type name
+     * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol/toStringTag
+     */
+    get [Symbol.toStringTag](): string;
+}
+//# sourceMappingURL=Unobservable.d.ts.map

package/dist/utils/base64.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Base64 encode data
+ *
+ * @param {Buffer|ArrayBuffer} buffer - input buffer
+ * @author Jon Leighton
+ * @license MIT
+ * @see https://gist.github.com/jonleighton/958841
+ * @returns {string} - base 64 encoded data
+ * @private
+ */
+export function base64Encode(buffer: Buffer | ArrayBuffer): string;
+//# sourceMappingURL=base64.d.ts.map

package/dist/utils/geo.d.ts

@@ -0,0 +1,74 @@
+/**
+ * A geographical point
+ */
+export class GeoPoint {
+    /**
+     * Geographical point
+     * @param {Number} lat - latitude
+     * @param {Number} lng - longitude
+     */
+    constructor(lat: number, lng: number);
+    /**
+     * Set latitude
+     * @param {Number} value - latitude
+     */
+    set lat(arg: number);
+    /**
+     * Get latitude
+     * @returns {Number} - latitude
+     */
+    get lat(): number;
+    /**
+     * Set longitude
+     * @param {Number} value - longitude
+     */
+    set lng(arg: number);
+    /**
+     * Get longitude
+     * @returns {Number} - longitude
+     */
+    get lng(): number;
+    _lat: number;
+    _lng: number;
+    /**
+     * Get data to be JSON encoded
+     * @returns {{lat: Number, lng: Number}} - data
+     */
+    toJSON(): {
+        lat: number;
+        lng: number;
+    };
+}
+/**
+ * Geometric boundary
+ */
+export class GeoBoundary {
+    /**
+     * Geometric boundary
+     * @param {Object} topLeft - top left corner of the boundary
+     * @param {Number} topLeft.lat - top left corner latitude
+     * @param {Number} topLeft.lng - top left corner longitude
+     * @param {Object} bottomRight - bottom right corner of the boundary
+     * @param {Number} bottomRight.lat - bottom right corner latitude
+     * @param {Number} bottomRight.lng - bottom right corner longitude
+     */
+    constructor({ lat: lat1, lng: lng1 }: {
+        lat: number;
+        lng: number;
+    }, { lat: lat2, lng: lng2 }: {
+        lat: number;
+        lng: number;
+    });
+    /**
+     * Top left coordinate
+     * @type {GeoPoint}
+     */
+    topLeft: GeoPoint;
+    /**
+     * Bottom right coordinate
+     * @type {GeoPoint}
+     */
+    bottomRight: GeoPoint;
+    getCenter(): GeoPoint;
+}
+//# sourceMappingURL=geo.d.ts.map

package/dist/utils/hash.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Fast hash function for non-cryptographic use
+ * @param {string} str - Input to be hashed
+ * @returns {string} - String representation of the hash
+ * @private
+ */
+export function fnv32b(str: string): string;
+/**
+ * Fast object hashing for non-cryptographic use
+ * @param {object} data - input data
+ * @returns {string} - String reprisentation of the hash
+ * @private
+ */
+export function hashObject(data: object): string;
+//# sourceMappingURL=hash.d.ts.map

package/dist/utils/helpers.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Get all the pages from a {@link PaginatedResourceListing} or a range
+ * @param {Promise<PaginatedResourceListing>|PaginatedResourceListing} page - Promise that returns a {@link PaginatedResourceListing}
+ * @param {?Number} [start=1] - Start page
+ * @param {?Number} [stop] - Stop page, defaults to the page count if not filled in.
+ * @returns {Promise<Array<ResourceBase>>} - multiple pages
+ * @throws {ApiError} - If the api returns errors
+ * @example
+ * import { helpers } from "@mapcreator/api";
+ *
+ * const promise = api.users.list(1, 50); // 50 per page is more efficient
+ *
+ * helpers.getPaginatedRange(promise).then(data => {
+ *    data.map(row => `[${row.id}] ${row.name}`) // We just want the names
+ *        .forEach(console.log) // Log the names and ids of every user
+ * })
+ */
+export function getPaginatedRange(page: Promise<PaginatedResourceListing> | PaginatedResourceListing, start?: number | null, stop?: number | null): Promise<Array<ResourceBase>>;
+/**
+ * Wraps around ky to make it return cancelable requests
+ * @param {function(*=, *=): Response} fn - ky instance
+ * @returns {function(*=, *=): Response}
+ * @private
+ */
+export function wrapKyCancelable(fn: () => Response): () => Response;
+/**
+ * @typedef {Promise} CancelablePromise
+ * @property {function(): void} cancel - Cancel the promise
+ */
+/**
+ * Makes a promise cancelable by passing it a signal
+ * @param {function} fn - async method
+ * @returns {CancelablePromise}
+ * @private
+ */
+export function makeCancelable(fn: Function): CancelablePromise;
+/**
+ * Convert Date into server format
+ * @param {Date} date - Target
+ * @returns {String} - Formatted date
+ * @private
+ */
+export function serializeUTCDate(date: Date): string;
+export function clone(input: any, clonePrivate?: boolean): any;
+export function delay(ms: number): Promise<any>;
+export type CancelablePromise = Promise<any>;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/utils/node.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Test if the application is running under nodejs
+ * @returns {boolean} - Is the application running under node?
+ * @see https://nodejs.org
+ * @private
+ */
+export function isNode(): boolean;
+/**
+ * Quickly check if the window contains a variable
+ * @param {string} str - target variable
+ * @returns {boolean} - If the window contains the variable
+ * @private
+ */
+export function windowTest(str: string): boolean;
+//# sourceMappingURL=node.d.ts.map

package/dist/utils/reflection.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Tests if the parent is a parent of child
+ * @param {Class|object} parent - Instance or Class
+ * @param {Class|object} child - Instance or Class
+ * @returns {boolean} - is parent a parent of child
+ * @private
+ * @example
+ * class A {}
+ * class B extends A {}
+ * class C extends B {}
+ *
+ * isParentOf(A, C) // true
+ * isParentOf(B, C) // true
+ * isParentOf(C, C) // true
+ * isParentOf(B, A) // false
+ */
+export function isParentOf(parent: Class | object, child: Class | object): boolean;
+/**
+ * Get the name of the value type
+ * @param {*} value - Any value
+ * @private
+ * @returns {string} - Value type name
+ */
+export function getTypeName(value: any): string;
+/**
+ * Mix traits into the target class
+ * @param {Class} baseClass - Target base class for the traits to be applied to
+ * @param {Class<Trait>} mixins - Traits to be applied
+ * @returns {Class} - Constructor with any traits applied
+ * @private
+ */
+export function mix(baseClass: Class, ...mixins: Class<Trait>): Class;
+/**
+ * Checks if the target has a certain trait.
+ *
+ * @param {Class|Object} Subject - Instance or class
+ * @param {Class<Trait>} TraitClass - Trait to check for
+ * @returns {boolean} - If the subject has the trait
+ * @private
+ */
+export function hasTrait(Subject: Class | any, TraitClass: Class<Trait>): boolean;
+import Trait from "../traits/Trait";
+//# sourceMappingURL=reflection.d.ts.map