@logic-pad/core 0.1.0

package/assets/z3-built.worker.js

@@ -0,0 +1,206 @@
+/**
+ * @license
+ * Copyright 2015 The Emscripten Authors
+ * SPDX-License-Identifier: MIT
+ */
+
+// Pthread Web Worker startup routine:
+// This is the entry point file that is loaded first by each Web Worker
+// that executes pthreads on the Emscripten application.
+
+'use strict';
+
+var Module = {};
+
+// Node.js support
+var ENVIRONMENT_IS_NODE = typeof process == 'object' && typeof process.versions == 'object' && typeof process.versions.node == 'string';
+if (ENVIRONMENT_IS_NODE) {
+  // Create as web-worker-like an environment as we can.
+
+  var nodeWorkerThreads = require('worker_threads');
+
+  var parentPort = nodeWorkerThreads.parentPort;
+
+  parentPort.on('message', function(data) {
+    onmessage({ data: data });
+  });
+
+  var fs = require('fs');
+
+  Object.assign(global, {
+    self: global,
+    require: require,
+    Module: Module,
+    location: {
+      href: __filename
+    },
+    Worker: nodeWorkerThreads.Worker,
+    importScripts: function(f) {
+      (0, eval)(fs.readFileSync(f, 'utf8'));
+    },
+    postMessage: function(msg) {
+      parentPort.postMessage(msg);
+    },
+    performance: global.performance || {
+      now: function() {
+        return Date.now();
+      }
+    },
+  });
+}
+
+// Thread-local guard variable for one-time init of the JS state
+var initializedJS = false;
+
+// Proxying queues that were notified before the thread started and need to be
+// executed as part of startup.
+var pendingNotifiedProxyingQueues = [];
+
+function assert(condition, text) {
+  if (!condition) abort('Assertion failed: ' + text);
+}
+
+function threadPrintErr() {
+  var text = Array.prototype.slice.call(arguments).join(' ');
+  // See https://github.com/emscripten-core/emscripten/issues/14804
+  if (ENVIRONMENT_IS_NODE) {
+    fs.writeSync(2, text + '\n');
+    return;
+  }
+  console.error(text);
+}
+function threadAlert() {
+  var text = Array.prototype.slice.call(arguments).join(' ');
+  postMessage({cmd: 'alert', text: text, threadId: Module['_pthread_self']()});
+}
+// We don't need out() for now, but may need to add it if we want to use it
+// here. Or, if this code all moves into the main JS, that problem will go
+// away. (For now, adding it here increases code size for no benefit.)
+var out = () => { throw 'out() is not defined in worker.js.'; }
+var err = threadPrintErr;
+self.alert = threadAlert;
+
+Module['instantiateWasm'] = (info, receiveInstance) => {
+  // Instantiate from the module posted from the main thread.
+  // We can just use sync instantiation in the worker.
+  var instance = new WebAssembly.Instance(Module['wasmModule'], info);
+  // TODO: Due to Closure regression https://github.com/google/closure-compiler/issues/3193,
+  // the above line no longer optimizes out down to the following line.
+  // When the regression is fixed, we can remove this if/else.
+  receiveInstance(instance);
+  // We don't need the module anymore; new threads will be spawned from the main thread.
+  Module['wasmModule'] = null;
+  return instance.exports;
+}
+
+self.onmessage = (e) => {
+  try {
+    if (e.data.cmd === 'load') { // Preload command that is called once per worker to parse and load the Emscripten code.
+
+      // Module and memory were sent from main thread
+      Module['wasmModule'] = e.data.wasmModule;
+
+      Module['wasmMemory'] = e.data.wasmMemory;
+
+      Module['buffer'] = Module['wasmMemory'].buffer;
+
+      Module['ENVIRONMENT_IS_PTHREAD'] = true;
+
+      if (typeof e.data.urlOrBlob == 'string') {
+        importScripts(e.data.urlOrBlob);
+      } else {
+        var objectUrl = URL.createObjectURL(e.data.urlOrBlob);
+        importScripts(objectUrl);
+        URL.revokeObjectURL(objectUrl);
+      }
+      initZ3(Module).then(function (instance) {
+        Module = instance;
+      });
+    } else if (e.data.cmd === 'run') {
+      // This worker was idle, and now should start executing its pthread entry
+      // point.
+      // performance.now() is specced to return a wallclock time in msecs since
+      // that Web Worker/main thread launched. However for pthreads this can
+      // cause subtle problems in emscripten_get_now() as this essentially
+      // would measure time from pthread_create(), meaning that the clocks
+      // between each threads would be wildly out of sync. Therefore sync all
+      // pthreads to the clock on the main browser thread, so that different
+      // threads see a somewhat coherent clock across each of them
+      // (+/- 0.1msecs in testing).
+      Module['__performance_now_clock_drift'] = performance.now() - e.data.time;
+
+      // Pass the thread address inside the asm.js scope to store it for fast access that avoids the need for a FFI out.
+      Module['__emscripten_thread_init'](e.data.threadInfoStruct, /*isMainBrowserThread=*/0, /*isMainRuntimeThread=*/0, /*canBlock=*/1);
+
+      assert(e.data.threadInfoStruct);
+      // Also call inside JS module to set up the stack frame for this pthread in JS module scope
+      Module['establishStackSpace']();
+      Module['PThread'].receiveObjectTransfer(e.data);
+      Module['PThread'].threadInitTLS();
+
+      if (!initializedJS) {
+
+        // Execute any proxied work that came in before the thread was
+        // initialized. Only do this once because it is only possible for
+        // proxying notifications to arrive before thread initialization on
+        // fresh workers.
+        pendingNotifiedProxyingQueues.forEach(queue => {
+          Module['executeNotifiedProxyingQueue'](queue);
+        });
+        pendingNotifiedProxyingQueues = [];
+        initializedJS = true;
+      }
+
+      try {
+        Module['invokeEntryPoint'](e.data.start_routine, e.data.arg);
+      } catch(ex) {
+        if (ex != 'unwind') {
+          // ExitStatus not present in MINIMAL_RUNTIME
+          if (ex instanceof Module['ExitStatus']) {
+            if (Module['keepRuntimeAlive']()) {
+              err('Pthread 0x' + Module['_pthread_self']().toString(16) + ' called exit(), staying alive due to noExitRuntime.');
+            } else {
+              err('Pthread 0x' + Module['_pthread_self']().toString(16) + ' called exit(), calling _emscripten_thread_exit.');
+              Module['__emscripten_thread_exit'](ex.status);
+            }
+          }
+          else
+          {
+            // The pthread "crashed".  Do not call `_emscripten_thread_exit` (which
+            // would make this thread joinable.  Instead, re-throw the exception
+            // and let the top level handler propagate it back to the main thread.
+            throw ex;
+          }
+        } else {
+          // else e == 'unwind', and we should fall through here and keep the pthread alive for asynchronous events.
+          err('Pthread 0x' + Module['_pthread_self']().toString(16) + ' completed its main entry point with an `unwind`, keeping the worker alive for asynchronous operation.');
+        }
+      }
+    } else if (e.data.cmd === 'cancel') { // Main thread is asking for a pthread_cancel() on this thread.
+      if (Module['_pthread_self']()) {
+        Module['__emscripten_thread_exit'](-1/*PTHREAD_CANCELED*/);
+      }
+    } else if (e.data.target === 'setimmediate') {
+      // no-op
+    } else if (e.data.cmd === 'processProxyingQueue') {
+      if (initializedJS) {
+        Module['executeNotifiedProxyingQueue'](e.data.queue);
+      } else {
+        // Defer executing this queue until the runtime is initialized.
+        pendingNotifiedProxyingQueues.push(e.data.queue);
+      }
+    } else {
+      err('worker.js received unknown command ' + e.data.cmd);
+      err(e.data);
+    }
+  } catch(ex) {
+    err('worker.js onmessage() captured an uncaught exception: ' + ex);
+    if (ex && ex.stack) err(ex.stack);
+    if (Module['__emscripten_thread_crashed']) {
+      Module['__emscripten_thread_crashed']();
+    }
+    throw ex;
+  }
+};
+
+

