@dra2020/baseclient 1.0.0

package/lib/ot-js/otsession.ts

@@ -0,0 +1,199 @@
+// Errors
+export const ESuccess: number = 0;      // Generic success
+export const EFail: number = 1;         // Generic failure
+export const EFull: number = 2;         // Too many clients attached to this session; try later
+export const ERetry: number = 3;        // Try request again
+export const ENoSession: number = 4;		// No record of such session
+export const EClockSeen: number = 5;
+export const EClockFailure: number = 6;
+export const EClockReset: number = 7;
+export const ENoUser: number = 8;       // No user specified (internal error since all authorized reqs have user)
+export const EBadRequest: number = 9;   // Badly formed request
+export const ELoadFailed: number = 10;  // Session exists in index, but load of state failed ((temp?) internal error)
+export const ENoPerm: number = 11;      // No permissions (readonly)
+export const ENoAccess: number = 12;    // No access (no read)
+export const EMaintenance: number = 13; // Server under maintenance
+export const EClockAnomaly: number = 14;  // Typically server restart and client is ahead
+
+// Filters
+export const FilterMyMaps: number = 0;
+export const FilterSharedWithMe: number = 1;
+export const FilterMyPublic: number = 2;
+export const FilterRecent: number = 3;
+export const FilterTrash: number = 4;
+export const FilterPublic: number = 5;
+export const FilterOfficial: number = 6;
+export const FilterCount: number = 7;
+export type Filter = number;
+
+// Permissions
+export const PermNone: number = 0;      // No permissions
+export const PermRead: number = 1;      // Can view
+export const PermWrite: number = 2;     // Can modify
+export const PermOwner: number = 4;     // Can change deleted, published, access permissions
+export const PermAdmin: number = 8;     // Can administer site
+export const PermEdit: number = (PermWrite|PermOwner);
+export const PermAll: number = (PermRead|PermWrite|PermOwner|PermAdmin);
+export type Permission = number;
+
+// Server State
+export const ServerStateRunning: number = 0;
+export const ServerStateMaintenance: number = 1;
+export type ServerState = number;
+
+// Maps Access Tokens (IDs) to SessionID
+export interface AccessSessionMap
+{
+  [key: string]: string;
+}
+
+// Maps Access ID to { list of users, permission } (stored with session)
+export interface AccessMap
+{
+  [key: string]: Access;
+}
+
+export interface Access
+{
+  userIDs: string[];  // empty implies "anyone"
+  perm: Permission;
+}
+
+export interface Revision
+{
+  id: string;
+  modifyTime: any;  // JSON date
+  label?: string;   // optional label
+}
+
+export type RevisionList = Revision[];
+
+export interface SessionUser
+{
+	id: string;
+	name: string;
+}
+
+export interface ActiveUser
+{
+	id: string;
+	name: string;
+	active: number;
+}
+
+export interface SessionUserIndex
+{
+	[key: string]: SessionUser;
+}
+
+export interface SessionUserList
+{
+	[key: string]: number;
+}
+
+export interface SessionProps
+{
+  id: string;
+  name: string;
+  type: string;
+  description: string;
+  labels: string[];
+  createdBy: string;
+  lastActive: any;		// JSON date (should be string)
+  createTime: any;    // JSON date (should be string)
+  modifyTime: any;    // JSON date (should be string)
+  clientCount: number;
+  maxClients: number;
+  requestCount: number;
+  deleted: boolean;
+  published?: string;
+  official: boolean;
+	loadFailed: boolean;
+  accessMap: AccessMap;
+  revisions: RevisionList;
+  xprops?: { [prop: string]: string };
+}
+
+// True to add, False to remove
+export type LabelUpdate = { [name: string]: boolean|null }
+
+export interface SessionUpdateProps
+{
+	id: string;
+	deleted?: boolean;
+	published?: boolean;
+	official?: boolean;
+  name?: string;
+  description?: string;
+  labelupdate?: LabelUpdate;
+  access?: Access;
+  accessUpdate?: AccessMap;
+  restore?: string; // Revision ID
+  revision?: Revision;  // If ID is empty, snap a new revision, otherwise label it.
+}
+
+export interface SessionsIndex
+{
+	[key: string]: SessionProps;
+}
+
+// The semantics here are:
+//  if aid is provided, only look through that access token.
+//  if aid is missing, look for that user in any access token (but ignore anonymous tokens).
+//  in either case, return the full set of permissions a user has.
+//
+export function accessFindUser(a: Access, uid: string): Permission
+{
+  if (a === undefined) return PermNone;
+  if (a.userIDs.length == 0)
+    return a.perm;
+  for (let i: number = 0; i < a.userIDs.length; i++)
+    if (a.userIDs[i] === uid) return a.perm;
+  return PermNone;
+}
+
+export function accessMapFindUser(accessMap: AccessMap, uid: string, aid?: string): Permission
+{
+  if (aid !== undefined)
+    return accessFindUser(accessMap[aid], uid);
+  else
+  {
+    let perm: Permission = PermNone;
+    for (var aid1 in accessMap) if (accessMap.hasOwnProperty(aid1))
+    {
+      let a = accessMap[aid1];
+      for (let i: number = 0; i < a.userIDs.length; i++)
+        if (a.userIDs[i] === uid)
+        {
+          perm |= a.perm;
+          break;
+        }
+    }
+    return perm;
+  }
+}
+
+export function SessionFilterFunction(p: SessionProps, uid: string, f: number): boolean
+{
+	if (f === FilterPublic) return p.published !== undefined;
+
+	if (f === FilterSharedWithMe)
+	{
+		if (p.createdBy === uid) return false;
+    return true;
+	}
+
+	// All other filters require ownership of this session
+	if (p.createdBy !== uid) return false;
+
+	if (f === FilterTrash) return p.deleted;
+
+  if (f === FilterRecent && !p.deleted && p.modifyTime)
+  {
+    let d = new Date();
+    let interval = d.getTime() - new Date(p.modifyTime).getTime();
+    return interval < (1000 * 60 * 60 * 24 * 7);  // one week
+  }
+
+	return !p.deleted;
+}

