@dra2020/baseclient 1.0.84 → 1.0.86

package/dist/csv/csv.d.ts

@@ -1,4 +1,13 @@
 import * as Util from '../util/all';
+export declare class ParseMany {
+    buf: Uint8Array;
+    n: number;
+    one: ParseOne;
+    constructor(coder: Util.Coder, buf: Uint8Array);
+    get length(): number;
+    get fields(): string[];
+    next(): boolean;
+}
 export declare class ParseOne {
     coder: Util.Coder;
     fields: string[];
@@ -12,6 +21,7 @@ export declare class ParseOne {
     force: boolean;
     constructor(coder: Util.Coder, line?: string);
     set(line: string): void;
+    setBuf(buf: Uint8Array): void;
     get length(): number;
     pushtok(): void;
     parse(): void;

package/dist/geo/all.d.ts

@@ -1,3 +1,4 @@
 export * from './geo';
 export * from './vfeature';
 export * from './flexname';
+export * from './multiblockmapping';

package/dist/geo/multiblockmapping.d.ts

@@ -0,0 +1,21 @@
+export declare type BlockMapping = {
+    [blockid: string]: string;
+};
+export declare type ReverseBlockMapping = {
+    [geoid: string]: string[];
+};
+interface Entry {
+    tag: string;
+    bm: BlockMapping;
+    rbm?: ReverseBlockMapping;
+}
+export declare function reverseBlockMapping(bm: BlockMapping): ReverseBlockMapping;
+export declare class MultiBlockMapping {
+    entries: Entry[];
+    constructor(tag?: string, bm?: BlockMapping);
+    add(tag: string, bm: BlockMapping): void;
+    remove(tag: string): void;
+    map(blockid: string): string;
+    rev(geoid: string): string[];
+}
+export {};

package/docs/fsm.md

@@ -191,14 +191,18 @@ An `Fsm` can be reused and transition from `ready` to not `ready` or `done` to n
 
 ### Cancellation
 
-There is no explicit cancellation mechanism.
+The standard member function `cancel` will set the state to `FSM_CANCEL` which is considered a done state as
+well as an error state (and will set the dependentError flag on any waiting state machines).
 
-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.
+By convention, a sub-class should override the `cancel` member function to allow external cancellation
+if it needs to do more internal cleanup than set the state to `FSM_CANCEL`.
 
-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.
+Additionally, it can use the `end` member function (by convention) to complete the state machine if that
+makes sense and does not wanted to be treated as an error.
+The class should override the `end` member function if it needs to do cleanup and finalization internally.
+
+If a class internally is implemented with callbacks or promises, by convention it should check `if this.done`
+when the callback or promise completes to check whether it may have been externally canceled while awaiting.
 
 ### FsmOnDone
 

package/lib/csv/csv.ts

@@ -23,6 +23,56 @@ function isWhite(c: number): boolean
   return c === Space || c === Newline || c === Tab || c == CR;
 }
 
+// Keep calling next() to retrieve next parsed line. Returns false when done. Empty lines are ignored.
+
+export class ParseMany
+{
+  buf: Uint8Array;
+  n: number;
+  one: ParseOne;
+
+  constructor(coder: Util.Coder, buf: Uint8Array)
+  {
+    this.buf = buf;
+    this.n = 0;
+    this.one = new ParseOne(coder);
+  }
+
+  get length(): number { return this.one.length }
+  get fields(): string[] { return this.one.fields }
+
+  next(): boolean
+  {
+    // Move past any leading CRLF
+    while (this.n < this.buf.length)
+    {
+      let c = this.buf[this.n];
+      if (c == CR || c == Newline)
+        this.n++;
+      else
+        break;
+    }
+
+    let s = this.n;
+    while (this.n < this.buf.length)
+    {
+      let c = this.buf[this.n];
+      if (c == CR || c == Newline)
+        break;
+      else
+        this.n++;
+    }
+
+    if (s != this.n)
+    {
+      this.one.setBuf(this.buf.subarray(s, this.n));
+      return true;
+    }
+    else
+      return false;
+  }
+}
+
 export class ParseOne
 {
   coder: Util.Coder;
@@ -47,9 +97,15 @@ export class ParseOne
 
   set(line: string): void
   {
+    this.setBuf(Util.s2u8(this.coder, line));
+  }
+
+  setBuf(buf: Uint8Array): void
+  {
+    this.buf = buf;
     this.fields = [];
-    this.buf = Util.s2u8(this.coder, line);
-    this.tok = new Uint8Array(new ArrayBuffer(this.buf.length));
+    if (!this.tok || this.tok.length < this.buf.length)
+      this.tok = new Uint8Array(new ArrayBuffer(this.buf.length));
     this.n = 0;
     this.toklen = 0;
     this.infield = false;

package/lib/geo/all.ts

@@ -1,3 +1,4 @@
 export * from './geo';
 export * from './vfeature';
 export * from './flexname';
+export * from './multiblockmapping';

package/lib/geo/multiblockmapping.ts

@@ -0,0 +1,72 @@
+export type BlockMapping = { [blockid: string]: string };
+export type ReverseBlockMapping = { [geoid: string]: string[] };
+
+interface Entry
+{
+  tag: string,
+  bm: BlockMapping,
+  rbm?: ReverseBlockMapping,
+}
+
+export function reverseBlockMapping(bm: BlockMapping): ReverseBlockMapping
+{
+  let rev: ReverseBlockMapping = {};
+
+  if (bm) Object.keys(bm).forEach(blockid => {
+      let geoid = bm[blockid];
+      if (! rev[geoid]) rev[geoid] = [];
+      rev[geoid].push(blockid);
+    });
+  Object.values(rev).forEach((a: string[]) => a.sort());
+  return rev;
+}
+
+export class MultiBlockMapping
+{
+  entries: Entry[];
+
+  constructor(tag?: string, bm?: BlockMapping)
+  {
+    this.entries = [];
+    if (tag && bm)
+      this.entries.push({ tag, bm });
+  }
+
+  add(tag: string, bm: BlockMapping): void
+  {
+    this.entries.forEach(e => { if (e.tag === tag) { e.bm = bm; delete e.rbm; bm = null } });
+    if (bm)
+      this.entries.push({ tag, bm });
+  }
+
+  remove(tag: string): void
+  {
+    for (let i = this.entries.length-1; i >= 0; i--)
+      if (this.entries[i].tag === tag)
+        this.entries.splice(i, 1);
+  }
+
+  map(blockid: string): string
+  {
+    for (let i = 0; i < this.entries.length; i++)
+    {
+      let e = this.entries[i];
+      if (e.bm[blockid])
+        return e.bm[blockid];
+    }
+    return undefined;
+  }
+
+  rev(geoid: string): string[]
+  {
+    for (let i = 0; i < this.entries.length; i++)
+    {
+      let e = this.entries[i];
+      if (! e.rbm)
+        e.rbm = reverseBlockMapping(e.bm);
+      if (e.rbm[geoid])
+        return e.rbm[geoid];
+    }
+    return undefined;
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dra2020/baseclient",
-  "version": "1.0.84",
+  "version": "1.0.86",
   "description": "Utility functions for Javascript projects.",
   "main": "dist/baseclient.js",
   "types": "./dist/all/all.d.ts",