@dra2020/baseclient 1.0.13 → 1.0.14

package/dist/lambda/lambda.d.ts

@@ -0,0 +1,18 @@
+import * as FSM from '../fsm/all';
+import { Environment } from './env';
+import * as Lambda from 'aws-sdk/clients/lambda';
+export declare class FsmInvoke extends FSM.Fsm {
+    name: string;
+    params: any;
+    result: any;
+    constructor(env: Environment, name: string, params: any);
+    get env(): Environment;
+    tick(): void;
+}
+export declare class Manager extends FSM.Fsm {
+    awslambda: Lambda;
+    constructor(env: Environment);
+    get env(): Environment;
+    invoke(name: string, params?: any): FsmInvoke;
+}
+export declare function create(env: Environment): Manager;

package/dist/logabstract/all.d.ts

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

package/dist/logabstract/log.d.ts

@@ -0,0 +1,26 @@
+import * as Util from '../util/all';
+import * as FSM from '../fsm/all';
+export interface ILog {
+    dump: () => FSM.Fsm;
+    stamp: (o: any) => void;
+    log: (o: any, verbosity?: number) => void;
+    event: (o: any, verbosity?: number) => void;
+    error: (o: any) => void;
+    value: (o: any, verbosity?: number) => void;
+    chatter: (s: string) => void;
+    chatters: () => string[];
+}
+export declare class Timer {
+    ilog: ILog;
+    o: any;
+    verbosity: number;
+    elapsed: Util.Elapsed;
+    constructor(ilog: ILog, kind: string, o: any, verbosity?: number);
+    log(): void;
+}
+export declare class AsyncTimer extends Timer {
+    constructor(ilog: ILog, o: any, verbosity?: number);
+}
+export declare class SyncTimer extends Timer {
+    constructor(ilog: ILog, o: any, verbosity?: number);
+}

package/dist/logclient/all.d.ts

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

package/dist/logclient/log.d.ts

@@ -0,0 +1,6 @@
+import * as Context from '../context/all';
+import * as LogAbstract from '../logabstract/all';
+export interface LogEnvironment {
+    context: Context.IContext;
+}
+export declare function create(env: LogEnvironment): LogAbstract.ILog;

package/dist/logserver/all.d.ts

@@ -0,0 +1,5 @@
+export * from './log';
+export * from './logkey';
+export * from './logblob';
+export * from './logaccum';
+export * from './logconcat';

package/dist/logserver/log.d.ts

@@ -0,0 +1,11 @@
+import * as LogAbstract from '../logabstract/all';
+import * as Context from '../context/all';
+import * as Storage from '../storage/all';
+import * as FSM from '../fsm/all';
+export interface LogEnvironment {
+    context: Context.IContext;
+    fsmManager: FSM.FsmManager;
+    storageManager: Storage.StorageManager;
+    log: LogAbstract.ILog;
+}
+export declare function create(env: LogEnvironment): LogAbstract.ILog;

package/dist/logserver/logaccum.d.ts

