solanapolis 1.0.0

package/convex/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "allowJs": true,
+    "strict": true,
+    "target": "ESNext",
+    "lib": ["ES2021", "dom"],
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true,
+    "paths": {
+      "convex/_generated/*": ["./_generated/*"]
+    },
+    "moduleResolution": "Bundler",
+    "module": "ESNext",
+    "noEmit": true
+  },
+  "include": ["./**/*.ts"],
+  "exclude": ["./_generated"]
+}

package/convex/util/FastIntegerCompression.ts

@@ -0,0 +1,221 @@
+/**
+ * FastIntegerCompression.js : a fast integer compression library in JavaScript.
+ * From https://github.com/lemire/FastIntegerCompression.js/
+ * (c) the authors
+ * Licensed under the Apache License, Version 2.0.
+ *
+ *FastIntegerCompression
+ * Simple usage :
+ *  // var FastIntegerCompression = require("fastintcompression");// if you use node
+ *  var array = [10,100000,65999,10,10,0,1,1,2000];
+ *  var buf = FastIntegerCompression.compress(array);
+ *  var back = FastIntegerCompression.uncompress(buf); // gets back [10,100000,65999,10,10,0,1,1,2000]
+ *
+ *
+ * You can install the library under node with the command line
+ *   npm install fastintcompression
+ */
+
+function bytelog(val: number) {
+  if (val < 1 << 7) {
+    return 1;
+  } else if (val < 1 << 14) {
+    return 2;
+  } else if (val < 1 << 21) {
+    return 3;
+  } else if (val < 1 << 28) {
+    return 4;
+  }
+  return 5;
+}
+
+function zigzag_encode(val: number) {
+  return (val + val) ^ (val >> 31);
+}
+
+function zigzag_decode(val: number) {
+  return (val >> 1) ^ -(val & 1);
+}
+
+// Compute how many bytes an array of integers would use once compressed.
+// The input is expected to be an array of non-negative integers.
+export function computeCompressedSizeInBytes(input: number[]) {
+  var c = input.length;
+  var answer = 0;
+  for (var i = 0; i < c; i++) {
+    answer += bytelog(input[i]);
+  }
+  return answer;
+}
+
+// Compute how many bytes an array of integers would use once compressed.
+// The input is expected to be an array of integers, some of them can be negative.
+export function computeCompressedSizeInBytesSigned(input: number[]) {
+  var c = input.length;
+  var answer = 0;
+  for (var i = 0; i < c; i++) {
+    answer += bytelog(zigzag_encode(input[i]));
+  }
+  return answer;
+}
+
+// Compress an array of integers, return a compressed buffer (as an ArrayBuffer).
+// It is expected that the integers are non-negative: the caller is responsible
+// for making this check. Floating-point numbers are not supported.
+export function compress(input: number[]) {
+  var c = input.length;
+  var buf = new ArrayBuffer(computeCompressedSizeInBytes(input));
+  var view = new Int8Array(buf);
+  var pos = 0;
+  for (var i = 0; i < c; i++) {
+    var val = input[i];
+    if (val < 1 << 7) {
+      view[pos++] = val;
+    } else if (val < 1 << 14) {
+      view[pos++] = (val & 0x7f) | 0x80;
+      view[pos++] = val >>> 7;
+    } else if (val < 1 << 21) {
+      view[pos++] = (val & 0x7f) | 0x80;
+      view[pos++] = ((val >>> 7) & 0x7f) | 0x80;
+      view[pos++] = val >>> 14;
+    } else if (val < 1 << 28) {
+      view[pos++] = (val & 0x7f) | 0x80;
+      view[pos++] = ((val >>> 7) & 0x7f) | 0x80;
+      view[pos++] = ((val >>> 14) & 0x7f) | 0x80;
+      view[pos++] = val >>> 21;
+    } else {
+      view[pos++] = (val & 0x7f) | 0x80;
+      view[pos++] = ((val >>> 7) & 0x7f) | 0x80;
+      view[pos++] = ((val >>> 14) & 0x7f) | 0x80;
+      view[pos++] = ((val >>> 21) & 0x7f) | 0x80;
+      view[pos++] = val >>> 28;
+    }
+  }
+  return buf;
+}
+
+// From a compressed array of integers stored ArrayBuffer,
+// compute the number of compressed integers by scanning the input.
+export function computeHowManyIntegers(input: ArrayBuffer) {
+  var view = new Uint8Array(input);
+  var c = view.length;
+  var count = 0;
+  for (var i = 0; i < c; i++) {
+    count += view[i] >>> 7;
+  }
+  return c - count;
+}
+// Uncompress an array of integer from an ArrayBuffer, return the array.
+// It is assumed that they were compressed using the compress function, the caller
+// is responsible for ensuring that it is the case.
+export function uncompress(input: ArrayBuffer) {
+  var array = []; // The size of the output is not yet known.
+  var inbyte = new Int8Array(input);
+  var end = inbyte.length;
+  var pos = 0;
+  while (end > pos) {
+    var c = inbyte[pos++];
+    var v = c & 0x7f;
+    if (c >= 0) {
+      array.push(v);
+      continue;
+    }
+    c = inbyte[pos++];
+    v |= (c & 0x7f) << 7;
+    if (c >= 0) {
+      array.push(v);
+      continue;
+    }
+    c = inbyte[pos++];
+    v |= (c & 0x7f) << 14;
+    if (c >= 0) {
+      array.push(v);
+      continue;
+    }
+    c = inbyte[pos++];
+    v |= (c & 0x7f) << 21;
+    if (c >= 0) {
+      array.push(v);
+      continue;
+    }
+    c = inbyte[pos++];
+    v |= c << 28;
+    v >>>= 0; // make positive
+    array.push(v);
+  }
+  return array;
+}
+
+// Compress an array of integers, return a compressed buffer (as an ArrayBuffer).
+// The integers can be signed (negative), but floating-point values are not supported.
+export function compressSigned(input: number[]) {
+  var c = input.length;
+  var buf = new ArrayBuffer(computeCompressedSizeInBytesSigned(input));
+  var view = new Int8Array(buf);
+  var pos = 0;
+  for (var i = 0; i < c; i++) {
+    var val = zigzag_encode(input[i]);
+    if (val < 1 << 7) {
+      view[pos++] = val;
+    } else if (val < 1 << 14) {
+      view[pos++] = (val & 0x7f) | 0x80;
+      view[pos++] = val >>> 7;
+    } else if (val < 1 << 21) {
+      view[pos++] = (val & 0x7f) | 0x80;
+      view[pos++] = ((val >>> 7) & 0x7f) | 0x80;
+      view[pos++] = val >>> 14;
+    } else if (val < 1 << 28) {
+      view[pos++] = (val & 0x7f) | 0x80;
+      view[pos++] = ((val >>> 7) & 0x7f) | 0x80;
+      view[pos++] = ((val >>> 14) & 0x7f) | 0x80;
+      view[pos++] = val >>> 21;
+    } else {
+      view[pos++] = (val & 0x7f) | 0x80;
+      view[pos++] = ((val >>> 7) & 0x7f) | 0x80;
+      view[pos++] = ((val >>> 14) & 0x7f) | 0x80;
+      view[pos++] = ((val >>> 21) & 0x7f) | 0x80;
+      view[pos++] = val >>> 28;
+    }
+  }
+  return buf;
+}
+
+// Uncompress an array of integer from an ArrayBuffer, return the array.
+// It is assumed that they were compressed using the compressSigned function, the caller
+// is responsible for ensuring that it is the case.
+export function uncompressSigned(input: ArrayBuffer) {
+  var array = []; // The size of the output is not yet known.
+  var inbyte = new Int8Array(input);
+  var end = inbyte.length;
+  var pos = 0;
+  while (end > pos) {
+    var c = inbyte[pos++];
+    var v = c & 0x7f;
+    if (c >= 0) {
+      array.push(zigzag_decode(v));
+      continue;
+    }
+    c = inbyte[pos++];
+    v |= (c & 0x7f) << 7;
+    if (c >= 0) {
+      array.push(zigzag_decode(v));
+      continue;
+    }
+    c = inbyte[pos++];
+    v |= (c & 0x7f) << 14;
+    if (c >= 0) {
+      array.push(zigzag_decode(v));
+      continue;
+    }
+    c = inbyte[pos++];
+    v |= (c & 0x7f) << 21;
+    if (c >= 0) {
+      array.push(zigzag_decode(v));
+      continue;
+    }
+    c = inbyte[pos++];
+    v |= c << 28;
+    array.push(zigzag_decode(v));
+  }
+  return array;
+}