package/lib/ot-js/ottypes.ts

@@ -0,0 +1,98 @@
+
+// Resource data type that supports basic OT inteface.
+export interface IOTResource
+{
+	resourceName: string;
+	underlyingType: string;
+	edits: any[];
+
+	// Normally defined by base class
+	length: number;
+	empty(): void;
+	isEmpty(): boolean;
+
+	// Copy an instance
+	copy(): IOTResource;
+
+	// Test whether two operations are effectively equivalent
+	effectivelyEqual(rhs: IOTResource): boolean;
+
+	// Core OT algorithm for this type
+	transform(rhs: IOTResource, bPriorIsService: boolean): void;			// throws on error
+
+	// compose two edit actions
+	compose(rhs: IOTResource): void; 			// throws on error
+
+	// apply this edit to an existing value, returning new value (if underlying type is mutable, may modify input)
+	apply(startValue: any): any;
+
+	// return a collapsed, minimal version of the operation, suitable for constructing from scratch from empty initial value
+	minimize(): void;
+}
+
+// Useful base class
+export class OTResourceBase implements IOTResource
+{
+	resourceName: string;
+	underlyingType: string;
+	edits: any[];
+
+	constructor(rname: string, utype: string)
+		{
+			this.resourceName = rname;
+			this.underlyingType = utype;
+			this.edits = [];
+		}
+
+	get length(): number
+		{
+			return this.edits.length;
+		}
+
+	// Set an existing instance of the operation to be empty
+	empty(): void
+		{
+			this.edits = [];
+		}
+
+	// Test
+	isEmpty(): boolean
+		{
+			return this.edits.length == 0;
+		}
+
+	// Copy an instance
+	copy(): OTResourceBase
+		{
+			throw "OTResourceBase.copy must be overridden in subclass";
+		}
+
+	// Test whether two operations are effectively equivalent
+	effectivelyEqual(rhs: OTResourceBase): boolean
+		{
+			throw "OTResourceBase.effectivelyEqual must be overridden in subclass";
+		}
+
+	// Core OT algorithm for this type
+	transform(rhs: OTResourceBase, bPriorIsService: boolean): void
+		{
+			throw "OTResourceBase.transform must be overridden in subclass";
+		}
+
+	// compose two edit actions
+	compose(rhs: OTResourceBase): void
+		{
+			throw "OTResourceBase.compose must be overridden in subclass";
+		}
+
+	// apply this edit to an existing value, returning new value (if underlying type is mutable, may modify input)
+	apply(startValue: any): any
+		{
+			throw "OTResourceBase.apply must be overridden in subclass";
+		}
+
+	minimize(): void
+		{
+			// Default implementation does nothing.
+		}
+}

package/lib/poly/all.ts

@@ -0,0 +1,15 @@
+export * from './poly';
+export * from './union';
+export * from './quad';
+export * from './polylabel';
+export * from './polysimplify';
+export * from './polypack';
+export * from './polybin';
+export * from './boundbox';
+export * from './blend';
+export * from './cartesian';
+export * from './minbound';
+export * from './polyround';
+export * from './topo';
+export * from './selfintersect';
+export * from './shamos';