@@ -0,0 +1,154 @@
+import * as Context from '../context/all';
+import * as LogAbstract from '../logabstract/all';
+import * as FSM from '../fsm/all';
+import * as Storage from '../storage/all';
+import { LogBlob } from './logblob';
+import { LogKey } from './logkey';
+export interface Environment {
+    context: Context.IContext;
+    log: LogAbstract.ILog;
+    fsmManager: FSM.FsmManager;
+    storageManager: Storage.StorageManager;
+}
+export interface AccumOptions {
+    onlyAggregateClosed?: boolean;
+}
+export declare class LogItem {
+    id: string;
+    key?: LogKey;
+    present?: boolean;
+    parent?: LogItem;
+    children?: {
+        [id: string]: LogItem;
+    };
+    accum?: ILogAccumulator;
+    blob?: LogBlob;
+    constructor(id: string);
+    query(filter: (item: LogItem) => boolean): LogItem[];
+    addListing(ls: string[]): void;
+    addChild(id: string, child: LogItem): void;
+    add(item: LogItem): void;
+}
+export interface IValueAccumulator {
+    count: number;
+    total: number;
+    min?: number;
+    max?: number;
+}
+export declare class ValueAccumulator {
+    constructor();
+    static create(): IValueAccumulator;
+    static avg(va: IValueAccumulator): number;
+    static incr(va: IValueAccumulator): void;
+    static accum(va: IValueAccumulator, v: number): void;
+    static reduce(va: IValueAccumulator, reduction: IValueAccumulator): void;
+    static log(va: IValueAccumulator): string;
+}
+export declare type IValueAccumulatorIndex = {
+    [key: string]: IValueAccumulator;
+};
+export declare type IValueAccumulatorIndexIndex = {
+    [key: string]: {
+        [key: string]: IValueAccumulator;
+    };
+};
+export declare type IEventAccumulator = IValueAccumulatorIndex;
+export declare class EventAccumulator {
+    constructor();
+    static create(): IEventAccumulator;
+    static getAccumulator(ea: IEventAccumulator, o: any, prop: string | string[]): IValueAccumulator;
+    static NUnique(ea: IEventAccumulator): number;
+    static incr(ea: IEventAccumulator, o: any, prop: string | string[]): void;
+    static accum(ea: IEventAccumulator, o: any, name: string, value: string): void;
+    static reduce(ea: IEventAccumulator, event: string, reduction: IValueAccumulator): void;
+}
+export declare type IEventAccumulatorIndex = {
+    [key: string]: IEventAccumulator;
+};
+export declare type IDayAccumulator = IEventAccumulatorIndex;
+export declare class DayAccumulator {
+    constructor();
+    static create(): IDayAccumulator;
+    static count(da: IDayAccumulator): number;
+    static getAccumulator(da: IDayAccumulator, date: string): IEventAccumulator;
+    static incr(da: IDayAccumulator, date: string, o: any, prop: string | string[]): void;
+    static accum(da: IDayAccumulator, date: string, o: any, name: string, value: string): void;
+    static reduce(da: IDayAccumulator, event: string, reduction: IValueAccumulator): void;
+    static reduceByDateKeys(da: IDayAccumulator, dateKeys: IKeyIndex, event: string, reduction: IValueAccumulator): void;
+    static reduceByDate(da: IDayAccumulator, date: string, event: string, dayReduction: IValueAccumulator): void;
+    static reduceUniqueByDate(da: IDayAccumulator, date: string, days: IValueAccumulatorIndexIndex): void;
+}
+export declare type IDayAccumulatorIndex = {
+    [key: string]: IDayAccumulator;
+};
+export declare type IKeyIndex = {
+    [key: string]: boolean;
+};
+export interface IInstanceAccumulator {
+    dateKeys: IKeyIndex;
+    uniqueKeys: IKeyIndex;
+    instances: IDayAccumulatorIndex;
+}
+export declare class InstanceAccumulator {
+    constructor();
+    static create(): IInstanceAccumulator;
+    static getToday(ia: IInstanceAccumulator): string;
+    static getAccumulator(ia: IInstanceAccumulator, instance: string): IDayAccumulator;
+    static incr(ia: IInstanceAccumulator, instance: string, date: string, o: any, prop: string | string[]): void;
+    static accum(ia: IInstanceAccumulator, instance: string, date: string, o: any, name: string, value: string): void;
+    static NInstances(ia: IInstanceAccumulator): number;
+    static NDays(ia: IInstanceAccumulator): number;
+    static NUniques(ia: IInstanceAccumulator): number;
+    static NUniquesByDay(ia: IInstanceAccumulator, dateKeys?: IKeyIndex): IValueAccumulatorIndex;
+    static AllCountsByDay(ia: IInstanceAccumulator, dateKeys?: IKeyIndex, eventKeys?: IKeyIndex): IValueAccumulatorIndexIndex;
+    static TotalCountsByDay(ia: IInstanceAccumulator, dateKeys?: IKeyIndex, eventKeys?: IKeyIndex): IValueAccumulatorIndex;
+    static ValuesByEvent(ia: IInstanceAccumulator, dateKeys?: IKeyIndex, eventKeys?: IKeyIndex): IValueAccumulatorIndex;
+    static ValuesByDay(ia: IInstanceAccumulator, dateKeys?: IKeyIndex, eventKeys?: IKeyIndex): IValueAccumulatorIndexIndex;
+    static filterNoisyProperty(p: string): boolean;
+    static getCountRows(ia: IInstanceAccumulator, dateKeys?: IKeyIndex, eventKeys?: IKeyIndex): any[];
+    static getValueRows(ia: IInstanceAccumulator, dateKeys?: IKeyIndex, eventKeys?: IKeyIndex): any[];
+}
+export interface ILogAccumulator {
+    users: IInstanceAccumulator;
+    sessions: IInstanceAccumulator;
+    events: IInstanceAccumulator;
+    errors: IInstanceAccumulator;
+    values: IInstanceAccumulator;
+    syncTimers: IInstanceAccumulator;
+    asyncTimers: IInstanceAccumulator;
+    logsSeen: {
+        [id: string]: boolean;
+    };
+}
+export declare class LogAccumulator {
+    static create(): ILogAccumulator;
+    static accumulate(la: ILogAccumulator, instance: string, dateKey: string, o: any): void;
+    static unquoteFields(fields: string[]): string[];
+    static gather(la: ILogAccumulator, logid: string, instance: string, dateKey: string, csvblob: string): void;
+    static aggregate(agg: ILogAccumulator, la: ILogAccumulator): void;
+    static datePatternToKeys(la: ILogAccumulator, pat: string): IKeyIndex;
+    static getToday(la: ILogAccumulator): IKeyIndex;
+    static getTodayRows(la: ILogAccumulator): any[];
+    static getDailyRows(la: ILogAccumulator, datePattern?: string, eventKeys?: IKeyIndex): any[];
+    static getLastDay(la: ILogAccumulator): any[];
+    static getTimerRows(la: ILogAccumulator, datePattern?: string, eventKeys?: IKeyIndex): any[];
+    static getErrorRows(la: ILogAccumulator, datePattern?: string, eventKeys?: IKeyIndex): any[];
+    static getEventRows(la: ILogAccumulator, datePattern?: string, eventKeys?: IKeyIndex): any[];
+    static getValueRows(la: ILogAccumulator, datePattern?: string, eventKeys?: IKeyIndex): any[];
+}
+export declare class FsmLogAccum extends FSM.Fsm {
+    options: AccumOptions;
+    root: LogItem;
+    blobLs: LogBlob;
+    lastErrorsRows: any[];
+    firstScanDone: boolean;
+    constructor(env: Environment, accum?: ILogAccumulator, options?: AccumOptions);
+    get env(): Environment;
+    resetLastErrors(): void;
+    getIncrementalErrors(): any[];
+    refresh(): void;
+    getCategories(): string[];
+    getSummaryRows(): any[];
+    getRows(category: string, datePattern?: string, eventKeys?: IKeyIndex): any[];
+    tick(): void;
+}

