@bikky/replication 1.0.1

package/Expressions/EvaluatorChain.d.ts

@@ -0,0 +1,19 @@
+import { ChainPath, TraversalScope } from "./TypeRegistry/Types.js";
+import { ExpressionConfiguration, ExpressionType } from "./EvaluatorSteps.js";
+import { ChainType } from "./TypeRegistry/ChainTypes.js";
+import { Pointer } from "../Transformers/Reference.js";
+export declare class EvaluationChain {
+    rawText?: string;
+    outputTypes: any[];
+    outputChains: ChainType[];
+    steps: ChainPath;
+    data: boolean;
+    config: Required<ExpressionConfiguration>;
+    wrapped: boolean;
+    result?: Pointer<any>;
+    type: ExpressionType;
+    constructor(steps: ChainPath, generatedTypes: ChainType[], data: boolean, config: Required<ExpressionConfiguration>);
+    navigate(scope: TraversalScope): [ChainPath, TraversalScope];
+    get(scope: TraversalScope): any;
+    set(scope: TraversalScope, value: any): void;
+}

package/Expressions/EvaluatorChain.js

@@ -0,0 +1,137 @@
+import { ClassCategory, describeObject } from "../Constants/SerialisationTypes.js";
+import { ValidExpressionTypes } from "./TypeRegistry/Registry.js";
+import { Pointer } from "../Transformers/Reference.js";
+import { ReplType } from "./TypeRegistry/ReplAPI.js";
+function prepareScope(scope) {
+    return Object.assign(Object.assign({}, scope), { global: Object.assign({}, scope.global), local: Object.assign({}, scope.local) });
+}
+export class EvaluationChain {
+    constructor(steps, generatedTypes, data, config) {
+        //Output types are the types that the expression is allowed to return, they can
+        // be more narrow than the types that the expression was instantiated with.
+        this.outputTypes = [];
+        //Output chains are the internal representation of the types above.
+        this.outputChains = [];
+        this.wrapped = false;
+        this.config = config;
+        this.steps = steps;
+        this.data = data;
+        this.outputChains = [...generatedTypes];
+        for (let chain of this.outputChains) {
+            let [types, style] = chain.getOutputTypes();
+            switch (style) {
+                case "Array2":
+                    if (config.outputArray != 2) {
+                        throw new Error(`Error! Expression ${this.rawText} output a double array but property expects something else.`);
+                    }
+                    break;
+                case "Array":
+                    if (config.outputArray != 1) {
+                        throw new Error(`Error! Expression ${this.rawText} output a single array but property expects something else.`);
+                    }
+                    break;
+                case "Map":
+                    if (!config.outputMap) {
+                        throw new Error(`Error! Expression ${this.rawText} output a map but property expects something else.`);
+                    }
+                    break;
+            }
+            //Expression type checking - no checking if any type is allowed.
+            if (config.outputTypes.includes("any")) {
+                this.outputTypes.push(...types);
+            }
+            else {
+                let desiredTypes = config.outputTypes.map((entry) => {
+                    let desiredType = ValidExpressionTypes.GetTypeChain(entry);
+                    if (!desiredType) {
+                        throw new Error(`Error! ${describeObject(entry)} is not a valid expression type, did you remember to register it?`);
+                    }
+                    return desiredType;
+                });
+                //Check that each generated output type maps onto at least one configuration type.
+                for (let discoveredType of types) {
+                    let handled = false;
+                    for (let desiredType of desiredTypes) {
+                        if (desiredType.isAssignableCompile(this.config.version, discoveredType, "Single")) {
+                            handled = true;
+                            this.outputTypes.push(...desiredType.getOutputTypes()[0]);
+                            break;
+                        }
+                    }
+                    if (!handled) {
+                        throw new Error(`Error! ${describeObject(discoveredType)} is not assignable to any provided`
+                            + ` expression configuration output types: ${config.outputTypes.map((e) => describeObject(e)).join(", ")}.`);
+                    }
+                }
+            }
+        }
+    }
+    navigate(scope) {
+        scope = prepareScope(scope);
+        let currentStep = this.steps;
+        let expressionValue = this.steps.eval(scope);
+        scope.self = expressionValue;
+        while (currentStep.next && currentStep.next.length > 0) {
+            let found = false;
+            let verifiedValue = expressionValue instanceof Pointer ? expressionValue.valOrNull : expressionValue;
+            for (let next of currentStep.next) {
+                if (next.node.isAssignableLive(this.config.version, verifiedValue)) {
+                    currentStep = next;
+                    found = true;
+                    break;
+                }
+            }
+            if (!found) {
+                throw new Error(`Error! ${describeObject(verifiedValue)} is not assignable to`
+                    + ` ${currentStep.next.map((e) => e.node.debugName).join(", ")}`);
+            }
+            expressionValue = currentStep.eval(scope);
+            scope.self = expressionValue;
+        }
+        return [currentStep, scope];
+    }
+    get(scope) {
+        let [_, finalScope] = this.navigate(scope);
+        let value = finalScope.self instanceof Pointer ? finalScope.self.val : finalScope.self;
+        let types = this.outputChains.filter((e) => e.isAssignableLive(this.config.version, value));
+        if (types.length == 0) {
+            throw new Error(`Error! ${describeObject(value)} is not assignable to`
+                + ` ${this.outputChains.map((e) => e.debugName).join(", ")}`);
+        }
+        //TODO: This is a hack - it wraps return values in pointers if they're not already pointers.
+        //      This is used for functions atm, because they can return raw values sometimes.
+        let needsPtr = false;
+        for (let type of types) {
+            if (type instanceof ReplType && ClassCategory.isType(ClassCategory.Pointer, type.repl.category)) {
+                needsPtr = true;
+            }
+        }
+        if (needsPtr && !(finalScope.self instanceof Pointer)) {
+            if (!this.wrapped) {
+                this.result = new Pointer(finalScope.self);
+            }
+            else {
+                this.result.val = finalScope.self;
+            }
+            return this.result;
+        }
+        return finalScope.self;
+    }
+    set(scope, value) {
+        if (this.data) {
+            throw new Error(`Cannot set value on data.`);
+        }
+        if (!this.outputChains.some((e) => e.isAssignableLive(this.config.version, value))) {
+            throw new Error(`Cannot set value, ${describeObject(value)} is not assignable to`
+                + ` ${this.outputChains.map((e) => e.debugName).join(", ")}`);
+        }
+        let currentStep;
+        [currentStep, scope] = this.navigate(scope);
+        if (!currentStep.set) {
+            throw new Error(`Error! Cannot set value on ${currentStep.node.debugName}`);
+        }
+        else {
+            return currentStep.set(scope, value);
+        }
+    }
+}

