@dra2020/baseclient 1.0.13 → 1.0.14

package/dist/poly/shamos.d.ts

@@ -0,0 +1 @@
+export declare function selfIntersectFast(poly: any): boolean;

package/dist/poly/simplify.d.ts

@@ -0,0 +1,2 @@
+export declare type Point = [number, number];
+export declare function simplify(points: Point[], tolerance?: number, highestQuality?: boolean): Point[];

package/dist/poly/topo.d.ts

@@ -0,0 +1,46 @@
+import * as FSM from '../fsm/all';
+import * as P from './poly';
+import * as Q from './quad';
+export declare type Topo = any;
+export declare function topoFromCollection(col: any): Topo;
+export declare function topoContiguity(topo: Topo): any;
+export declare function topoToFeature(topo: Topo, geoid: string): any;
+export declare function topoToCollection(topo: Topo): any;
+export interface SimplifyOptions {
+    minArea?: number;
+}
+export declare function topoSimplifyCollection(col: any, options?: SimplifyOptions): any;
+export declare function topoMerge(topo: Topo, geoids: string[]): any;
+export declare function topoMergeFeatures(topo: Topo, features: any[]): any;
+declare class FsmIncrementalUnion extends FSM.Fsm {
+    options: P.TickOptions;
+    key: any;
+    map: any;
+    result: any;
+    work: Q.WorkDone;
+    constructor(env: FSM.FsmEnvironment, options: P.TickOptions, key: any, map?: any);
+    matches(key: any): boolean;
+    recompute(map: any): void;
+    cancel(): void;
+    tick(): void;
+}
+export interface TopoUnionResult {
+    key: any;
+    poly: any;
+    work: Q.WorkDone;
+}
+export declare class FsmTopoUnion extends FSM.Fsm {
+    options: P.TickOptions;
+    unions: FsmIncrementalUnion[];
+    work: Q.WorkDone;
+    constructor(env: FSM.FsmEnvironment, options?: P.TickOptions);
+    get result(): TopoUnionResult[];
+    cancel(): void;
+    cancelOne(key: any): void;
+    recompute(key: any, map: any): void;
+    tick(): void;
+}
+export declare function topoPacked(topo: any): boolean;
+export declare function topoPack(topo: any): any;
+export declare function topoUnpack(topo: any): any;
+export {};

package/dist/poly/union.d.ts

@@ -0,0 +1,48 @@
+import * as FSM from '../fsm/all';
+import * as Poly from './poly';
+import * as Q from './quad';
+export declare function polyIntersects(p1: any, p2: any): boolean;
+declare class FsmDifference extends FSM.Fsm {
+    accum: any;
+    polys: any[];
+    work: Q.WorkDone;
+    constructor(env: FSM.FsmEnvironment, accum?: any, polys?: any[]);
+    initialize(accum: any, polys: any[]): void;
+    cancel(): void;
+    get result(): any;
+    tick(): void;
+}
+declare class FsmIncrementalUnion extends FSM.Fsm {
+    options: Poly.TickOptions;
+    key: any;
+    map: any;
+    result: any;
+    lastCompleteMap: any;
+    lastCompleteResult: any;
+    toSub: any[];
+    fsmUnion: Q.FsmQuadTree;
+    fsmDifference: FsmDifference;
+    work: Q.WorkDone;
+    constructor(env: FSM.FsmEnvironment, options: Poly.TickOptions, key: any, map?: any);
+    matches(key: any): boolean;
+    recompute(map: any): void;
+    cancel(): void;
+    tick(): void;
+}
+export interface UnionResult {
+    key: any;
+    poly: any;
+    work: Q.WorkDone;
+}
+export declare class FsmUnion extends FSM.Fsm {
+    options: Poly.TickOptions;
+    unions: FsmIncrementalUnion[];
+    work: Q.WorkDone;
+    constructor(env: FSM.FsmEnvironment, options?: Poly.TickOptions);
+    get result(): UnionResult[];
+    cancel(): void;
+    cancelOne(key: any): void;
+    recompute(key: any, map: any): void;
+    tick(): void;
+}
+export {};

package/dist/storage/all.d.ts

@@ -0,0 +1,4 @@
+export * from './env';
+export * from './storage';
+export * from './datablob';
+export * from './splitsblob';

package/dist/storage/datablob.d.ts

@@ -0,0 +1,9 @@
+import { Environment } from './env';
+import * as Storage from './storage';
+export declare class DataBlob extends Storage.StorageBlob {
+    constructor(env: Environment, params: Storage.BlobParams);
+    get env(): Environment;
+    get json(): any;
+    static createForJSON(env: Environment, id: string): DataBlob;
+    static createForStream(env: Environment, id: string, bucket?: string): DataBlob;
+}