package/dist/logserver/logblob.d.ts

@@ -0,0 +1,24 @@
+import * as Context from '../context/all';
+import * as LogAbstract from '../logabstract/all';
+import * as FSM from '../fsm/all';
+import * as Storage from '../storage/all';
+import { LogKey } from './logkey';
+interface Environment {
+    context: Context.IContext;
+    log: LogAbstract.ILog;
+    fsmManager: FSM.FsmManager;
+    storageManager: Storage.StorageManager;
+}
+export declare class LogBlob extends Storage.StorageBlob {
+    key: LogKey;
+    constructor(env: Environment, params: Storage.BlobParams);
+    get env(): Environment;
+    get result(): string;
+    static createForDownload(env: Environment, id: string): LogBlob;
+    static createForUpload(env: Environment, id: string, data: string): LogBlob;
+    static createForDelete(env: Environment, id: string): LogBlob;
+    static createForLs(env: Environment): LogBlob;
+    filter(s: string): boolean;
+    asString(): string;
+}
+export {};

package/dist/logserver/logconcat.d.ts

@@ -0,0 +1,55 @@
+import * as Context from '../context/all';
+import * as LogAbstract from '../logabstract/all';
+import * as FSM from '../fsm/all';
+import * as Storage from '../storage/all';
+import { LogBlob } from './logblob';
+interface Environment {
+    context: Context.IContext;
+    log: LogAbstract.ILog;
+    fsmManager: FSM.FsmManager;
+    storageManager: Storage.StorageManager;
+}
+export declare class FsmCompact extends FSM.Fsm {
+    blobLs: LogBlob;
+    clusters: {
+        [key: string]: string[];
+    };
+    constructor(env: Environment);
+    get env(): Environment;
+    gatherLogList(logs: string[]): void;
+    tick(): void;
+}
+declare class Permuter {
+    tag: string;
+    entries: {
+        [key: string]: {
+            key: string;
+            to: string;
+            from: string;
+        };
+    };
+    mapper: {
+        [from: string]: string;
+    };
+    length: number;
+    constructor(tag: string);
+    reset(): void;
+    add(fields: string[]): void;
+    map(from: string): string;
+    asCSV(): string[];
+}
+export declare class FsmCompactOne extends FSM.Fsm {
+    key: string;
+    cluster: string[];
+    blobs: LogBlob[];
+    csv: string[];
+    schemas: Permuter;
+    templates: Permuter;
+    constructor(env: Environment, key: string, cluster: string[]);
+    get env(): Environment;
+    loadBlobs(): void;
+    saveBlobs(): void;
+    deleteBlobs(): void;
+    tick(): void;
+}
+export {};