package/Expressions/EvaluatorSteps.d.ts

@@ -0,0 +1,19 @@
+export declare const matchExpression: RegExp;
+export declare function isExpression(str: string): boolean;
+export declare enum ExpressionType {
+    String = 0,
+    Value = 1,
+    Pointer = 2,
+    Collection = 3,
+    Function = 4
+}
+export interface ExpressionConfiguration {
+    version: string;
+    outputTypes: any[];
+    outputArray?: 2 | 1 | 0;
+    outputMap?: boolean;
+    outputDict?: boolean;
+    startType: any;
+    cacheable?: boolean;
+    duringLoad?: boolean;
+}

package/Expressions/EvaluatorSteps.js

@@ -0,0 +1,12 @@
+export const matchExpression = /@\{[^}]*?}/gm;
+export function isExpression(str) {
+    return matchExpression.test(str);
+}
+export var ExpressionType;
+(function (ExpressionType) {
+    ExpressionType[ExpressionType["String"] = 0] = "String";
+    ExpressionType[ExpressionType["Value"] = 1] = "Value";
+    ExpressionType[ExpressionType["Pointer"] = 2] = "Pointer";
+    ExpressionType[ExpressionType["Collection"] = 3] = "Collection";
+    ExpressionType[ExpressionType["Function"] = 4] = "Function";
+})(ExpressionType || (ExpressionType = {}));

package/Expressions/EvaluatorString.d.ts

@@ -0,0 +1,21 @@
+import { EvaluationChain } from "./EvaluatorChain.js";
+import { ExpressionConfiguration, ExpressionType } from "./EvaluatorSteps.js";
+import { TraversalScope } from "./TypeRegistry/Types.js";
+export declare class EvaluationString {
+    readonly rawText: string;
+    protected preparedText: string;
+    outputTypes: any[];
+    finalTypes: any[];
+    config: Required<ExpressionConfiguration>;
+    protected expressions: {
+        expression: EvaluationChain;
+        offset: number;
+    }[];
+    type: ExpressionType;
+    constructor(rawText: string, preparedText: string, expressions: {
+        expression: EvaluationChain;
+        offset: number;
+    }[], config: Required<ExpressionConfiguration>);
+    get(start: TraversalScope): any;
+    set(start: TraversalScope, value: any): void;
+}

package/Expressions/EvaluatorString.js

