@dra2020/baseclient 1.0.12 → 1.0.13

package/lib/ot-js/otsession.ts

@@ -1,202 +0,0 @@
-// 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 FilterCOI: number = 7;
-export const FilterCount: number = 8;
-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;
-  expunged?: boolean;
-  expungeDate?: string;
-  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

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

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

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

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

@@ -1,130 +0,0 @@
-//
-// 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;
-}