@dra2020/baseclient 1.0.10 → 1.0.13

package/dist/util/util.d.ts

@@ -1,68 +0,0 @@
-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

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

package/docs/filterexpr.md

@@ -1,22 +0,0 @@
-# filterexpr
-Simple utility class for applying a user-provided filtering expression against an object.
-
-## FilterExpr
-
-Optionally initialize with expression to test against.
-Or call `set(expr: string)` to set the expression.
-The function `test(o: any)` will test the object against the expression.
-
-## Expression syntax
-
-The simplest expression is just a string of text. If any field in the object contains the string, the pattern matches.
-All comparisons are case-insensitive.
-
-A quoted string can be used to hide special characters. Single or double quotes are allowed.
-
-Expressions can be combined with `not`, `and`, and `or`. Precedence is in that order.
-
-Expressions can be surrounded by parens to force a precedence interpretation.
-
-A field name can be specified to limit the comparison to a specific field. An example is `state: ma`. Field names are case-insensitive.
-Field name is lowest precedence, so `state: ma or tx` would constrain both strings to the `state` property.

package/docs/fsm.md

@@ -1,243 +0,0 @@
-# fsm
-Library for managing the execution of a linked tree of finite state machines.
-
-# Overview
-
-The `Fsm` library and class serves as the base class for chainable finite state machines.
-
-The library improves management of asynchronous work in several ways over more primitive syntactic approaches
-like plain callbacks, async/await, promises or async libraries. These include:
-
-- The state of your computation is managed as an explicit set of objects rather than
-an opaque mixture of callbacks and closures.
-
-- It is easy to model a computation that proceeds through multiple intermediate states rather
-than simply "in-process" or "done".
-
-- Computations (objects) can be built as a tree of dependent computations, effectively acting as a
-data-flow model, a natural way of describing many computations.
-
-- The mechanism integrates well with existing mechanisms like callbacks and promises.
-
-- A state machine more directly models how the computation is proceeding rather than syntactic models
-like async/await that explicitly try to hide the real control flow.
-
-- Requiring a class definition to represent the computation tends to facilitate reuse of the
-asynchronous logic rather than having callbacks sprinkled through the code base.
-
-A potential disadvantage of the FSM mechanism is that requiring a new subclass tends
-to have a heavier syntactic weight than
-mechanisms like simple callbacks.
-For some, this is an advantage in not trivializing the additional
-state complexity that an outstanding asynchronous computation represents for the application.
-
-The normal usage is to sub-class the Fsm base class and override the `tick` function to walk the
-state machine through its states.
-
-Each machine begins in the FSM_STARTING state.
-The `tick` function on the class gets scheduled to be called (asynchronously) initially after
-construction and then explicitly whenever
-the state changes (by a call to the class function `setState`).
-
-A subclass overrides the `tick` function to run the machine through its state transitions.
-
-Additionally, a finite state machine can `waitOn` another state machine.
-When that machine is marked complete (either `FSM_DONE` or `FSM_ERROR`),
-any machines waiting on that state machine get scheduled to have their `tick` function called as well.
-
-A machine is `ready` when all `Fsm`'s it is waiting on have been marked complete.
-
-The `tick` function of a dependent state machine is called whenever any machine it is waiting on completes,
-but normally the `tick` function only performs activity when the machine is `ready`.
-
-Most usage involves the `tick` function first testing if it is `ready` before doing any activity,
-although a usage that wanted to take action whenever any waitedOn dependent completes might omit that test
-(e.g. to race multiple asynchronous operations and use whichever result completes first or
-immediately complete if any one of several outstanding dependents fail).
-
-For example, this is typical usage:
-
-```javascript
-tick(): void
-{
-  if (this.ready)
-  {
-    // all dependents are complete, take action now
-  }
-}
-```
-
-Of course, a state machine can go from `ready` to not `ready` as many times as necessary simply by waiting on
-some new `Fsm` within its `tick` function.
-
-Normally a Fsm-based class does not fire off any activity until the first time its `tick` function is called (rather than
-in the constructor).
-
-So,
-
-```javascript
-constructor(env: Environment)
-{
-  super(env);
-  // Don't do any real work here.
-}
-
-tick(): void
-{
-  if (this.ready)
-  {
-    switch (this.state)
-    {
-      case FSM_STARTING:
-        // Kick off activity here
-        break;
-    }
-  }
-}
-```
-
-That is not a requirement but increases flexibility by allowing clients to construct the Fsm and
-then add dependents it must wait on before any activity is kicked off.
-
-The infrastructure only cares about the starting state FSM_STARTING and the completion states `FSM_ERROR` and `FSM_DONE`.
-Any other state values can
-be used internally to a state machine to manage walking through different active states prior to completion.
-For convenenience, the names `FSM_CUSTOM1` through `FSM_CUSTOM9` are predefined and internal states can use these
-values (typically assigned to something semantically meaningful) however they wish.
-
-The state `FSM_PENDING` has no special meaning but is defined for convenience since many state machines go through
-a single intermediate state (`FSM_STARTING` to `FSM_PENDING` to `FSM_DONE`).
-
-Callbacks can be integrated easily by having the callback set the `Fsm` state, which allows either completion
-notification to any other waiting state machines or the next step in the current state machine to be executed.
-
-```javascript
-tick(): void
-{
-  if (this.ready)
-  {
-    switch (this.state)
-    {
-      case FSM_STARTING:
-        asyncAPIWithCallback((err: any, result: any) => {
-            if (err)
-              this.setState(FSM_ERROR);
-            else
-              this.setState(FSM_DONE);
-          });
-        break;
-    }
-  }
-}
-```
-
-or
-
-```javascript
-tick(): void
-{
-  if (this.ready)
-  {
-    switch (this.state)
-    {
-      case FSM_STARTING:
-        asyncAPIWithCallback((err: any, result: any) => {
-            if (err)
-              this.setState(FSM_ERROR);
-            else
-              this.setState(FSM_PENDING);
-          });
-        break;
-
-      case FSM_PENDING:
-        // Do more stuff here now that callback has completed.
-        break;
-    }
-  }
-}
-```
-
-
-### isDependentError
-
-When an `Fsm` that is being waited on completes with an error, any waiting `Fsm`'s get the `isDependentError` flag set
-and of course get a chance to run their `tick` function (since the dependent `Fsm` has completed).
-
-They can decide if the semantics of the relationship then requires them to propagate, consume or otherwise handle the
-error. No other error propagation happens automatically.
-So:
-
-```javascript
-tick(): void
-{
-  if (this.ready && this.isDependentError)
-    this.setState(FSM_ERROR);
-  else if (this.ready)
-  {
-    // Normal code here
-  }
-}
-```
-
-would explicitly immediately propagate a dependent error.
-
-Note that the check above to test whether the state machine is `ready` before `isDependentError` is to ensure you do not
-loop continuously resetting the state to FSM_ERROR on each `tick` invocation.
-
-### Reuse
-
-An `Fsm` can be reused and transition from `ready` to not `ready` or `done` to not `done`.
-
-
-### Cancellation
-
-There is no explicit cancellation mechanism.
-
-By convention, a sub-class should override the `end` member function to allow external cancellation or completion.
-By default this function sets the `Fsm` to `FSM_DONE` but can optionally take the `FSM_ERROR` state
-to indicate error.
-
-Whether calling `end` or setting the state explicitly to `FSM_DONE` or `FSM_ERROR` from external to
-the state machine makes semantic sense depends on the specific properties and semantics of the computation.
-
-### FsmOnDone
-
-A simple utility class `FsmOnDone` provides a way of integrating a callback with an Fsm-based infrastructor.
-
-The FsmOnDone class will wait till the `Fsm` passed to the constructor completes and then call the provided
-callback, passing the completed Fsm as the argument.
-
-```javascript
-let fsm = new FsmOnDone(env, fsmWait, (fsmWait: Fsm) => {
-    /* do stuff with fsmWait since it is now complete */
-  });
-```
-
-### FsmSleep
-
-`FsmSleep` is a  simple utility class that creates a dependency that is marked done after
-the number of milliseconds passed to the constructor.
-
-So:
-
-```javascript
-fsm.waitOn(new FsmSleep(env, 1000));
-```
-
-will result in the object `fsm` having a dependency that will complete in 1000ms.
-
-### FsmLoop
-
-`FsmLoop` is a simple utility class to run an asynchronous process in a loop at some maximum rate.
-It waits for the `Fsm` passed in to complete, then uses `FsmSleep` to wait until the specified
-minimum interval is complete (starting when the `Fsm` started executing)and restarts the `Fsm`.
-It is required that the `Fsm` properly handles going from the `FSM_DONE` state back to `FSM_STARTING`.
-
-### FsmArray
-
-`FsmArray` is a simple utility class that provides a mechanism for waiting for a stream of
-objects to appear in an array and consuming them, repeatedly.
-It will be marked `done` when any content is made available in the array (through the member `a`)
-by calling `push` or `concat`.
-When the content is consumed, it should be removed with `splice` or `reset`.
-At this point, the `Fsm` will be placed back in the `starting` state and can be waited on again.