package/dist/data/config.d.ts

@@ -0,0 +1,101 @@
+import GridData from './grid';
+import { Color, Comparison, Direction, DirectionToggle, Orientation, OrientationToggle } from './primitives';
+import { ControlLine } from './rules/musicControlLine';
+export declare enum ConfigType {
+    Boolean = "boolean",
+    NullableBoolean = "nullableBoolean",
+    Number = "number",
+    NullableNumber = "nullableNumber",
+    String = "string",
+    Color = "color",
+    Comparison = "comparison",
+    Direction = "direction",
+    DirectionToggle = "directionToggle",
+    Orientation = "orientation",
+    OrientationToggle = "orientationToggle",
+    Tile = "tile",
+    Grid = "grid",
+    NullableGrid = "nullableGrid",
+    Icon = "icon",
+    ControlLines = "controlLines",
+    NullableNote = "nullableNote"
+}
+export interface Config<T> {
+    readonly type: ConfigType;
+    readonly field: string;
+    readonly description: string;
+    readonly default: T;
+    readonly configurable: boolean;
+}
+export interface BooleanConfig extends Config<boolean> {
+    readonly type: ConfigType.Boolean;
+}
+export interface NullableBooleanConfig extends Config<boolean | null> {
+    readonly type: ConfigType.NullableBoolean;
+}
+export interface NumberConfig extends Config<number> {
+    readonly type: ConfigType.Number;
+    readonly min?: number;
+    readonly max?: number;
+    readonly step?: number;
+}
+export interface NullableNumberConfig extends Config<number | null> {
+    readonly type: ConfigType.NullableNumber;
+    readonly min?: number;
+    readonly max?: number;
+    readonly step?: number;
+}
+export interface StringConfig extends Config<string> {
+    readonly type: ConfigType.String;
+    readonly maxLength?: number;
+    readonly placeholder?: string;
+}
+export interface ColorConfig extends Config<Color> {
+    readonly type: ConfigType.Color;
+    readonly allowGray: boolean;
+}
+export interface ComparisonConfig extends Config<Comparison> {
+    readonly type: ConfigType.Comparison;
+}
+export interface DirectionConfig extends Config<Direction> {
+    readonly type: ConfigType.Direction;
+}
+export interface DirectionToggleConfig extends Config<DirectionToggle> {
+    readonly type: ConfigType.DirectionToggle;
+}
+export interface OrientationConfig extends Config<Orientation> {
+    readonly type: ConfigType.Orientation;
+}
+export interface OrientationToggleConfig extends Config<OrientationToggle> {
+    readonly type: ConfigType.OrientationToggle;
+}
+export interface TileConfig extends Config<GridData> {
+    readonly type: ConfigType.Tile;
+    readonly resizable: boolean;
+}
+export interface GridConfig extends Config<GridData> {
+    readonly type: ConfigType.Grid;
+}
+export interface NullableGridConfig extends Config<GridData | null> {
+    readonly type: ConfigType.NullableGrid;
+    readonly nonNullDefault: GridData;
+}
+export interface IconConfig extends Config<string> {
+    readonly type: ConfigType.Icon;
+}
+export interface ControlLinesConfig extends Config<ControlLine[]> {
+    readonly type: ConfigType.ControlLines;
+}
+export interface NullableNoteConfig extends Config<string | null> {
+    readonly type: ConfigType.NullableNote;
+}
+export type AnyConfig = BooleanConfig | NullableBooleanConfig | NumberConfig | NullableNumberConfig | StringConfig | ColorConfig | ComparisonConfig | DirectionConfig | DirectionToggleConfig | OrientationConfig | OrientationToggleConfig | TileConfig | GridConfig | NullableGridConfig | IconConfig | ControlLinesConfig | NullableNoteConfig;
+/**
+ * Compare two config values for equality, using an appropriate method for the config type.
+ *
+ * @param type The type of the config.
+ * @param a The first value to compare.
+ * @param b The second value to compare.
+ * @returns Whether the two values are equal.
+ */
+export declare function configEquals<C extends AnyConfig>(type: C['type'], a: C['default'], b: C['default']): boolean;