package/dist/logserver/logkey.d.ts

@@ -0,0 +1,28 @@
+export declare function dateToKey(d: Date): string;
+export declare function dateToMonthKey(d: Date): string;
+export declare function dateToYearKey(d: Date): string;
+export declare class LogKey {
+    kind: string;
+    mode: string;
+    date: string;
+    dateKey: string;
+    monthKey: string;
+    yearKey: string;
+    count: string;
+    instance: string;
+    ext: string;
+    constructor();
+    static root(): LogKey;
+    static create(s: string): LogKey;
+    yearClosed(): boolean;
+    monthClosed(): boolean;
+    dateClosed(): boolean;
+    get closed(): boolean;
+    get yearID(): string;
+    get monthID(): string;
+    get dateID(): string;
+    get isYear(): boolean;
+    get isMonth(): boolean;
+    get isDate(): boolean;
+    get isLog(): boolean;
+}

package/dist/memsqs/all.d.ts

@@ -0,0 +1,4 @@
+export * from './queue';
+export * from './client';
+export * from './server';
+export * from './loopback';

package/dist/memsqs/client.d.ts

@@ -0,0 +1,13 @@
+import * as Q from './queue';
+export declare type SQSCallback = (err: any, result: Q.QMessages) => void;
+export declare class SQSClient {
+    private targeturl?;
+    private httpoptions?;
+    private agentPool?;
+    constructor(urlstring?: string);
+    setOptions(queueid: string, options: Q.QQueueOptions, cb: SQSCallback): void;
+    claim(queueid: string, owner: string, groupid: string, cb: SQSCallback): void;
+    send(queueid: string, m: Q.QMessage, cb: SQSCallback): void;
+    remove(queueid: string, m: Q.QMessage, cb: SQSCallback): void;
+    receive(queueid: string, owner: string, cb: SQSCallback): void;
+}

