@bikky/replication 1.0.1

package/Expressions/TypeRegistry/ReplAPI.js

@@ -0,0 +1,220 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _ReplAPI_private;
+import { ChainType } from "./ChainTypes.js";
+import { ReplicableClass } from "../../Tracking/Class.js";
+import { GetVersionController } from "../../Constants/Versions.js";
+import { ChainFunction, ChainOverride, ChainProperty } from "./Accessors.js";
+import { isPrimitiveType } from "../../Constants/SerialisationTypes.js";
+import { VersionMap } from "@bikky/smart-collections";
+import { ValidExpressionTypes } from "./Registry.js";
+import { ArrayType, DictType, MapType } from "./ChainCollections.js";
+var GetTypeChain = ValidExpressionTypes.GetTypeChain;
+import { PrimitiveType } from "./Primitive.js";
+import { Pointer } from "../../Transformers/Reference.js";
+import { CustomType } from "./CustomAPI.js";
+let IsLoadableDataForType;
+let getReplicableClassByName = null;
+let getReplicableClassOrPrimByAlias = null;
+export var __ReplTypeHelperFunctions;
+(function (__ReplTypeHelperFunctions) {
+    function SetIsLoadableDataForType(func) {
+        IsLoadableDataForType = func;
+    }
+    __ReplTypeHelperFunctions.SetIsLoadableDataForType = SetIsLoadableDataForType;
+    function SetDataNameTypeLookupFunction(lookupFunc) {
+        getReplicableClassByName = lookupFunc;
+    }
+    __ReplTypeHelperFunctions.SetDataNameTypeLookupFunction = SetDataNameTypeLookupFunction;
+    function SetPrimOrClassLookupFunction(lookupFunc) {
+        getReplicableClassOrPrimByAlias = lookupFunc;
+    }
+    __ReplTypeHelperFunctions.SetPrimOrClassLookupFunction = SetPrimOrClassLookupFunction;
+})(__ReplTypeHelperFunctions || (__ReplTypeHelperFunctions = {}));
+let replMap = new Map();
+export class ReplType extends ChainType {
+    constructor(repl) {
+        super(repl.opts.dataTypeName);
+        this.properties = new VersionMap(GetVersionController());
+        this.dataProperties = new VersionMap(GetVersionController());
+        this.repl = repl;
+        ValidExpressionTypes.SetTypeChain(repl, this);
+        ValidExpressionTypes.AddAliasForType(repl.opts.typescriptTypeName, repl);
+        ValidExpressionTypes.AddAliasForType(repl.opts.dataTypeName, repl);
+        ValidExpressionTypes.AddAliasForType(repl.classConstructor, repl);
+    }
+    getOwnOutputStyle() {
+        return "Single";
+    }
+    getOwnOutputTypes() {
+        return [this.repl.classConstructor];
+    }
+    isAssignableCompile(version, type) {
+        return this.repl.isChildTypeOfThisType(type);
+    }
+    isAssignableLive(version, value) {
+        return this.repl.isObjectOfThisType(value);
+    }
+    isAssignableData(version, value, stack) {
+        return IsLoadableDataForType(this.repl, value, version, stack);
+    }
+    isCastableCompile(version, type) {
+        if (isPrimitiveType(type))
+            return false;
+        if (type instanceof PrimitiveType)
+            return false;
+        if (!getReplicableClassByName || !getReplicableClassOrPrimByAlias) {
+            throw new Error(`Error, ReplType is missing a lookup function for data types.`);
+        }
+        let repl;
+        if (type instanceof ReplType) {
+            repl = type.repl;
+        }
+        else if (type instanceof ReplicableClass) {
+            repl = type;
+        }
+        else if (typeof type === "string") {
+            repl = getReplicableClassByName(type);
+        }
+        else {
+            //Handle aliases.
+            let result = getReplicableClassOrPrimByAlias(type instanceof CustomType ? type.name : type);
+            if (!result) {
+                throw new Error(`Error, ${type} is not a valid type.`);
+            }
+            for (let val of result) {
+                if (val instanceof ReplicableClass && (val.isChildTypeOfThisType(this.repl) || this.repl.isChildTypeOfThisType(val))) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        if (!repl)
+            return false;
+        return repl.isChildTypeOfThisType(this.repl) || this.repl.isChildTypeOfThisType(repl);
+    }
+    isCastableLive(version, value) {
+        if (value instanceof Pointer) {
+            value = value.valOrNull;
+        }
+        return this.repl.isObjectOfThisType(value);
+    }
+    isCastableData(version, value, stack) {
+        return IsLoadableDataForType(this.repl, value, version, stack);
+    }
+    getLive(version, prop, node, contexts) {
+        let value = this.properties.get(version, prop);
+        if (value)
+            return value;
+        return this.checkContextScopes(version, prop, node, contexts);
+    }
+    getData(version, prop, node, contexts) {
+        let value = this.dataProperties.get(version, prop);
+        if (value)
+            return value;
+        return this.checkContextsData(version, prop, node, contexts);
+    }
+}
+export class ReplAPI {
+    constructor(type, opts) {
+        _ReplAPI_private.set(this, void 0);
+        this.replicable = opts;
+        __classPrivateFieldSet(this, _ReplAPI_private, new ReplType(opts), "f");
+        replMap.set(this, __classPrivateFieldGet(this, _ReplAPI_private, "f"));
+    }
+    async addProperty(version, def) {
+        var _a;
+        if ("doesntExist" in def) {
+            //pass
+        }
+        else if ("removed" in def) {
+            if (def.expressionMigration) {
+                __classPrivateFieldGet(this, _ReplAPI_private, "f").properties.set(version, def.dataName, new ChainOverride(def.property, "self", def.type, def.expressionMigration));
+            }
+            if (def.dataMigration) {
+                __classPrivateFieldGet(this, _ReplAPI_private, "f").dataProperties.set(version, def.dataName, new ChainOverride(def.property, "self", (_a = def.customDataType) !== null && _a !== void 0 ? _a : def.type, def.dataMigration));
+            }
+        }
+        else {
+            if (!def.expressionForProperty) {
+                return;
+            }
+            //Force this to wait so that any string types' classes have been registered.
+            this.addPropertyHelper(__classPrivateFieldGet(this, _ReplAPI_private, "f").properties, def, def.expressionForProperty[version], version);
+            this.addPropertyHelper(__classPrivateFieldGet(this, _ReplAPI_private, "f").dataProperties, def, def.expressionForProperty[version], version);
+        }
+    }
+    addPropertyHelper(target, def, liveInfo, version) {
+        let outputTypes = liveInfo.outputTypes.map(e => {
+            let result = e instanceof ChainType ? e : GetTypeChain(e);
+            if (!result) {
+                throw new Error(`Error, ${def.load.name} has an unknown type ${e}.`);
+            }
+            return result;
+        });
+        if (liveInfo.outputArray == 2) {
+            let array = ValidExpressionTypes.GetArrayType([ValidExpressionTypes.GetArrayType(outputTypes)]);
+            target.set(version, def.load.name, new ChainProperty(def.name, "self", [array]));
+        }
+        else if (liveInfo.outputArray == 1) {
+            let array = ValidExpressionTypes.GetTypeChain(ArrayType.generateName(outputTypes));
+            if (!array) {
+                array = ValidExpressionTypes.GetArrayType(outputTypes);
+            }
+            target.set(version, def.load.name, new ChainProperty(def.name, "self", [array]));
+        }
+        else if (liveInfo.outputDict) {
+            let dictionary = ValidExpressionTypes.GetTypeChain(DictType.generateName(outputTypes));
+            if (!dictionary) {
+                dictionary = ValidExpressionTypes.GetDictType(outputTypes);
+            }
+            target.set(version, def.load.name, new ChainProperty(def.name, "self", [dictionary]));
+        }
+        else if (liveInfo.outputMap) {
+            let map = ValidExpressionTypes.GetTypeChain(MapType.generateName(outputTypes));
+            if (!map) {
+                map = ValidExpressionTypes.GetMapType(outputTypes);
+            }
+            target.set(version, def.load.name, new ChainProperty(def.name, "self", [map]));
+        }
+        else {
+            target.set(version, def.load.name, new ChainProperty(def.name, "self", outputTypes));
+        }
+    }
+    addFunction(version, opts, types, parameters) {
+        for (let type of [...types, ...parameters].flat()) {
+            if ("array" in type) {
+                throw new Error(`Error, ${opts.name} has an array type in a function signature.`);
+            }
+            if ("mapKey" in type) {
+                throw new Error(`Error, ${opts.name} has a map type in a function signature.`);
+            }
+            if ("dictKey" in type) {
+                throw new Error(`Error, ${opts.name} has a dict type in a function signature.`);
+            }
+        }
+        let accessor = new ChainFunction(opts.name, "self", types.flatMap((e) => e.type), 
+        //Convert [[{type: Type[]}], [{type: Type[]}]] -> [Type[], Type[]]
+        parameters.map((e) => {
+            return e.flatMap((f) => {
+                if (Array.isArray(f.type)) {
+                    return f.type.map((g) => GetTypeChain(g));
+                }
+                else {
+                    return [GetTypeChain(f.type)];
+                }
+            });
+        }));
+        __classPrivateFieldGet(this, _ReplAPI_private, "f").properties.set(version, opts.exprName, accessor);
+    }
+}
+_ReplAPI_private = new WeakMap();

package/Expressions/TypeRegistry/Scope.d.ts

@@ -0,0 +1,24 @@
+import { ChainType } from "./ChainTypes.js";
+import { ChainAccessor } from "./Accessors.js";
+import { ErrorStack } from "../../Constants/Errors.js";
+import { Versions } from "../../Constants/Versions.js";
+import { ExpressionGrammar } from "../Compiler/ExpressionGrammar.js";
+export declare class ScopeType extends ChainType {
+    liveScope: {
+        [variable: string]: ChainAccessor;
+    };
+    dataScope: {
+        [variable: string]: ChainAccessor;
+    };
+    constructor(debugName: string, liveScope: ScopeType["liveScope"], dataScope: ScopeType["dataScope"]);
+    getOwnOutputStyle(): ReturnType<ChainType["getOwnOutputStyle"]>;
+    getOwnOutputTypes(): string[];
+    isAssignableCompile(type: any): boolean;
+    isAssignableData(value: any, stack: ErrorStack): boolean;
+    isAssignableLive(value: any): boolean;
+    isCastableCompile(type: any): boolean;
+    isCastableData(value: any, stack: ErrorStack): boolean;
+    isCastableLive(value: any): boolean;
+    getData(version: Versions, prop: string, node: ExpressionGrammar.Node, parents?: ChainType[]): ChainAccessor;
+    getLive(version: Versions, prop: string, node: ExpressionGrammar.Node, parents?: ChainType[]): ChainAccessor;
+}

package/Expressions/TypeRegistry/Scope.js

@@ -0,0 +1,44 @@
+import { ChainType } from "./ChainTypes.js";
+export class ScopeType extends ChainType {
+    constructor(debugName, liveScope, dataScope) {
+        super(debugName);
+        this.liveScope = liveScope;
+        this.dataScope = dataScope;
+    }
+    getOwnOutputStyle() {
+        return "Map";
+    }
+    getOwnOutputTypes() {
+        return [this.debugName];
+    }
+    isAssignableCompile(type) {
+        return false;
+    }
+    isAssignableData(value, stack) {
+        return false;
+    }
+    isAssignableLive(value) {
+        return false;
+    }
+    isCastableCompile(type) {
+        return false;
+    }
+    isCastableData(value, stack) {
+        return false;
+    }
+    isCastableLive(value) {
+        return false;
+    }
+    getData(version, prop, node, parents) {
+        if (prop in this.dataScope) {
+            return this.dataScope[prop];
+        }
+        return this.checkContextsData(version, prop, node, parents);
+    }
+    getLive(version, prop, node, parents) {
+        if (prop in this.liveScope) {
+            return this.liveScope[prop];
+        }
+        return this.checkContextScopes(version, prop, node, parents);
+    }
+}

package/Expressions/TypeRegistry/Types.d.ts

@@ -0,0 +1,23 @@
+import { ChainType } from "./ChainTypes.js";
+import { Versions } from "../../Constants/Versions.js";
+import { ChainAccessor } from "./Accessors.js";
+export interface TraversalScope<localScopeType = any> {
+    data: boolean;
+    version: Versions.v1_0_0;
+    global: {
+        [category: string]: {
+            [key: string]: any;
+        } | string;
+    };
+    local: {
+        [keyword: string]: any;
+    };
+    self: localScopeType;
+}
+export interface ChainPath {
+    node: ChainType;
+    expression: ChainAccessor;
+    eval: (scope: TraversalScope) => any;
+    set?: (scope: TraversalScope, val: any) => void;
+    next?: ChainPath[];
+}

package/Expressions/TypeRegistry/Types.js

@@ -0,0 +1 @@
+export {};

package/Expressions/TypeRegistry/__tests__/Replicable.Expressions.Accessors.test.d.ts

@@ -0,0 +1 @@
+export {};

package/Expressions/TypeRegistry/__tests__/Replicable.Expressions.Accessors.test.js

@@ -0,0 +1,31 @@
+import { describe, expect, test } from "vitest";
+import { ChainFunction } from "../Accessors.js";
+import { Versions } from "../../../Constants/Versions.js";
+import { ValidExpressionTypes } from "../Registry.js";
+var GetTypeChain = ValidExpressionTypes.GetTypeChain;
+//TODO: Test scopes.
+//TODO: Test that expression's outputs are validated against the desired outputs.
+//TODO: Test that trying to set the local scope for an entity checks for a valid parent scope.
+//TODO: Test that getting the scope for an entity gets a valid parent scope.
+//TODO: Test that versioning for repl properties and functions is honoured correctly ("from now on").
+//TODO: Write a series of tests for customAPI, including for registering rules before their types have loaded.
+//TODO: Test casting an alias down to one of it's types.
+describe("Accessors", async () => {
+    const scope = {
+        version: Versions.v1_0_0,
+        data: false,
+        local: {},
+        global: {},
+        self: {
+            testString: "world",
+            testFunction: (a) => "hello " + a
+        }
+    };
+    test("ChainFunction", async () => {
+        const StringChainType = GetTypeChain(String);
+        const NullChainType = GetTypeChain(null);
+        let chain = new ChainFunction("testFunction", "self", [StringChainType], [[StringChainType, NullChainType]]);
+        let result = chain.evaluate(scope, ["world"]);
+        expect(result).toBe("hello world");
+    });
+});

package/Expressions/__tests__/ExpressionExamples.d.ts

@@ -0,0 +1,28 @@
+import { ChainType } from "../TypeRegistry/ChainTypes.js";
+import { ChainAccessor } from "../TypeRegistry/Accessors.js";
+import { ErrorStack } from "../../Constants/Errors.js";
+import { Versions } from "../../Constants/Versions.js";
+import { ExpressionGrammar } from "../Compiler/ExpressionGrammar.js";
+export declare class ExpressionTestType extends ChainType {
+    access: {
+        [key: string]: ChainAccessor;
+    };
+    value: any;
+    constructor(name: string, compareValue: any, properties: {
+        [key: string]: {
+            type: any[];
+            value: any;
+        };
+    });
+    getOwnOutputTypes(): any[];
+    getOwnOutputStyle(): ReturnType<ChainType["getOwnOutputStyle"]>;
+    addProperty(prop: string, chain: ChainAccessor): void;
+    isAssignableCompile(version: Versions, type: any): boolean;
+    isAssignableData(version: Versions, value: any, stack: ErrorStack): boolean;
+    isAssignableLive(version: Versions, value: any): boolean;
+    isCastableCompile(version: Versions, type: any): boolean;
+    isCastableData(version: Versions, value: any, stack: ErrorStack): boolean;
+    isCastableLive(version: Versions, value: any): boolean;
+    getData(version: Versions, prop: string, node: ExpressionGrammar.Node, parents?: ChainType[]): ChainAccessor;
+    getLive(version: Versions, prop: string, node: ExpressionGrammar.Node, parents?: ChainType[]): ChainAccessor;
+}

package/Expressions/__tests__/ExpressionExamples.js

@@ -0,0 +1,50 @@
+import { ChainType } from "../TypeRegistry/ChainTypes.js";
+import { ChainOverride } from "../TypeRegistry/Accessors.js";
+import { ExpressionSyntaxError } from "../../Constants/Errors.js";
+import { ValidExpressionTypes } from "../TypeRegistry/Registry.js";
+export class ExpressionTestType extends ChainType {
+    constructor(name, compareValue, properties) {
+        super(name);
+        this.access = {};
+        this.value = compareValue;
+        for (let prop in properties) {
+            let value = properties[prop].value;
+            this.access[prop] = new ChainOverride(prop, "self", properties[prop].type, () => value);
+        }
+    }
+    getOwnOutputTypes() {
+        return ValidExpressionTypes.ToRawTypes([this.debugName]);
+    }
+    getOwnOutputStyle() {
+        return "Single";
+    }
+    addProperty(prop, chain) {
+        this.access[prop] = chain;
+    }
+    isAssignableCompile(version, type) { debugger; return type === "Custom2"; }
+    isAssignableData(version, value, stack) { return value === this.value; }
+    isAssignableLive(version, value) { return value === this.value; }
+    isCastableCompile(version, type) { return false; }
+    isCastableData(version, value, stack) { return false; }
+    isCastableLive(version, value) { return false; }
+    getData(version, prop, node, parents) {
+        if (prop in this.access) {
+            return this.access[prop];
+        }
+        if (parents && parents.length > 0) {
+            let [parent, ...rest] = parents;
+            return parent.getLive(version, prop, node, rest);
+        }
+        throw new ExpressionSyntaxError(`CustomType doesn't have property ${prop}`, node);
+    }
+    getLive(version, prop, node, parents) {
+        if (prop in this.access) {
+            return this.access[prop];
+        }
+        if (parents && parents.length > 0) {
+            let [parent, ...rest] = parents;
+            return parent.getLive(version, prop, node, rest);
+        }
+        throw new ExpressionSyntaxError(`CustomType doesn't have property ${prop}`, node);
+    }
+}

package/Expressions/__tests__/Replicable.Expressions.Expressions.test.d.ts

@@ -0,0 +1 @@
+import "../Compiler/BuiltinGrammar.js";

package/Expressions/__tests__/Replicable.Expressions.Expressions.test.js

@@ -0,0 +1,166 @@
+import { beforeAll, beforeEach, describe, expect, test } from "vitest";
+import { AddVersion, GetVersionIndex, Versions } from "../../Constants/Versions.js";
+import "../Compiler/BuiltinGrammar.js";
+import { CreateExpression } from "../CreateEvaluator.js";
+import { EvaluationChain } from "../EvaluatorChain.js";
+import { ExpressionScopes, ValidExpressionTypes } from "../TypeRegistry/Registry.js";
+import { PrimitiveType } from "../TypeRegistry/Primitive.js";
+import { ChainFunction, ChainProperty } from "../TypeRegistry/Accessors.js";
+import { ExpressionTestType } from "./ExpressionExamples.js";
+import { ScopeType } from "../TypeRegistry/Scope.js";
+var GetTypeChain = ValidExpressionTypes.GetTypeChain;
+let version = "version";
+const config = {
+    startType: "Custom",
+    cacheable: false,
+    version: Versions.v1_0_0,
+    outputArray: 0,
+    outputMap: false,
+    outputDict: false,
+    outputTypes: [String],
+    duringLoad: false,
+};
+const basicScope = {
+    version: Versions.v1_0_0,
+    data: false,
+    global: {},
+    local: {},
+    self: {},
+};
+beforeEach(() => {
+    ExpressionScopes.ResetScopes();
+});
+beforeAll(() => {
+    AddVersion(version, Versions.v1_0_0);
+});
+//TODO: Test that expression exits properly when currentStep.next is an empty array (from casting?)
+//TODO: Test that expression can return child types and that's OK.
+//TODO: Test that expression can access property on parent type (think this was already done?)
+//TODO: Test IsLoadableDataForRepl with a primitive type that is valid DataIsType.
+//TODO: Test that setting local scope crawls up the heirarchy correctly (i.e. if a local scope is set on a child type,
+//      it should use the typing from the parent type)
+//TODO: Creating an expression with a current set child type will crawl up the heirarchy correctly (same as above but
+//      for creating expressions)
+test("AddVersion", () => {
+    let idx1 = GetVersionIndex(Versions.v1_0_0);
+    let idx2 = GetVersionIndex(version);
+    expect(idx1).not.toBeUndefined();
+    expect(idx1).not.toBe(idx2);
+    expect(idx1 + 1).toBe(idx2);
+});
+describe("Simple Global Expression", () => {
+    let expr;
+    beforeEach(() => {
+        ExpressionScopes.addLocalVariable("Custom", "value", [String]);
+        ExpressionScopes.setLocalScope("Custom", { value: "true" });
+    });
+    test("Create Simple Expression", () => {
+        let newExpression = CreateExpression("@{value}", "x", config);
+        expect(newExpression).not.toBeUndefined();
+        expect(newExpression).instanceOf(EvaluationChain);
+        if (!(newExpression instanceof EvaluationChain))
+            throw new Error(`Nyah!`);
+        expr = newExpression;
+    });
+    test("Simple expression has correct outputs", () => {
+        expect(expr.outputTypes).toHaveLength(1);
+        expect(expr.outputTypes[0]).toBe(String);
+        expect(expr.outputChains).toHaveLength(1);
+        expect(expr.outputChains[0]).instanceof(PrimitiveType);
+        let primChain = expr.outputChains[0];
+        expect(primChain.debugName).toBe("String");
+        expect(primChain.type).toBe(String);
+    });
+    test("Simple expression constructed correctly", () => {
+        expect(expr.steps).not.toBeUndefined();
+        expect(expr.steps.node).instanceof(ScopeType);
+        expect(expr.steps.expression).instanceof(ChainProperty);
+        expect(expr.steps.next).toBeUndefined();
+    });
+    test("Run Simple Expression", () => {
+        expect(expr).not.toBeUndefined();
+        expect(expr).instanceOf(EvaluationChain);
+        if (!(expr instanceof EvaluationChain))
+            throw new Error(`Nyah!`);
+        let value = expr.get(Object.assign(Object.assign({}, basicScope), { local: { value: "true" } }));
+        expect(value).toBe("true");
+    });
+    test("Expression returns incorrect result", () => {
+        expect(() => {
+            let value = expr.get(Object.assign(Object.assign({}, basicScope), { local: { value: false } }));
+            expect(value).toBe("true");
+        }).toThrowError();
+    });
+});
+describe("Lookup Value on Property", () => {
+    const StringType = GetTypeChain(String);
+    const CustomType = new ExpressionTestType("Custom", "value lookup", { second: { type: [String], value: "second lookup" } });
+    CustomType.addProperty("func", new ChainFunction("func", "self", [StringType], [[StringType, StringType]]));
+    test("Run multipart expression", () => {
+        ExpressionScopes.addLocalVariable("Custom", "value", ["Custom2"]);
+        ExpressionScopes.setLocalScope("Custom", { value: "value lookup" });
+        ValidExpressionTypes.SetTypeChain("Custom2", CustomType);
+        let exp = CreateExpression("@{value.second}", "x", config);
+        expect(exp).not.toBeUndefined();
+        expect(exp).instanceOf(EvaluationChain);
+        if (!(exp instanceof EvaluationChain))
+            throw new Error(`Nyah!`);
+        let value = exp.get({
+            version: Versions.v1_0_0,
+            data: false,
+            global: {},
+            local: { value: "value lookup" },
+            self: {},
+        });
+        expect(value).toBe("second lookup");
+    });
+    test("Expression with multiple output types", () => {
+        ExpressionScopes.addLocalVariable("Custom", "value", [String, null]);
+        ExpressionScopes.setLocalScope("Custom", { value: "true" });
+        let exp = CreateExpression("@{value}", "x", config);
+        expect(exp).not.toBeUndefined();
+        expect(exp).instanceOf(EvaluationChain);
+        if (!(exp instanceof EvaluationChain))
+            throw new Error(`Nyah!`);
+        let value = exp.get({
+            version: Versions.v1_0_0,
+            data: false,
+            global: {},
+            local: { value: "true" },
+            self: {},
+        });
+        expect(value).toBe("true");
+    });
+    test("Test multipart expression throws nice error", () => {
+        ExpressionScopes.addLocalVariable("CustomA", "thisValue", [String]);
+        ExpressionScopes.setLocalScope("CustomA", { thisValue: "true" });
+        expect(() => {
+            CreateExpression("@{thisValue.other}", "x", Object.assign(Object.assign({}, config), { startType: "CustomA" }));
+        }).toThrowError(`Error: Key "other" doesn't exist on type "String". Did you mean to write "Other"?
+     ---> thisValue.other
+                    ^^
+    Found in file x on line 1 at 10.
+    `.replace(/\n    /g, "\n"));
+    });
+    test("Call a function on a custom object", () => {
+        ExpressionScopes.addGlobalVariable("value", [String], "true");
+        ExpressionScopes.addLocalVariable("Custom", "func", [String], "Function", [[String, String]]);
+        let exp = CreateExpression("@{func(value, value)}", "x", config);
+        expect(exp).not.toBeUndefined();
+        expect(exp).instanceOf(EvaluationChain);
+        if (!(exp instanceof EvaluationChain))
+            throw new Error(`Nyah!`);
+        let value = exp.get({
+            version: Versions.v1_0_0,
+            data: false,
+            global: {
+                value: "true"
+            },
+            local: {
+                func: (first, second) => first + " " + second
+            },
+            self: {},
+        });
+        expect(value).toBe("true true");
+    });
+});

package/IDPool.d.ts

@@ -0,0 +1,18 @@
+export declare namespace IDPool {
+    function initialise(makeUUIDFunction: () => UUID): Promise<void>;
+    class UUID {
+        private secret;
+        toString(): string;
+    }
+    namespace UUID {
+        const name = "UUID";
+        function isUUID(input: any, complex?: boolean): input is UUID;
+    }
+    function useUUID(): UUID;
+    /**
+     * Verifies the client UUID and removes it from the pool of client UUIDs.
+     * @param id
+     * @param remoteID
+     */
+    function verifyClientUUID(id: UUID, remoteID: UUID): boolean;
+}

package/IDPool.data.d.ts

@@ -0,0 +1,17 @@
+
+
+
+// This file is automatically generated. Do not edit it, all edits will be overwritten on compile.// This file contains the typescript types for the data definitions for the corresponding 
+// types in the .ts file this file is named after.
+
+
+export type UUIDDefinition = IDPool.UUID;
+
+
+
+export type UUIDSerialised = IDPool.UUID;
+
+export type UUIDSerialisedReference = [ string, UUIDSerialised ];
+
+
+