@dra2020/baseclient 1.0.14 → 1.0.17

package/dist/filterexpr/filterexpr.d.ts

@@ -58,6 +58,9 @@ export declare class FilterExpr {
     set(expr: string): void;
     test(o: any, types?: any): boolean;
     asString(): string;
+    containsClause(expr: string): boolean;
+    addClause(expr: string): void;
+    removeClause(expr: string): void;
     asStringClause(clause: Clause): string;
     testClause(o: any, types: any, clause: Clause, prop?: string, relation?: TokType): boolean;
 }

package/dist/fsm/fsm.d.ts

@@ -63,6 +63,7 @@ export declare class FsmOnDone extends Fsm {
 }
 export declare class FsmSleep extends Fsm {
     delay: number;
+    timeoutHandle: any;
     constructor(env: FsmEnvironment, delay: number);
     tick(): void;
 }

package/dist/geo/all.d.ts

@@ -0,0 +1,2 @@
+export * from './geo';
+export * from './vfeature';

package/dist/geo/geo.d.ts

@@ -0,0 +1,67 @@
+import * as geojson from 'geojson';
+import * as Poly from '../poly/all';
+export declare type GeoProperties = geojson.GeoJsonProperties;
+export declare type GeoFeature = geojson.Feature;
+export declare type GeoFeatureArray = GeoFeature[];
+export declare type GeoFeatureCollection = geojson.FeatureCollection;
+export declare function geoCollectionToMap(col: GeoFeatureCollection): GeoFeatureMap;
+export declare function geoMapToCollection(map: GeoFeatureMap): GeoFeatureCollection;
+export declare function geoCollectionToTopo(col: GeoFeatureCollection): Poly.Topo;
+export declare function geoTopoToCollection(topo: Poly.Topo): GeoFeatureCollection;
+export interface GeoFeatureMap {
+    [id: string]: GeoFeature;
+}
+export declare type FeatureFunc = (f: GeoFeature) => void;
+interface GeoEntry {
+    tag: string;
+    col?: GeoFeatureCollection;
+    map?: GeoFeatureMap;
+    topo?: Poly.Topo;
+}
+declare type GeoEntryMap = {
+    [tag: string]: GeoEntry;
+};
+export declare function geoEqual(m1: GeoMultiCollection, m2: GeoMultiCollection): boolean;
+export declare function geoMapEqual(m1: GeoFeatureMap, m2: GeoFeatureMap): boolean;
+export declare class GeoMultiCollection {
+    entries: GeoEntryMap;
+    all: GeoEntry;
+    hidden: any;
+    stamp: number;
+    constructor(tag?: string, topo?: Poly.Topo, col?: GeoFeatureCollection, map?: GeoFeatureMap);
+    empty(): void;
+    get nEntries(): number;
+    nthEntry(n: number): GeoEntry;
+    add(tag: string, topo: Poly.Topo, col: GeoFeatureCollection, map: GeoFeatureMap): void;
+    addMulti(multi: GeoMultiCollection): void;
+    remove(tag: string): void;
+    _onChange(): void;
+    _col(e: GeoEntry): GeoFeatureCollection;
+    _map(e: GeoEntry): GeoFeatureMap;
+    _topo(e: GeoEntry): Poly.Topo;
+    colOf(tag: string): GeoFeatureCollection;
+    mapOf(tag: string): GeoFeatureMap;
+    topoOf(tag: string): Poly.Topo;
+    forEachEntry(cb: (e: GeoEntry) => void): void;
+    allCol(): GeoFeatureCollection;
+    allMap(): GeoFeatureMap;
+    allTopo(): Poly.Topo;
+    hide(id: any): void;
+    show(id: any): void;
+    showAll(): void;
+    get length(): number;
+    nthFeature(n: number): GeoFeature;
+    nthFilteredFeature(n: number, cb: (f: GeoFeature) => boolean): GeoFeature;
+    forEach(cb: FeatureFunc): void;
+    map(cb: (f: GeoFeature) => GeoFeature): GeoFeature[];
+    isHidden(id: string): boolean;
+    find(id: string): GeoFeature;
+    filter(test: (f: GeoFeature) => boolean): GeoMultiCollection;
+}
+export declare enum geoIntersectOptions {
+    Intersects = 0,
+    Bounds = 1,
+    BoundsCenter = 2
+}
+export declare function geoIntersect(multi: GeoMultiCollection, bbox: Poly.BoundBox, opt: geoIntersectOptions): GeoMultiCollection;
+export {};

