@casual-simulation/aux-runtime 3.2.7-alpha.6226622763

package/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Casual Simulation, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,82 @@
+# AUX Common
+
+[![npm (scoped)](https://img.shields.io/npm/v/@casual-simulation/aux-common.svg)](https://www.npmjs.com/package/@casual-simulation/aux-common)
+
+A library that contains common operations needed to modify and understand AUX files.
+
+## Installation
+
+```bash
+$ npm install @casual-simulation/aux-common
+```
+
+## Usage
+
+#### Calculate a formula for some bots
+
+```typescript
+import {
+    createBot,
+    createCalculationContext,
+    calculateFormulaValue,
+} from '@casual-simulation/aux-common';
+
+const file1 = createBot('test1', {
+    quantity: 10,
+});
+const file2 = createBot('test2', {
+    quantity: 5,
+});
+const file3 = createBot('test3', {
+    quantity: 5,
+});
+
+const context = createCalculationContext([file1, file2, file3]);
+
+const formula = '=math.sum(getBotTagValues("#quantity"))';
+const result = calculateFormulaValue(context, formula);
+
+console.log(result);
+
+// Outputs:
+// 20
+```
+
+#### Calculate events for an action script
+
+```typescript
+import {
+    createBot,
+    createCalculationContext,
+    calculateFormulaEvents,
+} from '@casual-simulation/aux-common';
+
+const state = {
+    test1: createBot('test1', {
+        quantity: 10,
+    }),
+    test2: createBot('test2', {
+        quantity: 5,
+    }),
+    test3: createBot('test3', {
+        quantity: 5,
+    }),
+};
+
+const formula = `
+    let total = math.sum(getBotTagValues("#quantity"));
+    player.toast("The total is " + total);
+`;
+const events = calculateFormulaEvents(state, formula);
+
+for (let event of events) {
+    if (event.type === 'local') {
+        if (event.name === 'show_toast') {
+            console.log('[Toast]', event.message);
+        }
+    }
+}
+
+// Outputs:
+// [Toast] The total is 5
+```

package/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * MIT License
+ *
+ * Copyright (c) 2019 Casual Simulation, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * @license MIT
+ */
+export * from './runtime';
+//# sourceMappingURL=index.d.ts.map

package/index.js

@@ -0,0 +1,26 @@
+/**
+ * MIT License
+ *
+ * Copyright (c) 2019 Casual Simulation, Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * @license MIT
+ */
+export * from './runtime';
+//# sourceMappingURL=index.js.map

package/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,cAAc,WAAW,CAAC"}

package/package.json

@@ -0,0 +1,79 @@
+{
+    "name": "@casual-simulation/aux-runtime",
+    "version": "3.2.7-alpha.6226622763",
+    "description": "Runtime for AUX projects",
+    "main": "index.js",
+    "types": "index.d.ts",
+    "module": "index",
+    "scripts": {
+        "watch": "tsc --build --watch",
+        "watch:player": "npm run watch",
+        "build": "echo \"Nothing to do.\"",
+        "test": "jest",
+        "test:watch": "jest --watchAll"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/casual-simulation/casualos.git"
+    },
+    "keywords": [
+        "aux",
+        "so4",
+        "realtime",
+        "crdt"
+    ],
+    "author": "Casual Simulation, Inc.",
+    "license": "MIT",
+    "bugs": {
+        "url": "https://github.com/casual-simulation/casualos/issues"
+    },
+    "homepage": "https://github.com/casual-simulation/casualos#readme",
+    "publishConfig": {
+        "access": "public"
+    },
+    "dependencies": {
+        "@casual-simulation/aux-common": "^3.2.7-alpha.6226622763",
+        "@casual-simulation/aux-records": "^3.2.7-alpha.6226622763",
+        "@casual-simulation/crypto": "^3.2.0",
+        "@casual-simulation/engine262": "0.0.1-4de2170374e22761996e46eb1362f4496ee57f8f",
+        "@casual-simulation/error-stack-parser": "^2.0.7",
+        "@casual-simulation/expect": "^3.1.28",
+        "@casual-simulation/fast-json-stable-stringify": "^3.1.11",
+        "@casual-simulation/js-interpreter": "^3.1.28",
+        "@casual-simulation/stacktrace": "^3.1.11",
+        "@casual-simulation/three": "^0.140.3",
+        "@tweenjs/tween.js": "18.6.0",
+        "@types/acorn": "^4.0.6",
+        "@types/estraverse": "^5.1.1",
+        "@types/uuid": "^8.3.1",
+        "acorn": "^8.0.1",
+        "acorn-jsx": "^5.3.2",
+        "astring": "1.7.5",
+        "estraverse": "^5.2.0",
+        "expect": "27.3.1",
+        "hash.js": "1.1.7",
+        "htm": "3.1.0",
+        "lib0": "0.2.49",
+        "lru-cache": "^5.1.1",
+        "luxon": "2.3.0",
+        "preact": "10.10.1",
+        "rxjs": "7.5.7",
+        "seedrandom": "3.0.5",
+        "stackframe": "^1.2.0",
+        "uuid": "^8.3.2",
+        "yjs": "13.5.41"
+    },
+    "devDependencies": {
+        "benchmark": "2.1.4",
+        "platform": "1.3.5"
+    },
+    "files": [
+        "/README.md",
+        "/LICENSE.txt",
+        "**/*.js",
+        "**/*.js.map",
+        "**/*.d.ts",
+        "**/*.def"
+    ],
+    "gitHead": "90c8d333924255b93b9654dc100fc74181b6138b"
+}

package/runtime/AuxCompiler.d.ts

@@ -0,0 +1,258 @@
+/// <reference types="node" />
+import { CodeLocation, TranspilerResult } from './Transpiler';
+import type { Breakpoint, ConstructedFunction, Interpreter, InterpreterContinuation, InterpreterStop, PossibleBreakpointLocation } from '@casual-simulation/js-interpreter';
+/**
+ * A symbol that identifies a function as having been compiled using the AuxCompiler.
+ */
+export declare const COMPILED_SCRIPT_SYMBOL: unique symbol;
+/**
+ * The symbol that is used to tag specific functions as interpretable.
+ */
+export declare const INTERPRETABLE_FUNCTION: unique symbol;
+/**
+ * The symbol that is used to tag function modules with the metadata for a function.
+ */
+export declare const FUNCTION_METADATA: unique symbol;
+/**
+ * Creates a new interpretable function based on the given function.
+ * @param interpretableFunc
+ */
+export declare function createInterpretableFunction<TArg extends Array<any>, R>(interpretableFunc: (...args: TArg) => Generator<any, R, any>): {
+    (...args: TArg): R;
+    [INTERPRETABLE_FUNCTION]: (...args: TArg) => Generator<any, R, any>;
+};
+/**
+ * Sets the INTERPRETABLE_FUNCTION property on the given object (semantically a function) to the given interpretable version and returns the object.
+ * @param interpretableFunc The version of the function that should be used as the interpretable version of the function.
+ * @param normalFunc The function that should be tagged.
+ */
+export declare function tagAsInterpretableFunction<T, N>(interpretableFunc: T, normalFunc: N): N & {
+    [INTERPRETABLE_FUNCTION]: T;
+};
+/**
+ * Determines if the given object has been tagged with the GENERATOR_FUNCTION_TAG.
+ * @param obj The object.
+ */
+export declare function isInterpretableFunction(obj: unknown): boolean;
+/**
+ * Gets the interpretable version of the given function.
+ */
+export declare function getInterpretableFunction<T extends Function>(obj: unknown): T;
+/**
+ * Defines a class that can compile scripts and formulas
+ * into functions.
+ */
+export declare class AuxCompiler {
+    private _transpiler;
+    private _functionCache;
+    /**
+     * The offset that should be applied to error line numbers when calculating their original
+     * position. Needed because Node.js Windows produces different line numbers than Mac/Linux.
+     *
+     * Node.js versions greater than v12.14.0 have an issue with identifying the correct line number
+     * for errors and stack traces. This issue is fixed in Node.js v14 and later (possibly also fixed in v13 but I didn't check that).
+     */
+    functionErrorLineOffset: number;
+    /**
+     * Calculates the "original" stack trace that the given error occurred at
+     * within the given function.
+     * Returns null if the original stack trace was unable to be determined.
+     * @param functionNameMap A map of function names to their scripts.
+     * @param error The error that occurred.
+     */
+    calculateOriginalStackTrace(functionNameMap: Map<string, AuxCompiledScript>, error: Error): string;
+    private _calculateInterpreterErrorOriginalStackTrace;
+    private _calculateNativeErrorOriginalStackTrace;
+    /**
+     * Calculates the original location within the given function for the given location.
+     * The returned location uses zero-based line and column numbers.
+     * @param func The function.
+     * @param location The location. Line and column numbers are one-based.
+     */
+    calculateOriginalLineLocation(func: AuxCompiledScript, location: CodeLocation): CodeLocation;
+    /**
+     * Calculates the final location within the given function for the given location.
+     * @param func The function.
+     * @param location The location. Line and column numbers are zero based.
+     */
+    calculateFinalLineLocation(func: AuxCompiledScript, location: CodeLocation): CodeLocation;
+    /**
+     * Compiles the given script into a function.
+     * @param script The script to compile.
+     * @param options The options that should be used to compile the script.
+     */
+    compile<T>(script: string, options?: AuxCompileOptions<T>): AuxCompiledScript;
+    /**
+     * Finds the line number information for a function created with this compiler using the
+     * given stack trace and metadata.
+     * @param stackTrace The stack trace.
+     * @param metadata The metadata.
+     */
+    findLineInfo(stackTrace: NodeJS.CallSite[], metadata: AuxScriptMetadata): LineInfo;
+    /**
+     * Sets the given breakpoint.
+     * @param breakpoint The breakpoint that should be set.
+     */
+    setBreakpoint(breakpoint: AuxCompilerBreakpoint): void;
+    listPossibleBreakpoints(func: AuxCompiledScript, interpreter: Interpreter): PossibleBreakpointLocation[];
+    private _parseScript;
+    private _compileFunction;
+    private _buildFunction;
+    private __constructFunction;
+}
+/**
+ * Parses the line and column numbers from the the given syntax error, transforms them with the given function,
+ * and returns a new syntax error that contains the new location. Returns null if the line and column numbers could not be parsed.
+ * @param error The error to transform.
+ * @param transform The function that should be used to transform the errors.
+ * @returns
+ */
+export declare function replaceSyntaxErrorLineNumber(error: SyntaxError, transform: (location: CodeLocation) => CodeLocation): SyntaxError;
+/**
+ * A script that has been compiled.
+ */
+export interface AuxCompiledScript {
+    (...args: any[]): any;
+    [INTERPRETABLE_FUNCTION]: ((...args: any[]) => Generator<InterpreterStop, any, InterpreterContinuation>) | null;
+    /**
+     * The metadata for the script.
+     */
+    metadata: AuxScriptMetadata;
+}
+/**
+ * Line information that has been calculated from a stack trace.
+ */
+export interface LineInfo {
+    /**
+     * The line number.
+     */
+    line: number | null;
+    /**
+     * The column number.
+     */
+    column: number | null;
+}
+/**
+ * Metadata about the script.
+ */
+export interface AuxScriptMetadata {
+    /**
+     * The function that directly wraps the script.
+     */
+    scriptFunction: Function;
+    /**
+     * The number of lines that the user's script is offset inside the returned function source.
+     */
+    scriptLineOffset: number;
+    /**
+     * The number of lines that the user's script is offset from the tranpiler's output.
+     */
+    transpilerLineOffset: number;
+    /**
+     * The transpiler result;
+     */
+    transpilerResult: TranspilerResult;
+    /**
+     * The name that should be used for the function in stack traces.
+     */
+    diagnosticFunctionName: string;
+    /**
+     * The file name that was specified for the script.
+     */
+    fileName: string;
+    /**
+     * Whether the function is asynchronous and returns a promise.
+     */
+    isAsync: boolean;
+    /**
+     * The function that was constructed by the interpreter.
+     */
+    constructedFunction: ConstructedFunction;
+    /**
+     * The context that the function was created with.
+     */
+    context: any;
+}
+/**
+ * The set of options that a script should be compiled with.
+ */
+export interface AuxCompileOptions<T> {
+    /**
+     * The context that should be used.
+     */
+    context?: T;
+    /**
+     * The realm that should be used for the script.
+     * If provided, then the script will be parsed and executed in the context of this realm and
+     * the corresponding engine262 agent.
+     */
+    interpreter?: Interpreter;
+    /**
+     * The variables that should be made available to the script.
+     */
+    variables?: {
+        [name: string]: (context?: T) => any;
+    };
+    /**
+     * The constant values that should be made available to the script.
+     */
+    constants?: {
+        [name: string]: any;
+    };
+    /**
+     * The names that each argument should be assigned.
+     */
+    arguments?: (string | string[])[];
+    /**
+     * A function that should be called before the compiled function is executed.
+     */
+    before?: (context?: T) => void;
+    /**
+     * A function that should be called after the compiled function is executed.
+     */
+    after?: (context?: T) => void;
+    /**
+     * A function that should be called to invoke the compiled function.
+     */
+    invoke?: (func: Function, context?: T) => any;
+    /**
+     * A function that should be called when an error occurs.
+     */
+    onError?: (error: any, context?: T, meta?: AuxScriptMetadata) => void;
+    /**
+     * The name that should be given to the function.
+     */
+    functionName?: string;
+    /**
+     * The name that should be used for the function in stack traces.
+     */
+    diagnosticFunctionName?: string;
+    /**
+     * The file name that should be used for transformed error stack traces.
+     */
+    fileName?: string;
+    /**
+     * Whether to force the output function to be synchronous.
+     * This will compile out any async/await code.
+     */
+    forceSync?: boolean;
+    /**
+     * The global object that the function should be compiled to reference.
+     *
+     */
+    globalObj?: any;
+}
+/**
+ * The set of options that a breakpoint should use.
+ */
+export interface AuxCompilerBreakpoint extends Omit<Breakpoint, 'func'> {
+    /**
+     * The script that the breakpoint should be set for.
+     */
+    func: AuxCompiledScript;
+    /**
+     * The interpreter that the breakpoint should be set on.
+     */
+    interpreter: Interpreter;
+}
+//# sourceMappingURL=AuxCompiler.d.ts.map