@@ -0,0 +1,26 @@
+import { ExpressionType } from "./EvaluatorSteps.js";
+export class EvaluationString {
+    constructor(rawText, preparedText, expressions, config) {
+        //Output types are the types that the expression is allowed to return.
+        this.outputTypes = [String];
+        //Final types are the expected types that the expression can return, which may
+        // be less than the output types.
+        this.finalTypes = [String];
+        this.expressions = [];
+        this.type = ExpressionType.String;
+        this.rawText = rawText;
+        this.preparedText = preparedText;
+        this.config = config;
+        this.expressions = expressions;
+    }
+    get(start) {
+        let newText = "" + this.preparedText;
+        for (let i = 0; i < this.expressions.length; i++) {
+            newText = newText.replace("${" + i + "}", this.expressions[i].expression.get(start));
+        }
+        return newText;
+    }
+    set(start, value) {
+        throw new Error(`Cannot set expression string.`);
+    }
+}

package/Expressions/Expression.d.ts

@@ -0,0 +1,36 @@
+import { TraversalStep } from "../Constants/TraversalStep.js";
+import { TraversalScope } from "./TypeRegistry/Types.js";
+import { EvaluationChain } from "./EvaluatorChain.js";
+import { EvaluationString } from "./EvaluatorString.js";
+import { ExpressionConfiguration } from "./EvaluatorSteps.js";
+/**
+ * A wrapper for either ExpressionChain or ExpressionString.
+ */
+export declare class Expression<T = any> extends TraversalStep<T> {
+    text: string;
+    scope: TraversalScope;
+    expression: EvaluationChain | EvaluationString;
+    constructor(expr: {
+        text: string;
+        sourceFile: string;
+    }, config: ExpressionConfiguration);
+    constructor(expr: EvaluationChain | EvaluationString, config?: Pick<ExpressionConfiguration, "outputTypes">);
+    protected setup(): void;
+    static ChangeScope<T>(scope: {
+        [prop: string]: any;
+    }, expression: Expression<T>): void;
+    get(): T;
+    set(value: T): void;
+    call<F extends T extends (...args: any[]) => any ? T : never>(...args: Parameters<F>): ReturnType<F>;
+}
+export declare namespace Expression {
+    type PreloadedExpression = EvaluationChain | EvaluationString;
+    function setCurrentScope(type: any, scope: {
+        [key: string]: any;
+    }): void;
+    function setCurrentStartScopeType(name: string | null): void;
+    function getLatestSetScope(): string | undefined;
+    function isExpressionString(str: any): str is string;
+    function isExpressionKind(value: any): value is Expression | EvaluationString | EvaluationChain;
+    function Parse(expression: string, sourceFile: string, config: ExpressionConfiguration): EvaluationString | EvaluationChain;
+}

package/Expressions/Expression.js