package/docs/logabstract.md

@@ -1,2 +0,0 @@
-# logabstract
-Abstract interface for logging.

package/docs/logclient.md

@@ -1,2 +0,0 @@
-# logclient
-Client-side implementation of logging abstraction.

package/docs/ot-editutil.md

@@ -1,2 +0,0 @@
-# ot-editutil
-Utility library for Operational Transform implementation.

package/docs/ot-js.md

@@ -1,95 +0,0 @@
-# ot-js
-This is a JavaScript version of a basic OT library that implements OT for strings, basic arrays and maps (dictionaries).
-It presumes the approach used in Google Wave where a basic resource implements the key actions of "transform" and
-"compose". Clients serialize through a central server (which transforms as necessary when the client changes were not
-based off the tip). Clients receive the edit stream from the server and transform as necessary to update their local state.
-As with Google Wave, this presumes only a single edit action is outstanding at each client (local edits are composed and
-queued up until the outstanding action is acknowledged by the server).
-
-This library also provides a general framework for extending to other data types, although requires that these data types
-be well-known to the server and the client.
-
-This code serves as the basis for both the server and the client implementation of OT (there is an example implementation
-of both at dra2020/ot-js-server).
-
-The basic structure is that a set of client interacts with the server to establish a composite resource made up of
-named strings, arrays and maps that represent the shared client state. Clients submit "edits" to these resources and
-the server mediates these, applying the basic OT algorithm to transform incoming events and the dispatch them to all
-the clients.
-
-The key types are described below.
-
-## IOTResource (ottypes.ts)
-
-This TypeScript interface defines the core functions necessary to implement OT for a new resource type.
-The key function is "transform" which implements the core OT algorithm for this type. Note it takes a second boolean argument,
-"bPrior" which indicates whether the argument will be applied prior to this one in the canonical server ordering.
-This can be used to disambiguate situations that are otherwise ambiguous (e.g. classically, which action gets precedence
-when two insertions occur at the same location). (Is the final canonical result "ab" or "ba"?)
-
-The other key function with some complexity is "compose" which composes two operations into a new single operation
-that achieves the same final effect. This is key to actually implementing the overall system as well as for efficiency.
-
-Each resource defines an "edits" array which is composed of generic JavaScript objects suitable for serialization. This
-array is passed "as is" as the definition of the operation that needs to be performed.
-
-Each resource has a "name" which is used to support a composite collection of resources accessed by name.
-
-Each resource has an "underlyingType" which defines the mechanism by which the appropriate resource class is instantiated
-at the client and the server. The mechanism is extensible but requires that these be "well known" and pre-shared
-between client and server.
-
-## OTResourceBase (ottypes.ts)
-
-This class implements the IOTResource interface and provides some additional useful utility functions. All new types should
-extend from this class.
-
-## OTCompositeResource (otcomposite.ts)
-
-OTCompositeResource provides the mechanism for grouping a set of resources together, referenced by name. The client/server
-engine implementation assume OTCompositeResource is the base resource shared between instances.
-
-## OTArrayLikeResource (otarray.ts)
-
-OTArrayLikeResource is the base class for array-like data types that support insert, delete, retain, cursor and set. This
-class is further subclassed to support strings and generic arrays. This implements the guts of the hard OT algorithm for
-strings.
-
-## OTStringResource (otarray.ts)
-
-Implements a shared string (e.g. for editing plain text).
-
-## OTArrayResource (otarray.ts)
-
-Implements a shared array. The content of any specific entry in the array can be any serializable JSON object, although 
-the update to the object must be effectively atomic - there is no internal semantics around updating the value.
-
-## OTMapResource (otmap.ts)
-
-Implements a basic associative array with set and delete operations. Like OTArrayResource, the base data type can be any
-serializable object but is always updated atomically.
-
-## OTCounterResource (otcounter.ts)
-
-Implements a basic associative array with add and delete operations. The values associated with the keys are integer counters
-and the "add" operation increments (or decrements) the underlying value. Obviously this composes and transforms trivially.
-
-## OTClientEngine (otclientengine.ts)
-
-Implements the core client semantics of the OT process, as implemented in Google Wave. The core functions here are "addLocal"
-which adds a local change to the local state and prepares it for sending to the server and "addRemote" which receives
-an event from the server applies it to the local state. That event might be a response to sending up a local event.
-
-The function "getPending" indicates when a pending event is available for send.
-
-The client engine implements the required core semantics for the Google Wave OT implementation (which requires that any
-local changes are queued locally while there is an outstanding request to the server). This logic here is a bit tricky so the
-implementation here is critical to getting OT right.
-
-
-## OTServerEngine (otserverengine.ts)
-
-Implements the server processing (through the core function "addServer") for implementing the client-server OT algorithm.
-The core model here is that the client can submit an event against an old state of the server as long as the server can
-appropriately transform the event in order to apply it to the local state. This requires maintaining some ongoing log
-of all states and events.