package/dist/storage/env.d.ts

@@ -0,0 +1,10 @@
+import * as Context from '../context/all';
+import * as FSM from '../fsm/all';
+import * as LogAbstract from '../logabstract/all';
+import * as Storage from './storage';
+export interface Environment {
+    context: Context.IContext;
+    log: LogAbstract.ILog;
+    fsmManager: FSM.FsmManager;
+    storageManager: Storage.StorageManager;
+}

package/dist/storage/splitsblob.d.ts

@@ -0,0 +1,13 @@
+import { Environment } from './env';
+import * as Storage from './storage';
+export declare class SplitsBlob extends Storage.StorageBlob {
+    ls: {
+        [key: string]: Storage.BlobProperties;
+    };
+    constructor(env: Environment, params: Storage.BlobParams);
+    get env(): Environment;
+    get collection(): any;
+    static createForLs(env: Environment): SplitsBlob;
+    static createForUpload(env: Environment, id: string, collection: any): SplitsBlob;
+    static createForDownload(env: Environment, id: string): SplitsBlob;
+}

package/dist/storage/storage.d.ts

@@ -0,0 +1,166 @@
+/// <reference types="node" />
+import * as stream from 'stream';
+import * as FSM from '../fsm/all';
+import { Environment } from './env';
+export declare const ESuccess: number;
+export declare const EFail: number;
+export declare const ENotFound: number;
+export declare const EPending: number;
+export declare const EBadFormat: number;
+export declare type StorageState = number;
+export declare const StorageStateClean = 0;
+export declare const StorageStateDirty = 1;
+export declare const StorageStateSaving = 2;
+export declare const StorageStateLoading = 4;
+export declare const StorageStateLoadCanceled = 8;
+export declare const StorageStateLoadFailed = 16;
+export declare const StorageStateDeleting = 32;
+export declare const StorageStateDeleted = 64;
+export declare const StorageStateListing = 128;
+export declare type BucketMap = {
+    [key: string]: string;
+};
+export declare const BucketDefault = "default";
+export declare const BucketDev = "development";
+export declare const BucketProd = "production";
+export declare const BucketLogs = "logs";
+export declare type TransferUrlOp = 'putObject' | 'getObject';
+export interface TransferParams {
+    op: TransferUrlOp;
+    contentType?: string;
+}
+export declare type DispositionType = 'object' | 'string' | 'buffer' | 'stream' | 'filepath';
+export declare type LoadToFilter = (blob: StorageBlob, a: any) => any;
+export interface BlobParams {
+    id: string;
+    bucket?: string;
+    saveFromType?: DispositionType;
+    saveFrom?: any;
+    loadToType?: DispositionType;
+    loadTo?: any;
+    loadToFilter?: LoadToFilter;
+    deleteAfterLoad?: boolean;
+    suppressDeleteError?: boolean;
+    ContentEncoding?: string;
+    ContentType?: string;
+    CacheControl?: string;
+}
+export declare class FsmTransferUrl extends FSM.Fsm {
+    bucket: string;
+    key: string;
+    params: TransferParams;
+    url: string;
+    constructor(env: Environment, bucket: string, params: TransferParams);
+}
+export interface BlobProperties {
+    Key?: string;
+    ContentLength?: number;
+    ContentDisposition?: string;
+    ContentEncoding?: string;
+    ContentType?: string;
+    ContentLanguage?: string;
+    LastModified?: string;
+    ETag?: string;
+}
+export interface MultiBufferList {
+    buf: Buffer;
+    next: MultiBufferList;
+}
+export declare class MultiBufferPassThrough extends stream.Duplex {
+    _dopush: boolean;
+    _head: MultiBufferList;
+    _tail: MultiBufferList;
+    constructor();
+    _read(): void;
+    _dopushing(): void;
+    _pushChunk(chunk: any): void;
+    _write(chunk: any, encoding: string, cb: any): void;
+    _done(): void;
+    _flush(cb: any): void;
+    _transform(chunk: any, encoding: string, cb: any): void;
+}
+export declare class StorageBlob {
+    _env: Environment;
+    params: BlobParams;
+    state: StorageState;
+    tStarted: Date;
+    fsmSave: FSM.Fsm;
+    fsmLoad: FSM.Fsm;
+    fsmDel: FSM.Fsm;
+    fsmList: FSM.Fsm;
+    _props: FSM.FsmArray;
+    _keys: FSM.FsmArray;
+    constructor(env: Environment, params: BlobParams);
+    get env(): Environment;
+    get keys(): string[];
+    get props(): BlobProperties[];
+    resetList(): void;
+    get fsmArray(): FSM.Fsm;
+    setSaveFrom(t: DispositionType, data: any): void;
+    setLoadTo(t: DispositionType): void;
+    needSave(): boolean;
+    isSaving(): boolean;
+    isLoading(): boolean;
+    isListing(): boolean;
+    setListing(): void;
+    setListed(): void;
+    isDeleting(): boolean;
+    isDeleted(): boolean;
+    isLoadFailed(): boolean;
+    isValid(): boolean;
+    isReadable(): boolean;
+    isDirty(): boolean;
+    isSafeToUnload(): boolean;
+    setDirty(): void;
+    setInit(): void;
+    setLoading(): void;
+    setLoaded(result: number): void;
+    setSaving(): void;
+    setSaved(result: number): void;
+    setDeleting(): void;
+    setDeleted(result: number): void;
+    startLoad(sm: StorageManager): void;
+    startHead(sm: StorageManager): void;
+    checkSave(sm: StorageManager): void;
+    startDelete(sm: StorageManager): void;
+    endSave(br: BlobRequest): void;
+    endLoad(br: BlobRequest): void;
+    endHead(br: BlobRequest): void;
+    endDelete(br: BlobRequest): void;
+    startList(sm: StorageManager, continuationToken?: string): void;
+    endList(br: BlobRequest): void;
+    toLoadStream(): stream.Readable;
+    setLoadStream(rs: stream.Readable): void;
+}
+export interface BlobRequest {
+    blob: StorageBlob;
+    result(): number;
+    asBuffer(): Buffer;
+    asString(): string;
+    asError(): string;
+    asProps(): BlobProperties[];
+    continuationToken(): string;
+}
+export interface BlobRequestIndex {
+    [key: string]: BlobRequest;
+}
+export declare class StorageManager {
+    _env: Environment;
+    saveBlobIndex: BlobRequestIndex;
+    loadBlobIndex: BlobRequestIndex;
+    headBlobIndex: BlobRequestIndex;
+    delBlobIndex: BlobRequestIndex;
+    lsBlobIndex: BlobRequestIndex;
+    onList: any;
+    bucketMap: BucketMap;
+    constructor(env: Environment, bucketMap?: BucketMap);
+    save(blob: StorageBlob): void;
+    load(blob: StorageBlob): void;
+    del(blob: StorageBlob): void;
+    head(blob: StorageBlob): void;
+    ls(blob: StorageBlob, continuationToken?: string): void;
+    createTransferUrl(params: TransferParams): FsmTransferUrl;
+    on(eventName: string, cb: any): void;
+    off(eventName: string, cb: any): void;
+    emit(eventName: string, blob: StorageBlob): void;
+}