package/convex/util/assertNever.ts

@@ -0,0 +1,4 @@
+// From https://www.typescriptlang.org/docs/handbook/unions-and-intersections.html#union-exhaustiveness-checking
+export function assertNever(x: never): never {
+  throw new Error(`Unexpected object: ${JSON.stringify(x)}`);
+}

package/convex/util/asyncMap.ts

@@ -0,0 +1,20 @@
+/**
+ * asyncMap returns the results of applying an async function over an list.
+ *
+ * @param list - Iterable object of items, e.g. an Array, Set, Object.keys
+ * @param asyncTransform
+ * @returns
+ */
+
+export async function asyncMap<FromType, ToType>(
+  list: Iterable<FromType>,
+  asyncTransform: (item: FromType, index: number) => Promise<ToType>,
+): Promise<ToType[]> {
+  const promises: Promise<ToType>[] = [];
+  let idx = 0;
+  for (const item of list) {
+    promises.push(asyncTransform(item, idx));
+    idx += 1;
+  }
+  return Promise.all(promises);
+}

package/convex/util/compression.ts

@@ -0,0 +1,71 @@
+export function quantize(values: number[], precision: number) {
+  const factor = 1 << precision;
+  return values.map((v) => Math.floor(v * factor));
+}
+
+export function unquantize(quantized: number[], precision: number) {
+  const reciprocal = 1 / (1 << precision);
+  return quantized.map((q) => q * reciprocal);
+}
+
+export function deltaEncode(values: number[], initialValue = 0) {
+  let prev = initialValue;
+  const deltas = [];
+  for (const value of values) {
+    deltas.push(value - prev);
+    prev = value;
+  }
+  return deltas;
+}
+
+export function deltaDecode(deltas: number[], initialValue = 0) {
+  let prev = initialValue;
+  const values = [];
+  for (const delta of deltas) {
+    const value = prev + delta;
+    values.push(value);
+    prev = value;
+  }
+  return values;
+}
+
+export function runLengthEncode(values: number[]) {
+  let hasPrevious = false;
+  let previous = 0;
+  let count = 0;
+  const encoded = [];
+  for (const value of values) {
+    if (!hasPrevious) {
+      previous = value;
+      count = 1;
+      hasPrevious = true;
+      continue;
+    }
+    if (previous === value) {
+      count += 1;
+      continue;
+    }
+    encoded.push(previous, count);
+    previous = value;
+    count = 1;
+  }
+  if (hasPrevious) {
+    encoded.push(previous, count);
+  }
+  return encoded;
+}
+
+export function runLengthDecode(encoded: number[]) {
+  if (encoded.length % 2 !== 0) {
+    throw new Error(`Invalid RLE encoded length: ${encoded.length}`);
+  }
+  const values = [];
+  for (let i = 0; i < encoded.length; i += 2) {
+    const value = encoded[i];
+    const count = encoded[i + 1];
+    for (let j = 0; j < count; j++) {
+      values.push(value);
+    }
+  }
+  return values;
+}