@@ -0,0 +1,147 @@
+import { TraversalStep } from "../Constants/TraversalStep.js";
+import { ReplicableRegistry } from "../Constants/ReplicableRegistry.js";
+import { EvaluationChain } from "./EvaluatorChain.js";
+import { EvaluationString } from "./EvaluatorString.js";
+import { ExpressionType } from "./EvaluatorSteps.js";
+import { CreateExpression } from "./CreateEvaluator.js";
+import { ExpressionScopes } from "./TypeRegistry/Registry.js";
+import { describeObject } from "../Constants/SerialisationTypes.js";
+/**
+ * A wrapper for either ExpressionChain or ExpressionString.
+ */
+export class Expression extends TraversalStep {
+    constructor(expr, config) {
+        super();
+        if (expr instanceof EvaluationChain || expr instanceof EvaluationString) {
+            this.text = expr.rawText;
+            this.expression = expr;
+            if (!config)
+                config = expr.config;
+        }
+        else {
+            this.text = expr.text;
+            this.expression = Expression.Parse(expr.text, expr.sourceFile, config);
+            if (!config) {
+                throw new Error(`Cannot create expression without configuration.`);
+            }
+        }
+        this.setup();
+        if (config.outputTypes.length < 1) {
+            throw new Error(`Expressions must specify at least one output type`);
+        }
+    }
+    setup() {
+        if (this.scope)
+            return;
+        let [globalRule, scopeRule, scopeMap] = ExpressionScopes.GetScopeChain(this.expression.config.startType);
+        if (!scopeRule)
+            throw new Error(`Cannot evaluate expression, requires valid starting scope for type ${describeObject(this.expression.config.startType)} but none is registered.`);
+        let scope = scopeMap;
+        scope.data = this.expression.config.duringLoad;
+        scope.self = null;
+        this.scope = scope;
+    }
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    static ChangeScope(scope, expression) {
+        Object.defineProperties(expression.scope, {
+            local: {
+                value: Object.assign({}, scope),
+                writable: false,
+                configurable: true,
+                enumerable: true
+            }
+        });
+    }
+    get() {
+        const value = this.expression.get(this.scope);
+        if (this.expression.type === ExpressionType.Collection) {
+            if (this.expression.config.outputArray) {
+                if (value instanceof Map) {
+                    return Array.from(value.values());
+                }
+                else if (typeof value === "object") {
+                    if (Array.isArray(value)) {
+                        return value;
+                    }
+                    if (value.__proto__ !== Object.prototype) {
+                        return [value];
+                    }
+                    return Array.from(Object.values(value));
+                }
+                else {
+                    return [value];
+                }
+            }
+            else {
+                if (value instanceof Map) {
+                    return new Map([...value.entries()]);
+                }
+                if (Array.isArray(value) || value.__proto__ === Object.prototype || typeof value !== "object") {
+                    throw new Error(`Expression returns non-map value.`);
+                }
+                return value;
+            }
+        }
+        else {
+            return value;
+        }
+    }
+    set(value) {
+        if (this.expression.type !== ExpressionType.Value) {
+            throw new Error(`Can't set expression that isn't a value.`);
+        }
+        this.expression.set(this.scope, value);
+    }
+    call(...args) {
+        if (this.expression.type !== ExpressionType.Function) {
+            throw new Error(`Can't call expression that isn't a function.`);
+        }
+        return this.expression.get(this.scope)(...args);
+    }
+}
+(function (Expression) {
+    let latestScopeName;
+    function setCurrentScope(type, scope) {
+        if (typeof type === "string") {
+            latestScopeName = type;
+            type = ReplicableRegistry.GetTypesForName(latestScopeName)[0];
+        }
+        else {
+            latestScopeName = ReplicableRegistry.GetDataName(type);
+        }
+        ExpressionScopes.setLocalScope(type, scope);
+        ExpressionScopes.setLocalScope(latestScopeName, scope);
+    }
+    Expression.setCurrentScope = setCurrentScope;
+    function setCurrentStartScopeType(name) {
+        if (name === null) {
+            latestScopeName = undefined;
+        }
+        else {
+            latestScopeName = name;
+        }
+    }
+    Expression.setCurrentStartScopeType = setCurrentStartScopeType;
+    function getLatestSetScope() {
+        return latestScopeName;
+    }
+    Expression.getLatestSetScope = getLatestSetScope;
+    //Can't use /g because it makes the regexp stateful causing test to fail every second time.
+    const matchExpression = /@\{[^}]*?}/;
+    function isExpressionString(str) {
+        return typeof str === "string" && matchExpression.test(str);
+    }
+    Expression.isExpressionString = isExpressionString;
+    function isExpressionKind(value) {
+        return (value instanceof Expression ||
+            value instanceof EvaluationString ||
+            value instanceof EvaluationChain);
+    }
+    Expression.isExpressionKind = isExpressionKind;
+    function Parse(expression, sourceFile, config) {
+        var _a, _b, _c, _d, _e;
+        let initialisedConfig = Object.assign(Object.assign({}, config), { cacheable: (_a = config.cacheable) !== null && _a !== void 0 ? _a : false, duringLoad: (_b = config.duringLoad) !== null && _b !== void 0 ? _b : false, outputArray: (_c = config.outputArray) !== null && _c !== void 0 ? _c : 0, outputMap: (_d = config.outputMap) !== null && _d !== void 0 ? _d : false, outputDict: (_e = config.outputDict) !== null && _e !== void 0 ? _e : false });
+        return CreateExpression(expression, sourceFile, initialisedConfig);
+    }
+    Expression.Parse = Parse;
+})(Expression || (Expression = {}));

package/Expressions/Traverser.d.ts

@@ -0,0 +1,28 @@
+import { ExpressionAST } from "./Compiler/BuiltinGrammar.js";
+import { EAST_Token } from "./Compiler/ExpressionGrammar.js";
+import { ExpressionConfiguration } from "./EvaluatorSteps.js";
+import { EvaluationChain } from "./EvaluatorChain.js";
+import "./TypeRegistry/Primitive.js";
+import FileNode = ExpressionAST.FileNode;
+interface PreparedToken {
+    type: "Token";
+    node: EAST_Token;
+}
+interface PreparedOp {
+    type: "Op";
+    node: EAST_Token;
+    params: [PreparedAST];
+}
+interface PreparedCast {
+    type: "Cast" | "ForceCast";
+    node: EAST_Token;
+}
+interface PreparedCall {
+    type: "Call";
+    node: EAST_Token;
+    params: PreparedAST[];
+}
+type PreparedAST = (PreparedToken | PreparedOp | PreparedCast | PreparedCall)[];
+export declare function OrderASTSequentially(ast: FileNode): PreparedAST[];
+export declare function OrderedNodeSequencesToTrees(orderedNodes: PreparedAST[], config: Required<ExpressionConfiguration>): EvaluationChain[];
+export {};