package/dist/storages3/all.d.ts

@@ -0,0 +1 @@
+export * from './s3';

package/dist/storages3/s3.d.ts

@@ -0,0 +1,62 @@
+/// <reference types="node" />
+import * as Context from '../context/all';
+import * as Storage from '../storage/all';
+import * as LogAbstract from '../logabstract/all';
+import * as FSM from '../fsm/all';
+export interface Environment {
+    context: Context.IContext;
+    log: LogAbstract.ILog;
+    fsmManager: FSM.FsmManager;
+    storageManager: Storage.StorageManager;
+}
+declare class S3Request implements Storage.BlobRequest {
+    blob: Storage.StorageBlob;
+    req: any;
+    res: any;
+    data: any;
+    err: any;
+    constructor(blob: Storage.StorageBlob);
+    continuationToken(): string;
+    result(): number;
+    decode(): void;
+    asString(): string;
+    asBuffer(): Buffer;
+    _dataToProps(data: any): Storage.BlobProperties;
+    asProps(): Storage.BlobProperties[];
+    asError(): string;
+}
+export declare class FsmStreamLoader extends FSM.Fsm {
+    sm: StorageManager;
+    blob: Storage.StorageBlob;
+    param: any;
+    err: any;
+    contentLength: number;
+    contentPos: number;
+    readStream: Storage.MultiBufferPassThrough;
+    passThrough: Storage.MultiBufferPassThrough;
+    constructor(env: Environment, sm: StorageManager, blob: Storage.StorageBlob);
+    get env(): Environment;
+    setStreamError(): void;
+    tick(): void;
+}
+export declare class FsmTransferUrl extends Storage.FsmTransferUrl {
+    storageManager: StorageManager;
+    constructor(env: Environment, bucket: string, params: Storage.TransferParams);
+}
+export declare class StorageManager extends Storage.StorageManager {
+    s3: any;
+    count: number;
+    constructor(env: Environment, bucketMap?: Storage.BucketMap);
+    get env(): Environment;
+    lookupBucket(s: string): string;
+    blobBucket(blob: Storage.StorageBlob): string;
+    load(blob: Storage.StorageBlob): void;
+    _finishLoad(blob: Storage.StorageBlob, id: string, rq: S3Request, err: any, data: any): void;
+    head(blob: Storage.StorageBlob): void;
+    safeSaveFromPath(blob: Storage.StorageBlob, rq: S3Request, id: string, trace: LogAbstract.AsyncTimer): any;
+    save(blob: Storage.StorageBlob): void;
+    del(blob: Storage.StorageBlob): void;
+    ls(blob: Storage.StorageBlob, continuationToken?: string): void;
+    createTransferUrl(params: Storage.TransferParams): Storage.FsmTransferUrl;
+}
+export {};