package/docs/poly.md

@@ -1,103 +0,0 @@
-# poly
-Small utility library of convenient polygon functions used for geojson project.
-
-These library functions all take either a GeoJSON polygon or multipolygon feature
-or take a bare set of points (in the same basic format as either the GeoJSON
-polygon). Look to the reference but basically, a polygon is an array whose first
-member is the outer ring and subsequent members are the internal holes.
-
-A multipolygon is just an array of polygons.
-
-A ring is an array of points. The array should be at least 4 points long and the
-first and last points should be equal.
-
-A point is an array of lon, lat (that is, x, y).
-
-### Earth Radius
-export declare const EARTH_RADIUS = 6371000;
-
-### polyNormalize
-export declare function polyNormalize(poly: any): any;
-
-Used internally to normalize the input for subsequent processing. Exposed
-if you want to be consistent. The result is either null or the points
-array in multi-polygon format.
-
-### polyArea
-export declare function polyArea(poly: any): number;
-
-Compute the area of the polygon in meters squared.
-
-### polyPerimeter
-export declare function polyPerimeter(poly: any): number;
-
-Compute the perimeter of a polygon in meters.
-
-### Circle class
-export declare class Circle {
-    x: number;
-    y: number;
-    r: number;
-    constructor(x: number, y: number, r: number);
-}
-
-Used for subsequent functions.
-
-### polyToCircle
-
-export declare function polyToCircle(poly: any): Circle | null;
-
-Return smallest circle that encloses all points.
-
-### polyToPolsbyPopperCircle
-
-export declare function polyToPolsbyPopperCircle(poly: any): Circle | null;
-
-Returns circle whose perimeter is equal to the perimeter of the bounding perimeter
-of the polygon.
-
-### polyFromCircle
-
-export declare function polyFromCircle(c: Circle, nSegments?: number): any;
-
-Return a polygon (in normalized form) that approximates the circle provided.
-NSegments specifies the number of segments to use (must be at least 8).
-
-### polyConvexHull
-
-export declare function polyConvexHull(poly: any): any;
-
-A.M. Andrew's monotone chain 2D convex hull algorithm.
-
-### Compactness Description
-export interface CompactnessDescription {
-    value: number;
-    reock: number;
-    polsby_popper: number;
-    convex_hull: number;
-    schwartzberg: number;
-}
-
-Type returned from polyCompactness function.
-
-### polyCompactness
-
-export declare function polyCompactness(poly: any): CompactnessDescription;
-
-Compute the compactness of the polygon.
-
-### PolyDescription
-
-export interface PolyDescription {
-    npoly: number;
-    nhole: number;
-    npoint: number;
-}
-
-Type returned from polyDescribe.
-
-### polyDescribe
-
-export declare function polyDescribe(poly: any): PolyDescription;
-
-Describe the given polygon.