package/dist/memsqs/loopback.d.ts

@@ -0,0 +1,11 @@
+import * as Q from './queue';
+import * as C from './client';
+export declare class SQSClientLoopback {
+    constructor(urlstring?: string);
+    setOptions(queueid: string, options: Q.QQueueOptions, cb: C.SQSCallback): void;
+    claim(queueid: string, owner: string, groupid: string, cb: C.SQSCallback): void;
+    send(queueid: string, m: Q.QMessage, cb: C.SQSCallback): void;
+    remove(queueid: string, m: Q.QMessage, cb: C.SQSCallback): void;
+    receive(queueid: string, owner: string, cb: C.SQSCallback): void;
+    doReceive(): void;
+}

package/dist/memsqs/orderedlist.d.ts

@@ -0,0 +1,19 @@
+export interface OrderedListEntry<T> {
+    prev: OrderedListEntry<T>;
+    next: OrderedListEntry<T>;
+    value: T;
+}
+export declare type OrderedListIndex<T> = {
+    [key: string]: OrderedListEntry<T>;
+};
+export declare class OrderedList<T> {
+    head: OrderedListEntry<T>;
+    tail: OrderedListEntry<T>;
+    index: OrderedListIndex<T>;
+    constructor();
+    isempty(): boolean;
+    clear(): void;
+    insert(key: string, value: T): string;
+    remove(key: string): string;
+    forEach(cb: (value: T) => boolean): void;
+}

package/dist/memsqs/queue.d.ts

@@ -0,0 +1,84 @@
+import * as Util from '../util/all';
+import * as OL from './orderedlist';
+export declare const DefaultPort: number;
+export declare const DefaultServerUrl: string;
+export interface QMessage {
+    messageid: string;
+    groupid: string;
+    seqno?: number;
+    contents?: any;
+    blobid?: string;
+}
+export declare type QMessages = QMessage[];
+interface QMessageHolder {
+    m: QMessage;
+    pending: boolean;
+    deadline: Util.Deadline;
+}
+declare type QMessageList = OL.OrderedList<QMessageHolder>;
+declare type QMessageIndex = {
+    [key: string]: boolean;
+};
+interface QVisibility {
+    owner: string;
+    deadline: Util.Deadline;
+    index: QMessageIndex;
+}
+interface QGroup {
+    id: string;
+    messages: QMessageList;
+    visibility: QVisibility;
+}
+declare type QGroupIndex = {
+    [id: string]: QGroup;
+};
+export interface QQueueOptions {
+    timeoutVisibility: number;
+    timeoutDead: number;
+    timeoutQueueDead: number;
+    receiveLimit: number;
+    longpoll: boolean;
+}
+declare class QQueue {
+    id: string;
+    groups: QGroupIndex;
+    seqno: number;
+    options: QQueueOptions;
+    nHeld: number;
+    lastActive: Util.Elapsed;
+    constructor(id: string, options?: QQueueOptions);
+    dumpLog(): void;
+    setOptions(options: QQueueOptions): void;
+    _group(id: string): QGroup;
+    forEachGroup(cb: (g: QGroup) => boolean): void;
+    forEachMessageHolder(g: QGroup, cb: (h: QMessageHolder) => boolean): void;
+    get isActive(): boolean;
+    checkTimeout(): void;
+    send(m: QMessage): string;
+    claim(owner: string, groupid: string): string;
+    receive(owner: string, result: QMessages): void;
+    removeFromGroup(g: QGroup, m: QMessage): string;
+    remove(m: QMessage): string;
+}
+declare type QQueueIndex = {
+    [id: string]: QQueue;
+};
+export declare class QQueueManager {
+    queues: QQueueIndex;
+    nSent: number;
+    nReceived: number;
+    nRemoved: number;
+    nCulled: number;
+    constructor();
+    _queue(queueid: string): QQueue;
+    checkTimeout(): void;
+    forEach(cb: (q: QQueue) => void): void;
+    dumpLog(): void;
+    setOptions(queueid: string, options: QQueueOptions): void;
+    isLongpoll(queueid: string): boolean;
+    claim(queueid: string, owner: string, groupid: string): string;
+    send(queueid: string, m: QMessage): string;
+    receive(queueid: string, owner: string, result: QMessages): void;
+    remove(queueid: string, m: QMessage): string;
+}
+export {};