package/dist/data/config.js

@@ -0,0 +1,55 @@
+import { DIRECTIONS, ORIENTATIONS, } from './primitives';
+export var ConfigType;
+(function (ConfigType) {
+    ConfigType["Boolean"] = "boolean";
+    ConfigType["NullableBoolean"] = "nullableBoolean";
+    ConfigType["Number"] = "number";
+    ConfigType["NullableNumber"] = "nullableNumber";
+    ConfigType["String"] = "string";
+    ConfigType["Color"] = "color";
+    ConfigType["Comparison"] = "comparison";
+    ConfigType["Direction"] = "direction";
+    ConfigType["DirectionToggle"] = "directionToggle";
+    ConfigType["Orientation"] = "orientation";
+    ConfigType["OrientationToggle"] = "orientationToggle";
+    ConfigType["Tile"] = "tile";
+    ConfigType["Grid"] = "grid";
+    ConfigType["NullableGrid"] = "nullableGrid";
+    ConfigType["Icon"] = "icon";
+    ConfigType["ControlLines"] = "controlLines";
+    ConfigType["NullableNote"] = "nullableNote";
+})(ConfigType || (ConfigType = {}));
+/**
+ * Compare two config values for equality, using an appropriate method for the config type.
+ *
+ * @param type The type of the config.
+ * @param a The first value to compare.
+ * @param b The second value to compare.
+ * @returns Whether the two values are equal.
+ */
+export function configEquals(type, a, b) {
+    if (type === ConfigType.ControlLines) {
+        const aLines = a;
+        const bLines = b;
+        if (aLines.length !== bLines.length)
+            return false;
+        return aLines.every((line, i) => line.equals(bLines[i]));
+    }
+    if (type === ConfigType.Tile || type === ConfigType.Grid) {
+        return a.equals(b);
+    }
+    if (type === ConfigType.NullableGrid) {
+        if (a === null && b === null)
+            return true;
+        if (a === null || b === null)
+            return false;
+        return a.equals(b);
+    }
+    if (type === ConfigType.DirectionToggle) {
+        return DIRECTIONS.every(dir => a[dir] === b[dir]);
+    }
+    if (type === ConfigType.OrientationToggle) {
+        return ORIENTATIONS.every(dir => a[dir] === b[dir]);
+    }
+    return a === b;
+}