package/lib/poly/blend.ts

@@ -0,0 +1,27 @@
+import * as Util from '../util/all';
+import * as PP from './polypack';
+
+// Takes array of polygon or multi-polygon coordinate structures and returns a single multi-polygon
+// structure. The coordinates may be passed in using packed format.
+
+export function blend(polys: any[]): any
+{
+  if (polys == null || polys.length == 0) return null;
+
+  let result: any[] = [];
+
+  for (let i: number = 0; i < polys.length; i++)
+  {
+    let p = PP.polyUnpack(polys[i]);
+    let d = Util.depthof(p);
+    if (d === 4)
+      result.push(p);
+    else if (d === 5)
+      for (let j: number = 0; j < p.length; j++)
+        result.push(p[j]);
+    else if (p.length === undefined || p.length > 0)
+      throw new Error('blend expects polygon or multi-polygon coordinates');
+  }
+
+  return result;
+}

package/lib/poly/boundbox.ts

@@ -0,0 +1,102 @@
+import * as Util from '../util/all';
+
+import * as P from './poly';
+import * as PP from './polypack';
+
+// Note, in Geo format so top > bottom
+export interface BoundBox
+{
+  left?: number;
+  top?: number;
+  right?: number;
+  bottom?: number;
+}
+
+export function boundboxWidth(bb: BoundBox): number { return Math.abs(bb.right - bb.left); }
+export function boundboxHeight(bb: BoundBox): number { return Math.abs(bb.bottom - bb.top); }
+
+export function boundboxCX(bb: BoundBox): number { return bb.left + (bb.right - bb.left) / 2; }
+export function boundboxCY(bb: BoundBox): number { return bb.top + (bb.bottom - bb.top) / 2; }
+
+export function clipLon(lon: number): number { return lon <= 0 ? lon : -179; }
+
+export function boundboxExtend(bbox: BoundBox, x: number, y: number): void
+{
+  x = clipLon(x);
+  if (bbox.left === undefined || x < bbox.left)
+    bbox.left = x;
+  if (bbox.right === undefined || x > bbox.right)
+    bbox.right = x;
+  if (bbox.top === undefined || y > bbox.top)
+    bbox.top = y;
+  if (bbox.bottom === undefined || y < bbox.bottom)
+    bbox.bottom = y;
+}
+
+function boundboxExtendPacked(pp: PP.PolyPack, bbox: BoundBox): void
+{
+  let buffer = pp.buffer as Float64Array;
+  let offset = pp.buffer[pp.offset+1] + pp.offset;
+  let end = pp.offset + pp.length;
+  for (; offset < end; offset += 2)
+    boundboxExtend(bbox, buffer[offset], buffer[offset+1]);
+}
+
+export function boundbox(poly: any, bbox?: BoundBox): BoundBox
+{
+  let i: number;
+
+  if (bbox === undefined)
+    bbox = { };
+
+  if (poly)
+  {
+    // Collection
+    if (poly.features)
+    {
+      for (i = 0; i < poly.features.length; i++)
+        boundbox(poly.features[i], bbox);
+    }
+
+    // feature
+    else if (poly.geometry)
+    {
+      if (poly.geometry.packed)
+        boundboxExtendPacked(poly.geometry.packed as PP.PolyPack, bbox);
+      else if (poly.geometry.coordinates)
+        boundbox(poly.geometry.coordinates, bbox);
+    }
+
+    // raw packed buffer
+    else if (poly.offset !== undefined)
+      boundboxExtendPacked(poly as PP.PolyPack, bbox);
+
+    // array of other things (like raw coordinates, or other aggregates)
+    else if (Array.isArray(poly) && typeof poly[0] !== 'number')
+    {
+      for (i = 0; i < poly.length; i++)
+        boundbox(poly[i], bbox);
+    }
+
+    // single point
+    else
+      boundboxExtend(bbox, poly[0], poly[1]);
+  }
+
+  return bbox;
+}
+
+export function boundboxPoly(bb: BoundBox): any
+{
+  return [ [ [bb.left, bb.top], [bb.left, bb.bottom], [bb.right, bb.bottom], [bb.right, bb.top], [bb.left, bb.top] ] ];
+}
+
+export function boundboxArea(poly: any): number
+{
+  return P.polyArea(boundboxPoly(boundbox(poly)));
+}
+
+export function boundboxIntersects(bb1: BoundBox, bb2: BoundBox): boolean
+{
+  return !(bb1.left > bb2.right || bb1.right < bb2.left || bb1.top < bb2.bottom || bb1.bottom > bb2.top);
+}

package/lib/poly/cartesian.ts