package/dist/memsqs/server.d.ts

@@ -0,0 +1,37 @@
+import * as JS from '../jsonstream/all';
+import * as Q from './queue';
+export declare class SQSServer {
+    private port;
+    private server;
+    queuemanager: Q.QQueueManager;
+    longpoll: LongPoll;
+    constructor(port?: number);
+    get running(): boolean;
+    close(): void;
+}
+interface LongPollRequest {
+    deadline: number;
+    request: OneRequest;
+}
+declare class LongPoll {
+    requests: LongPollRequest[];
+    constructor();
+    check(): void;
+    tick(): void;
+    add(one: OneRequest): void;
+}
+declare class OneRequest {
+    server: SQSServer;
+    req: any;
+    res: any;
+    jsonstream: JS.JSONStreamReader;
+    json: any;
+    body: any;
+    constructor(server: SQSServer, req: any, res: any);
+    isDone(): boolean;
+    onRetry(): boolean;
+    onDone(): void;
+    onError(s: string): void;
+    onFinish(): void;
+}
+export {};

package/dist/ot-editutil/all.d.ts

@@ -0,0 +1,2 @@
+export * from "./oteditutil";
+export * from "./otmaputil";

package/dist/ot-editutil/oteditutil.d.ts

@@ -0,0 +1,14 @@
+import * as LogAbstract from '../logabstract/all';
+import * as OT from '../ot-js/all';
+export declare class OTEditUtil {
+    ilog: LogAbstract.ILog;
+    resourceID: string;
+    resourceName: string;
+    clientID: string;
+    constructor(ilog: LogAbstract.ILog, rid: string, cid: string, name: string);
+    insertAtStart(s: any, nCurrentLen: number): OT.OTCompositeResource;
+    insertAtEnd(s: any, nCurrentLen: number): OT.OTCompositeResource;
+    injectCursor(edit: OT.OTCompositeResource, start: number, end?: number): void;
+    extractCursor(edit: OT.OTCompositeResource): any;
+    computeEdit(sOld: string, sNew: string): OT.OTCompositeResource;
+}

package/dist/ot-editutil/otmaputil.d.ts

@@ -0,0 +1,21 @@
+import * as OT from '../ot-js/all';
+export declare const MERGE: number;
+export declare const REPLACE: number;
+export declare class Editor {
+    private engine;
+    private root;
+    private stamps;
+    constructor(engine: OT.OTEngine);
+    startLocalEdit(): void;
+    stamp(rid: string, prop: string): void;
+    set(rid: string, p: string, v: any): Editor;
+    del(rid: string, p: string): Editor;
+    rawObject(rid: string): OT.OTMapResource;
+    rawArray(rid: string): OT.OTArrayResource;
+    editCounter(rid: string, oNew: any, mode?: number): void;
+    editObject(rid: string, oNew: any, mode?: number): void;
+    editArray(rid: string, aNew: any[]): void;
+    edit(oNew: any): boolean;
+    get length(): number;
+    commit(): boolean;
+}

package/dist/ot-js/all.d.ts

@@ -0,0 +1,9 @@
+export * from "./otarray";
+export * from "./otengine";
+export * from "./otclientengine";
+export * from "./otcomposite";
+export * from "./otmap";
+export * from "./otcounter";
+export * from "./otserverengine";
+export * from "./ottypes";
+export * from "./otsession";