package/dist/data/configurable.d.ts

@@ -0,0 +1,12 @@
+import { AnyConfig } from './config';
+export default abstract class Configurable {
+    get configs(): readonly AnyConfig[] | null;
+    abstract copyWith(props: Record<string, unknown>): this;
+    /**
+     * Check if this instruction is equal to another instruction by comparing their IDs and configs.
+     *
+     * @param other The other instruction to compare to.
+     * @returns Whether the two instructions are equal.
+     */
+    equals(other: Configurable): boolean;
+}

package/dist/data/configurable.js

@@ -0,0 +1,26 @@
+import { configEquals } from './config';
+export default class Configurable {
+    get configs() {
+        return null;
+    }
+    /**
+     * Check if this instruction is equal to another instruction by comparing their IDs and configs.
+     *
+     * @param other The other instruction to compare to.
+     * @returns Whether the two instructions are equal.
+     */
+    equals(other) {
+        const configs = this.configs;
+        if (configs === null)
+            return true;
+        // this is only possible when an instruction is instantiated before the class itself is completely defined
+        // in this case, we can only compare the instances themselves
+        if (configs === undefined)
+            return this === other;
+        for (const config of this.configs) {
+            if (!configEquals(config.type, this[config.field], other[config.field]))
+                return false;
+        }
+        return true;
+    }
+}

package/dist/data/dataHelper.d.ts