@@ -0,0 +1,130 @@
+//
+// GEO-FEATURES UTILITIES
+//
+
+import * as GeoJSON from 'geojson';
+import * as P from './poly';
+import * as PP from './polypack';
+
+
+// HELPER
+
+function bufferToRing(b: Float64Array, s: number, nPoints: number): any
+{
+  let r: any = [];
+  let e = s + nPoints * 2;
+  for (; s < e; s += 2)
+    r.push([ b[s], b[s+1] ]);
+  return r;
+}
+
+export function polyParts(poly: any): GeoJSON.FeatureCollection
+{
+  let pp = P.polyNormalize(poly);
+
+  let parts: GeoJSON.FeatureCollection = { type: 'FeatureCollection', features: [] };
+  let af: any = parts.features;
+  let f: any;
+  PP.polyPackEachRing(pp, (b: Float64Array, iPoly: number, iRing: number, iOffset: number, nPoints: number) => {
+      let r = bufferToRing(b, iOffset, nPoints);
+      if (iRing == 0)
+      {
+        f = { type: 'Feature',
+              properties: { id: String(iPoly+1) },
+              geometry: { type: 'Polygon', coordinates: [ r ] } };
+        af.push(f);
+      }
+      else
+        f.geometry.coordinates.push(r);
+    });
+  return parts;
+}
+
+// CARTESIAN ("FLAT") AREA, PERIMETER, AND DIAMETER
+
+export function polyAreaFlat(poly: any): number
+{
+  let pp = P.polyNormalize(poly);
+
+  let a: number = 0;
+  PP.polyPackEachRing(pp, (b: Float64Array, iPoly: number, iRing: number, iOffset: number, nPoints: number) => {
+      a += polySimpleAreaFlat(b, iOffset, nPoints) * (iRing == 0 ? 1 : -1);
+    });
+  return a;
+}
+
+// Algorithm for the area of a simple/single planar polygon:
+// https://algorithmtutor.com/Computational-Geometry/Area-of-a-polygon-given-a-set-of-points/
+// https://mathopenref.com/coordpolygonarea2.html
+//
+// function polygonArea(X, Y, numPoints) 
+// { 
+//   area = 0;         // Accumulates area in the loop
+//   j = numPoints-1;  // The last vertex is the 'previous' one to the first
+
+//   for (i=0; i<numPoints; i++)
+//     { area = area +  (X[j]+X[i]) * (Y[j]-Y[i]); 
+//       j = i;  //j is previous vertex to i
+//     }
+//   return area/2;
+// }
+
+// Reimplemented to use polygons vs. X & Y vectors
+function polySimpleAreaFlat(b: Float64Array, i: number, nPoints: number): number
+{
+  let a = 0;
+  let e = i + nPoints * 2;
+  let j = e - 2;         // The last vertex is the 'previous' one to the first
+
+  for (; i < e; i += 2)
+  {
+    a += (b[j] + b[i]) * (b[j+1] - b[i+1]);
+    j = i;
+  }
+  return Math.abs(a / 2);
+}
+
+// You would need to divide by Poly.EARTH_RADIUS to go from the returned units of meters to Lat/Lon “units.”
+// NOTE - No conversion of degrees to radians!
+
+export function polyPerimeterFlat(poly: any): number
+{
+  let pp = P.polyNormalize(poly);
+
+  let perimeter: number = 0;
+  PP.polyPackEachRing(pp, (b: Float64Array, iPoly: number, iRing: number, iOffset: number, nPoints: number) => {
+      // Ignore holes so only look at first ring
+      if (iRing == 0)
+      {
+        let s = iOffset;
+        let e = s + (nPoints-1) * 2;  // index *at* last point since we look at next point in each iteration
+        for (; s < e; s += 2)
+          perimeter += _distance(b[s], b[s+1], b[s+2], b[s+3]);
+        s = iOffset;
+        if (nPoints > 2 && (b[s] != b[e] || b[s+1] != b[e+1]))
+          perimeter += _distance(b[s], b[s+1], b[e], b[e+1]);
+      }
+    });
+
+  return perimeter;
+}
+
+function _distance(x1: number, y1: number, x2: number, y2: number): number
+{
+  const dLat = y2 - y1;
+  const dLon = x2 - x1;
+  let d: number;
+
+  d = Math.sqrt((dLat * dLat) + (dLon * dLon));
+
+  return d;
+}
+
+// The polyCircle code is already just treating the coordinate system as Cartesian.
+// So just compute circle and return diameter.
+
+export function polyDiameterFlat(poly: any): number
+{
+  let circle = P.polyToCircle(poly);
+  return circle ? circle.r * 2 : 0;
+}