package/dist/util/all.d.ts

@@ -0,0 +1,5 @@
+export * from './util';
+export * from './countedhash';
+export * from './indexedarray';
+export * from './gradient';
+export * from './bintrie';

package/dist/util/bintrie.d.ts

@@ -0,0 +1,93 @@
+export interface Coder {
+    encoder: {
+        encode: (s: string) => Uint8Array;
+    };
+    decoder: {
+        decode: (u8: Uint8Array) => string;
+    };
+}
+export declare function s2u8(coder: Coder, s: string): Uint8Array;
+export declare function u82s(coder: Coder, u8: Uint8Array, offset: number, n: number): string;
+interface Fragment {
+    count: number;
+    used: number;
+    offset: number;
+    s: string;
+    u8?: Uint8Array;
+}
+declare type FragmentTable = {
+    [frag: string]: Fragment;
+};
+declare type FragmentPair = {
+    f1: Fragment;
+    f2: Fragment;
+    offset?: number;
+};
+declare class ValueTable {
+    coder: Coder;
+    ab: ArrayBuffer;
+    u8: Uint8Array;
+    u32: Uint32Array;
+    constructor(coder: Coder);
+    static fromBuffer(coder: Coder, ab: ArrayBuffer, offset: number, length: number): ValueTable;
+    fromOffset(offset: number): string;
+}
+declare class ValueTableBuilder {
+    coder: Coder;
+    values: string[];
+    fragments: FragmentTable;
+    pairs: {
+        [value: string]: FragmentPair;
+    };
+    ab: ArrayBuffer;
+    u8: Uint8Array;
+    u32: Uint32Array;
+    constructor(coder: Coder);
+    static fromStrings(coder: Coder, values: string[]): ValueTableBuilder;
+    validateStrings(values: string[]): void;
+    addFragment(s: string): void;
+    extractFragments(s: string): void;
+    pickFragments(s: string): void;
+    toOffset(s: string): number;
+    toBinary(): void;
+}
+export declare type StringMap = {
+    [key: string]: string;
+};
+interface UnpackedNode {
+    suffix: Uint8Array;
+    value: number;
+    bytes: number[] | null;
+    nodes: UnpackedNode[] | null;
+}
+export declare class BinTrie {
+    coder: Coder;
+    ab: ArrayBuffer;
+    vt: ValueTable;
+    u8: Uint8Array;
+    i32: Int32Array;
+    constructor(coder: Coder);
+    static fromBuffer(coder: Coder, ab: ArrayBuffer): BinTrie;
+    get(key: string): string;
+}
+export declare class BinTrieBuilder {
+    coder: Coder;
+    root: UnpackedNode;
+    vtb: ValueTableBuilder;
+    vt: ValueTable;
+    ab: ArrayBuffer;
+    u8: Uint8Array;
+    i32: Int32Array;
+    constructor(coder: Coder);
+    nodeCount(node: UnpackedNode): number;
+    nodeBranching(node: UnpackedNode, counts: number[]): number;
+    nodeValueCount(node: UnpackedNode): number;
+    nodeByteLength(node: UnpackedNode): number;
+    addString(s: string, value: number): void;
+    dedup(node: UnpackedNode): void;
+    getUnpacked(key: string): string;
+    packNode(node: UnpackedNode, byteOffset: number): number;
+    toBinary(): void;
+    static fromMap(coder: Coder, o: StringMap): BinTrie;
+}
+export {};

package/dist/util/countedhash.d.ts