@@ -0,0 +1,77 @@
+import { Direction, Orientation, Position } from './primitives';
+/**
+ * Offset the given position by a given step in the given direction.
+ * @param position The position to offset.
+ * @param direction The direction to offset in.
+ * @param step The distance to offset by.
+ * @returns The offset position.
+ */
+export declare function move(position: Position, direction: Direction | Orientation, step?: number): {
+    x: number;
+    y: number;
+};
+/**
+ * Convert the given direction to a rotation in degrees.
+ * @param direction The direction to convert.
+ * @returns The rotation in degrees.
+ */
+export declare function directionToRotation(direction: Direction): 0 | 270 | 90 | 180;
+/**
+ * Convert the given orientation to a rotation in degrees.
+ * @param orientation The orientation to convert.
+ * @returns The rotation in degrees.
+ */
+export declare function orientationToRotation(orientation: Orientation): 0 | 270 | 90 | 180 | 225 | 125 | 315 | 45;
+/**
+ * Create a new 2D array with the given dimensions and values.
+ * @param width The width of the array.
+ * @param height The height of the array.
+ * @param value A function that returns the value for each x,y coordinate.
+ * @returns The 2D array.
+ */
+export declare function array<T>(width: number, height: number, value: (x: number, y: number) => T): T[][];
+/**
+ * Resize the given array to the new size, cutting off or padding with the default value.
+ * @param array The array to resize.
+ * @param newSize The new size of the array.
+ * @param defaultValue A function that returns the default value for each new element.
+ * @returns The resized array.
+ */
+export declare function resize<T>(array: T[], newSize: number, defaultValue: () => T): T[];
+export declare function resize<T>(array: readonly T[], newSize: number, defaultValue: () => T): readonly T[];
+/**
+ * Check if all the given values are equal.
+ * @param values The values to compare.
+ * @returns Whether all the values are equal.
+ */
+export declare function allEqual<T>(...values: T[]): boolean;
+/**
+ * Return the first element of the array which has the minimum mapped value.
+ *
+ * @param values The array of values.
+ * @param mapper The function to map each value to a number.
+ * @returns The first element with the minimum mapped value.
+ */
+export declare function minBy<T>(values: readonly T[], mapper: (element: T) => number): T | undefined;
+/**
+ * Return the first element of the array which has the maximum mapped value.
+ *
+ * @param values The array of values.
+ * @param mapper The function to map each value to a number.
+ * @returns The first element with the maximum mapped value.
+ */
+export declare function maxBy<T>(values: readonly T[], mapper: (element: T) => number): T | undefined;
+/**
+ * Escape the given text by replacing the specified characters with HTML escape sequences.
+ * @param text The text to escape.
+ * @param escapeCharacters The characters to escape.
+ * @returns The escaped text.
+ */
+export declare function escape(text: string, escapeCharacters?: string): string;
+/**
+ * Unescape the given text by replacing HTML escape sequences with the corresponding characters.
+ * @param text The text to unescape.
+ * @param escapeCharacters The characters to unescape. This should match the characters escaped by the `escape` function.
+ * @returns The unescaped text.
+ */
+export declare function unescape(text: string, escapeCharacters?: string): string;

package/dist/data/dataHelper.js