package/docs/util.md

@@ -1,2 +0,0 @@
-# util
-A variety of simple utility functions for Javascript projects.

package/lib/all/all.ts

@@ -1,21 +0,0 @@
-// Client and Server
-import * as Util from '../util/all';
-export { Util };
-import * as Context from '../context/all';
-export { Context };
-import * as FSM from '../fsm/all';
-export { FSM };
-import * as Poly from '../poly/all';
-export { Poly };
-import * as LogAbstract from '../logabstract/all';
-export { LogAbstract };
-import * as LogClient from '../logclient/all';
-export { LogClient };
-import * as OT from '../ot-js/all';
-export { OT };
-import * as OTE from '../ot-editutil/all';
-export { OTE };
-import { FilterExpr } from '../filterexpr/all';
-export { FilterExpr }
-import * as G from '../geo/all';
-export { G };

package/lib/context/all.ts

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

package/lib/context/context.ts

@@ -1,82 +0,0 @@
-import * as Util from '../util/all';
-
-export type ContextValues = { [key: string]: any };
-export interface IContext
-{
-  setDefaults: (o: ContextValues) => void
-  setValues: (o: ContextValues) => void
-  xvalue: (prop: string) => any
-  xset: (prop: string) => boolean
-  xflag: (prop: string) => boolean
-  xnumber: (prop: string) => number
-  xstring: (prop: string) => string
-}
-
-class Context implements IContext
-{
-  private values: ContextValues;
-  private defaults: ContextValues;
-
-  constructor()
-  {
-    this.values = {};
-    this.defaults = {};
-  }
-
-  setValues(o: ContextValues): void
-  {
-    this.values = Util.shallowAssignImmutable(this.values, o);
-  }
-
-  setDefaults(o: ContextValues): void
-  {
-    this.defaults = Util.shallowAssignImmutable(this.defaults, o);
-  }
-
-  xvalue(prop: string): any
-  {
-    let v: any = this.values[prop];
-    if (v === undefined && process && process.env)
-      v = process.env[prop.toUpperCase()];
-    if (v === undefined)
-      v = this.defaults[prop];
-    return v;
-  }
-
-  xset(prop: string): boolean
-  {
-    let v: any = this.values[prop];
-    if (v === undefined && process && process.env)
-      v = process.env[prop.toUpperCase()];
-    return v !== undefined;
-  }
-
-  xflag(prop: string): boolean
-  {
-    let v: any = this.xvalue(prop);
-    if (v === undefined || v === null)
-      return false;
-    return Number(v) != 0;
-  }
-
-  xnumber(prop: string): number
-  {
-    let v: any = this.xvalue(prop);
-    if (v === undefined || v === null)
-      return 0;
-    return Number(v);
-  }
-
-  xstring(prop: string): string
-  {
-    let v: any = this.xvalue(prop);
-    if (v === undefined || v === null)
-      return null;
-    return String(v);
-  }
-}
-
-export function create(): IContext
-{
-  return new Context();
-}

package/lib/filterexpr/all.ts

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