@@ -0,0 +1,19 @@
+export declare class CountedHash {
+    n: number;
+    val: {
+        [id: string]: true | null;
+    };
+    constructor();
+    get length(): number;
+    indeterminate(id: string): boolean;
+    test(id: string): boolean;
+    set(id: string, val?: true | null): void;
+    clear(id: string): void;
+    apply(vals: {
+        [id: string]: boolean | null;
+    }): void;
+    empty(): void;
+    asArray(): string[];
+    asString(): string;
+    forEach(f: (id: string) => void): void;
+}

package/dist/util/gradient.d.ts

@@ -0,0 +1,15 @@
+interface RGB {
+    r: number;
+    g: number;
+    b: number;
+}
+export interface Stop {
+    color: string;
+    stop: number;
+    rgb?: RGB;
+}
+export declare type GradientStops = Stop[];
+export declare function execGradient(stops: GradientStops, value: number): string;
+export declare function parseGradient(sStops: string): GradientStops;
+export declare function asCSSGradient(stops: GradientStops): string;
+export {};

package/dist/util/indexedarray.d.ts

@@ -0,0 +1,15 @@
+export declare class IndexedArray {
+    o: any;
+    a: any[];
+    constructor();
+    ensure(): void;
+    asArray(): any[];
+    get length(): number;
+    test(s: string): boolean;
+    set(s: string): void;
+    setAll(a: string[]): void;
+    clear(s: string): void;
+    at(i: number): string;
+    empty(): void;
+    forEach(f: (s: string) => void): void;
+}

package/dist/util/util.d.ts

@@ -0,0 +1,68 @@
+export declare type DateString = string;
+export declare function Now(): DateString;
+export declare class Elapsed {
+    tStart: any;
+    tDur: any;
+    constructor(bStart?: boolean);
+    start(): void;
+    end(): void;
+    ms(): number;
+    nano(): number;
+}
+export declare class MultiTimer {
+    _overall: Elapsed;
+    _segment: Elapsed;
+    _msAggregate: number;
+    constructor(bStart?: boolean);
+    start(): void;
+    end(): number;
+    segstart(): void;
+    segend(): number;
+    get overall(): number;
+    get aggregate(): number;
+}
+export declare class Deadline {
+    msDelta: number;
+    elapsed: Elapsed;
+    constructor(msDelta: number);
+    start(): void;
+    done(): boolean;
+}
+export declare function createGuid(): string;
+export declare function sizeof(a: any): number;
+export declare function depthof(a: any): number;
+export declare function isEmpty(o: any): boolean;
+export declare function countKeys(o: any): number;
+export declare function nthProperty(o: any, n?: number): any;
+export declare function nthKey(o: any, n?: number): any;
+export declare function partialEqual(o: any, subset: any): boolean;
+export interface EqOptions {
+    omitKey?: {
+        [key: string]: boolean;
+    };
+    unorderedArrays?: boolean;
+    emptyStringIsNull: boolean;
+}
+export declare function deepEqual(o1: any, o2: any, options?: EqOptions): boolean;
+export declare function prettyDate(d: Date): string;
+export declare function relativeDate(d: Date): string;
+export declare function recentDate(d: Date): string;
+export declare function textToHtml(sText: string): string;
+export declare function shallowCopy(src: any): any;
+export declare function shallowAssign(o1: any, o2: any): any;
+export declare function shallowDelete(o1: any, o2: any): any;
+export declare function shallowAssignImmutable(o1: any, o2: any): any;
+export declare function shallowEqual(o1: any, o2: any): boolean;
+export declare function deepCopy(src: any): any;
+export declare function deepAccum(accum: any, o: any): any;
+export declare function precisionRound(n: number, p: number): number;
+export declare function percentString(num: number, den: number, precision?: number): string;
+export declare function hash(s: string): number;
+export declare function hashObject(o: any): number;
+export declare function toHex(n: number): string;
+export declare function toRGBA(color: string, alpha: number): string;
+export declare function toRGBAIntensity(color: string, intensity: number, alpha: number): string;
+export declare function distance(x0: number, y0: number, x1: number, y1: number): number;
+export declare function deg2rad(num: number): number;
+export declare function rad2deg(num: number): number;
+export declare function wrapLon(lon: number): number;

package/docs/context.md

@@ -0,0 +1,2 @@
+# context
+Define environmental context for program execution.

package/docs/dbabstract.md

@@ -0,0 +1,2 @@
+# dbabstract
+Abstract database layer to allow local mock.

package/docs/dbdynamo.md

@@ -0,0 +1,2 @@
+# dbdynamo
+Dynamo abstraction layer