package/convex/util/geometry.ts

@@ -0,0 +1,132 @@
+import { Path, PathComponent, Point, Vector, packPathComponent, queryPath } from './types';
+
+export function distance(p0: Point, p1: Point): number {
+  const dx = p0.x - p1.x;
+  const dy = p0.y - p1.y;
+  return Math.sqrt(dx * dx + dy * dy);
+}
+
+export function pointsEqual(p0: Point, p1: Point): boolean {
+  return p0.x == p1.x && p0.y == p1.y;
+}
+
+export function manhattanDistance(p0: Point, p1: Point) {
+  return Math.abs(p0.x - p1.x) + Math.abs(p0.y - p1.y);
+}
+
+export function pathOverlaps(path: Path, time: number): boolean {
+  if (path.length < 2) {
+    throw new Error(`Invalid path: ${JSON.stringify(path)}`);
+  }
+  const start = queryPath(path, 0);
+  const end = queryPath(path, path.length - 1);
+  return start.t <= time && time <= end.t;
+}
+
+export function pathPosition(
+  path: Path,
+  time: number,
+): { position: Point; facing: Vector; velocity: number } {
+  if (path.length < 2) {
+    throw new Error(`Invalid path: ${JSON.stringify(path)}`);
+  }
+  const first = queryPath(path, 0);
+  if (time < first.t) {
+    return { position: first.position, facing: first.facing, velocity: 0 };
+  }
+  const last = queryPath(path, path.length - 1);
+  if (last.t < time) {
+    return { position: last.position, facing: last.facing, velocity: 0 };
+  }
+  for (let i = 0; i < path.length - 1; i++) {
+    const segmentStart = queryPath(path, i);
+    const segmentEnd = queryPath(path, i + 1);
+    if (segmentStart.t <= time && time <= segmentEnd.t) {
+      const interp = (time - segmentStart.t) / (segmentEnd.t - segmentStart.t);
+      return {
+        position: {
+          x: segmentStart.position.x + interp * (segmentEnd.position.x - segmentStart.position.x),
+          y: segmentStart.position.y + interp * (segmentEnd.position.y - segmentStart.position.y),
+        },
+        facing: segmentStart.facing,
+        velocity:
+          distance(segmentStart.position, segmentEnd.position) / (segmentEnd.t - segmentStart.t),
+      };
+    }
+  }
+  throw new Error(`Timestamp checks not exhaustive?`);
+}
+
+export const EPSILON = 0.0001;
+
+export function vector(p0: Point, p1: Point): Vector {
+  const dx = p1.x - p0.x;
+  const dy = p1.y - p0.y;
+  return { dx, dy };
+}
+
+export function vectorLength(vector: Vector): number {
+  return Math.sqrt(vector.dx * vector.dx + vector.dy * vector.dy);
+}
+
+export function normalize(vector: Vector): Vector | null {
+  const len = vectorLength(vector);
+  if (len < EPSILON) {
+    return null;
+  }
+  const { dx, dy } = vector;
+  return {
+    dx: dx / len,
+    dy: dy / len,
+  };
+}
+
+export function orientationDegrees(vector: Vector): number {
+  if (Math.sqrt(vector.dx * vector.dx + vector.dy * vector.dy) < EPSILON) {
+    throw new Error(`Can't compute the orientation of too small vector ${JSON.stringify(vector)}`);
+  }
+  const twoPi = 2 * Math.PI;
+  const radians = (Math.atan2(vector.dy, vector.dx) + twoPi) % twoPi;
+  return (radians / twoPi) * 360;
+}
+
+export function compressPath(densePath: PathComponent[]): Path {
+  const packed = densePath.map(packPathComponent);
+  if (densePath.length <= 2) {
+    return densePath.map(packPathComponent);
+  }
+  const out = [packPathComponent(densePath[0])];
+  let last = densePath[0];
+  let candidate;
+  for (const point of densePath.slice(1)) {
+    if (!candidate) {
+      candidate = point;
+      continue;
+    }
+    // We can skip `candidate` if it interpolates cleanly between
+    // `last` and `point`.
+    const { position, facing } = pathPosition(
+      [packPathComponent(last), packPathComponent(point)],
+      candidate.t,
+    );
+    const positionCloseEnough = distance(position, candidate.position) < EPSILON;
+    const facingDifference = {
+      dx: facing.dx - candidate.facing.dx,
+      dy: facing.dy - candidate.facing.dy,
+    };
+    const facingCloseEnough = vectorLength(facingDifference) < EPSILON;
+
+    if (positionCloseEnough && facingCloseEnough) {
+      candidate = point;
+      continue;
+    }
+
+    out.push(packPathComponent(candidate));
+    last = candidate;
+    candidate = point;
+  }
+  if (candidate) {
+    out.push(packPathComponent(candidate));
+  }
+  return out;
+}

package/convex/util/isSimpleObject.ts

@@ -0,0 +1,11 @@
+export function isSimpleObject(value: unknown) {
+  const isObject = typeof value === 'object';
+  const prototype = Object.getPrototypeOf(value);
+  const isSimple =
+    prototype === null ||
+    prototype === Object.prototype ||
+    // Objects generated from other contexts (e.g. across Node.js `vm` modules) will not satisfy the previous
+    // conditions but are still simple objects.
+    prototype?.constructor?.name === 'Object';
+  return isObject && isSimple;
+}