@@ -0,0 +1,190 @@
+import { Direction, Orientation } from './primitives';
+/**
+ * Offset the given position by a given step in the given direction.
+ * @param position The position to offset.
+ * @param direction The direction to offset in.
+ * @param step The distance to offset by.
+ * @returns The offset position.
+ */
+export function move(position, direction, step = 1) {
+    switch (direction) {
+        case Direction.Up:
+        case Orientation.Up:
+            return { x: position.x, y: position.y - step };
+        case Direction.Down:
+        case Orientation.Down:
+            return { x: position.x, y: position.y + step };
+        case Direction.Left:
+        case Orientation.Left:
+            return { x: position.x - step, y: position.y };
+        case Direction.Right:
+        case Orientation.Right:
+            return { x: position.x + step, y: position.y };
+        case Orientation.UpLeft:
+            return { x: position.x - step, y: position.y - step };
+        case Orientation.UpRight:
+            return { x: position.x + step, y: position.y - step };
+        case Orientation.DownLeft:
+            return { x: position.x - step, y: position.y + step };
+        case Orientation.DownRight:
+            return { x: position.x + step, y: position.y + step };
+    }
+}
+/**
+ * Convert the given direction to a rotation in degrees.
+ * @param direction The direction to convert.
+ * @returns The rotation in degrees.
+ */
+export function directionToRotation(direction) {
+    switch (direction) {
+        case Direction.Up:
+            return 0;
+        case Direction.Left:
+            return 270;
+        case Direction.Right:
+            return 90;
+        case Direction.Down:
+            return 180;
+    }
+}
+/**
+ * Convert the given orientation to a rotation in degrees.
+ * @param orientation The orientation to convert.
+ * @returns The rotation in degrees.
+ */
+export function orientationToRotation(orientation) {
+    switch (orientation) {
+        case Orientation.Up:
+            return 0;
+        case Orientation.Left:
+            return 270;
+        case Orientation.Right:
+            return 90;
+        case Orientation.Down:
+            return 180;
+        case Orientation.DownLeft:
+            return 225;
+        case Orientation.DownRight:
+            return 125;
+        case Orientation.UpLeft:
+            return 315;
+        case Orientation.UpRight:
+            return 45;
+    }
+}
+/**
+ * Create a new 2D array with the given dimensions and values.
+ * @param width The width of the array.
+ * @param height The height of the array.
+ * @param value A function that returns the value for each x,y coordinate.
+ * @returns The 2D array.
+ */
+export function array(width, height, value) {
+    const result = [];
+    for (let y = 0; y < height; y++) {
+        result[y] = [];
+        for (let x = 0; x < width; x++) {
+            result[y][x] = value(x, y);
+        }
+    }
+    return result;
+}
+export function resize(array, newSize, defaultValue) {
+    if (array.length < newSize) {
+        return [
+            ...array,
+            ...Array.from({ length: newSize - array.length }, defaultValue),
+        ];
+    }
+    else if (array.length > newSize) {
+        return array.slice(0, newSize);
+    }
+    return array;
+}
+/**
+ * Check if all the given values are equal.
+ * @param values The values to compare.
+ * @returns Whether all the values are equal.
+ */
+export function allEqual(...values) {
+    return values.every(value => value === values[0]);
+}
+/**
+ * Return the first element of the array which has the minimum mapped value.
+ *
+ * @param values The array of values.
+ * @param mapper The function to map each value to a number.
+ * @returns The first element with the minimum mapped value.
+ */
+export function minBy(values, mapper) {
+    let min = Number.POSITIVE_INFINITY;
+    let result;
+    for (const value of values) {
+        const mapped = mapper(value);
+        if (mapped < min) {
+            min = mapped;
+            result = value;
+        }
+    }
+    return result;
+}
+/**
+ * Return the first element of the array which has the maximum mapped value.
+ *
+ * @param values The array of values.
+ * @param mapper The function to map each value to a number.
+ * @returns The first element with the maximum mapped value.
+ */
+export function maxBy(values, mapper) {
+    let max = Number.NEGATIVE_INFINITY;
+    let result;
+    for (const value of values) {
+        const mapped = mapper(value);
+        if (mapped > max) {
+            max = mapped;
+            result = value;
+        }
+    }
+    return result;
+}
+/**
+ * Escape the given text by replacing the specified characters with HTML escape sequences.
+ * @param text The text to escape.
+ * @param escapeCharacters The characters to escape.
+ * @returns The escaped text.
+ */
+export function escape(text, escapeCharacters = '=,:|') {
+    let result = '';
+    for (const char of text) {
+        if (escapeCharacters.includes(char) || char === '&') {
+            result += `&#${char.charCodeAt(0)};`;
+        }
+        else {
+            result += char;
+        }
+    }
+    return result;
+}
+/**
+ * Unescape the given text by replacing HTML escape sequences with the corresponding characters.
+ * @param text The text to unescape.
+ * @param escapeCharacters The characters to unescape. This should match the characters escaped by the `escape` function.
+ * @returns The unescaped text.
+ */
+export function unescape(text, escapeCharacters = '=,:|') {
+    let result = '';
+    const matches = text.matchAll(/&#([0-9]+);/g);
+    let index = 0;
+    for (const match of matches) {
+        result += text.substring(index, match.index);
+        const char = String.fromCharCode(parseInt(match[1], 10));
+        if (escapeCharacters.includes(char) || char === '&') {
+            result += char;
+        }
+        else {
+            result += match[0];
+        }
+        index = match.index + match[0].length;
+    }
+    return result + text.substring(index);
+}

package/dist/data/events/eventHelper.d.ts

@@ -0,0 +1 @@
+export declare function isEventHandler<T>(val: unknown, event: string): val is T;

package/dist/data/events/eventHelper.js

@@ -0,0 +1,6 @@
+export function isEventHandler(val, event) {
+    if (typeof val !== 'object' || val === null || val === undefined)
+        return false;
+    return (event in val &&
+        typeof val[event] === 'function');
+}