package/dist/geo/vfeature.d.ts

@@ -0,0 +1,4 @@
+import * as Util from '../util/all';
+import * as Poly from '../poly/all';
+import * as G from './geo';
+export declare function computeVFeature(topoPrecinct: Poly.Topo, bintrie: Util.BinTrie, blocks: string[]): G.GeoFeature;

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

@@ -20,6 +20,7 @@ export declare const FilterRecent: number;
 export declare const FilterTrash: number;
 export declare const FilterPublic: number;
 export declare const FilterOfficial: number;
+export declare const FilterCOI: number;
 export declare const FilterCount: number;
 export declare type Filter = number;
 export declare const PermNone: number;
@@ -83,6 +84,8 @@ export interface SessionProps {
     loadFailed: boolean;
     accessMap: AccessMap;
     revisions: RevisionList;
+    expunged?: boolean;
+    expungeDate?: string;
     xprops?: {
         [prop: string]: string;
     };

package/dist/poly/union.d.ts

@@ -2,6 +2,7 @@ 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;
+export declare function polyDifference(main: any, parts: any[]): any;
 declare class FsmDifference extends FSM.Fsm {
     accum: any;
     polys: any[];

package/docs/filterexpr.md

@@ -0,0 +1,22 @@
+# 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/lib/all/all.ts

@@ -17,25 +17,5 @@ import * as OTE from '../ot-editutil/all';
 export { OTE };
 import { FilterExpr } from '../filterexpr/all';
 export { FilterExpr }
-
-// Server Only
-import * as DB from '../dbabstract/all';
-export { DB };
-import * as Storage from '../storage/all';
-export { Storage };
-import * as JS from '../jsonstream/all';
-export { JS };
-import * as FsmFile from '../fsmfile/all';
-export { FsmFile };
-
-import * as LogServer from '../logserver/all';
-export { LogServer };
-
-import * as S3 from '../storages3/all';
-export { S3 };
-import * as DBDynamo from '../dbdynamo/all';
-export { DBDynamo };
-import * as Lambda from '../lambda/all';
-export { Lambda };
-import * as Memsqs from '../memsqs/all';
-export { Memsqs };
+import * as G from '../geo/all';
+export { G };

package/lib/filterexpr/filterexpr.ts

@@ -484,6 +484,45 @@ function wordyDate(s: string): string
   return s;
 }
 
+function clauseEqual(c1: Clause, c2: Clause): boolean
+{
+  if (c1 == null && c2 == null) return true;
+  if (c1 == null || c2 == null) return false;
+  if (c1.op.tt === c2.op.tt)
+  {
+    if (c1.op.tt === TokType.Text)
+      return c1.op.text === c2.op.text;
+    else
+      return clauseEqual(c1.operand1, c2.operand1) && clauseEqual(c1.operand2, c2.operand2);
+  }
+  else
+    return false;
+}
+
+function containsClause(c: Clause, s: Clause): boolean
+{
+  if (clauseEqual(c, s))
+    return true;
+  if (c == null || s == null) return false;
+  return containsClause(c.operand1, s) || containsClause(c.operand2, s);
+}
+
+function removeClause(c: Clause, s: Clause): Clause
+{
+  if (c == null || (c.op.tt === TokType.Text && c.op.tt !== s.op.tt))
+    return c;
+  else if (clauseEqual(c, s))
+    return null;
+  else
+  {
+    c.operand1 = removeClause(c.operand1, s);
+    c.operand2 = removeClause(c.operand2, s);
+    if ((c.op.tt === TokType.And || c.op.tt === TokType.Or) && (c.operand1 == null || c.operand2 == null))
+      return c.operand1 || c.operand2;
+    return c;
+  }
+}
+
 export class FilterExpr
 {
   lexer: Lexer;
@@ -512,12 +551,47 @@ export class FilterExpr
     return this.asStringClause(this.parser.clause);
   }
 
+  containsClause(expr: string): boolean
+  {
+    let sub = new FilterExpr(this.lexer.coder, expr);
+    return containsClause(this.parser.clause, sub.parser.clause);
+  }
+
+  addClause(expr: string): void
+  {
+    let sub = new FilterExpr(this.lexer.coder, expr);
+    if (! containsClause(this.parser.clause, sub.parser.clause))
+    {
+      if (this.parser.clause)
+        this.parser.clauses = [ { op: { tt: TokType.And }, operand1: this.parser.clause, operand2: sub.parser.clause } ];
+      else
+        this.parser.clauses = [ sub.parser.clause ];
+    }
+  }
+
+  removeClause(expr: string): void
+  {
+    if (this.containsClause(expr))
+    {
+      let sub = new FilterExpr(this.lexer.coder, expr);
+      this.parser.clauses = [ removeClause(this.parser.clause, sub.parser.clause) ];
+    }
+  }
+
   asStringClause(clause: Clause): string
   {
     if (clause == null) return '';
-    if (clause.op.tt == TokType.Text) return `'${clause.op.text}'`;
+    if (clause.op.tt == TokType.Text)
+    {
+      this.lexer.set(clause.op.text);
+      if (this.lexer.tokens.length == 1 && this.lexer.tokens[0].tt === TokType.Text)
+        return clause.op.text;
+      else
+        return `'${clause.op.text}'`;
+    }
     let a: string[] = [];
-    a.push('(');
+    if (clause !== this.parser.clause)
+      a.push('(');
     switch (clause.op.tt)
     {
       case TokType.And:
@@ -535,8 +609,7 @@ export class FilterExpr
         a.push(this.asStringClause(clause.operand1));
         break;
       case TokType.Colon:
-        a.push(this.asStringClause(clause.operand1));
-        a.push(':');
+        a.push(`${this.asStringClause(clause.operand1)}:`);
         a.push(this.asStringClause(clause.operand2));
         break;
       case TokType.Equal:
@@ -551,7 +624,8 @@ export class FilterExpr
       default:
         throw 'Unexpected token in asString';
     }
-    a.push(')');
+    if (clause !== this.parser.clause)
+      a.push(')');
     return a.join(' ');
   }
 

package/lib/fsm/fsm.ts

@@ -291,6 +291,7 @@ export class FsmOnDone extends Fsm
 export class FsmSleep extends Fsm
 {
   delay: number;
+  timeoutHandle: any;
 
   constructor(env: FsmEnvironment, delay: number)
     {
@@ -300,10 +301,19 @@ export class FsmSleep extends Fsm
 
   tick(): void
     {
-      if (this.ready && this.state === FSM_STARTING)
+      // This allows canceling by simply setting state to done
+      if (this.done && this.timeoutHandle !== undefined)
+      {
+        clearTimeout(this.timeoutHandle);
+        delete this.timeoutHandle;
+      }
+      else if (this.ready && this.state === FSM_STARTING)
       {
         this.setState(FSM_PENDING);
-        setTimeout(() => { this.setState(FSM_DONE); }, this.delay);
+        this.timeoutHandle = setTimeout(() => {
+            delete this.timeoutHandle;
+            this.setState(FSM_DONE)
+          }, this.delay);
       }
     }
 }

package/lib/geo/all.ts

@@ -0,0 +1,2 @@
+export * from './geo';
+export * from './vfeature';