@bikky/replication 1.0.1

package/Expressions/TypeRegistry/ChainTypes.js

@@ -0,0 +1,46 @@
+import { ExpressionSyntaxError } from "../../Constants/Errors.js";
+export class ChainType {
+    constructor(debugName) {
+        this.debugName = debugName;
+    }
+    getOutputTypes() {
+        return [this.getOwnOutputTypes(), this.getOwnOutputStyle()];
+    }
+    checkContextScopes(version, prop, node, contexts) {
+        if (contexts && contexts.length > 0) {
+            let [parentContext, ...rest] = contexts;
+            try {
+                return parentContext.getLive(version, prop, node, rest);
+            }
+            catch (e) {
+                if (e instanceof ExpressionSyntaxError) {
+                    e.message = e.message.replace(/\n/, ` Nor on type "${this.debugName}".\n`);
+                    e.stack = e.stack.replace(/\n/, ` Nor on type "${this.debugName}".\n`);
+                }
+                throw e;
+            }
+        }
+        let appendix = "";
+        //Kinda hacky, but since expressions are PascalCase by default, we can do a hard-coded reminder here.
+        //TODO: Actually check to see if the upper-case version exists.
+        if (prop[0].toLowerCase() == prop[0]) {
+            appendix = ` Did you mean to write "${prop[0].toUpperCase() + prop.slice(1)}"?`;
+        }
+        throw new ExpressionSyntaxError(`Error: Key "${prop}" doesn't exist on type "${this.debugName}".` + appendix, node);
+    }
+    checkContextsData(version, prop, node, parents) {
+        if (parents && parents.length > 0) {
+            let [parent, ...rest] = parents;
+            try {
+                return parent.getData(version, prop, node, rest);
+            }
+            catch (e) {
+                if (e instanceof ExpressionSyntaxError) {
+                    e.message.replace(/\n/, `\nNor in scope ${this.debugName}.\n`);
+                }
+                throw e;
+            }
+        }
+        throw new ExpressionSyntaxError(`No variable with the name ${prop} exists in scope ${this.debugName}.`, node);
+    }
+}

package/Expressions/TypeRegistry/CustomAPI.d.ts

@@ -0,0 +1,36 @@
+import { ChainType } from "./ChainTypes.js";
+import { Versions } from "../../Constants/Versions.js";
+import { ErrorStack } from "../../Constants/Errors.js";
+import { ExpressionGrammar } from "../Compiler/ExpressionGrammar.js";
+import Node = ExpressionGrammar.Node;
+export declare class CustomType extends ChainType {
+    typePlaceholder: any;
+    properties: any;
+    dataProperties: any;
+    name: string;
+    isLiveOfType?: (obj: any) => boolean;
+    isDataOfType?: (data: any) => boolean;
+    typeCastableToThis?: (type: any) => boolean;
+    constructor(name: string, thing: any);
+    getOwnOutputTypes(): any[];
+    getOwnOutputStyle(): ReturnType<ChainType["getOwnOutputStyle"]>;
+    isAssignableCompile(version: Versions, type: any): boolean;
+    isAssignableLive(version: Versions, value: any): any;
+    isAssignableData(version: Versions, value: any, stack: ErrorStack): any;
+    isCastableCompile(version: Versions, type: any): any;
+    isCastableLive(version: Versions, value: any): any;
+    isCastableData(version: Versions, value: any, stack: ErrorStack): any;
+    getLive(version: Versions, prop: string, node: Node, parents?: ChainType[]): any;
+    getData(version: Versions, prop: string, node: Node, parents?: ChainType[]): any;
+}
+export declare class CustomExpressionTypeAPI {
+    #private;
+    constructor(type: "Custom", name: string, source: any);
+    registerIsTypeCheck(isLiveOfType: (obj: any) => boolean): this;
+    registerIsDataCheck(isDataOfType: (data: any) => boolean): this;
+    registerIsTypeCastableToThis(typeCastableToThis: (type: any) => boolean): this;
+    addProperty(version: Versions, name: string, types: any[]): this;
+    addMap(version: Versions, name: string, types: any[]): this;
+    addDict(version: Versions, name: string, types: any[]): this;
+    addFunction(version: Versions, name: string, types: any[], parameters: any[][]): this;
+}

package/Expressions/TypeRegistry/CustomAPI.js

@@ -0,0 +1,181 @@
+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 _CustomExpressionTypeAPI_private;
+import { InstantPromise, VersionMap } from "@bikky/smart-collections";
+import { ChainType } from "./ChainTypes.js";
+import { ChainFunction, ChainProperty } from "./Accessors.js";
+import { GetAllVersionsAfter, Versions } from "../../Constants/Versions.js";
+import { ValidExpressionTypes } from "./Registry.js";
+import { Progress } from "../../Transformers/Progress.js";
+export class CustomType extends ChainType {
+    constructor(name, thing) {
+        super(name);
+        this.properties = new VersionMap(Versions.v1_0_0);
+        this.dataProperties = new VersionMap(Versions.v1_0_0);
+        this.name = name;
+        this.typePlaceholder = thing;
+        ValidExpressionTypes.SetTypeChain(thing, this);
+        ValidExpressionTypes.AddAliasForType(name, thing);
+    }
+    getOwnOutputTypes() {
+        return [this.typePlaceholder];
+    }
+    getOwnOutputStyle() {
+        return "Single";
+    }
+    isAssignableCompile(version, type) {
+        var _a;
+        return ((_a = this.typeCastableToThis) === null || _a === void 0 ? void 0 : _a.call(this, type)) || type == this.typePlaceholder;
+    }
+    isAssignableLive(version, value) {
+        var _a, _b, _c, _d, _e;
+        return (_e = (_b = (_a = this.isLiveOfType) === null || _a === void 0 ? void 0 : _a.call(this, value)) !== null && _b !== void 0 ? _b : (_d = (_c = this.typePlaceholder).isLiveOfType) === null || _d === void 0 ? void 0 : _d.call(_c, value)) !== null && _e !== void 0 ? _e : false;
+    }
+    isAssignableData(version, value, stack) {
+        var _a, _b, _c, _d, _e;
+        return (_e = (_b = (_a = this.isDataOfType) === null || _a === void 0 ? void 0 : _a.call(this, value)) !== null && _b !== void 0 ? _b : (_d = (_c = this.typePlaceholder).isDataOfType) === null || _d === void 0 ? void 0 : _d.call(_c, value)) !== null && _e !== void 0 ? _e : false;
+    }
+    isCastableCompile(version, type) {
+        var _a, _b, _c, _d, _e;
+        return (_e = (_b = (_a = this.typeCastableToThis) === null || _a === void 0 ? void 0 : _a.call(this, type)) !== null && _b !== void 0 ? _b : (_d = (_c = this.typePlaceholder).typeCastableToThis) === null || _d === void 0 ? void 0 : _d.call(_c, type)) !== null && _e !== void 0 ? _e : false;
+    }
+    isCastableLive(version, value) {
+        var _a, _b, _c, _d, _e;
+        return (_e = (_b = (_a = this.isLiveOfType) === null || _a === void 0 ? void 0 : _a.call(this, value)) !== null && _b !== void 0 ? _b : (_d = (_c = this.typePlaceholder).isLiveOfType) === null || _d === void 0 ? void 0 : _d.call(_c, value)) !== null && _e !== void 0 ? _e : false;
+    }
+    isCastableData(version, value, stack) {
+        var _a, _b, _c, _d, _e;
+        return (_e = (_b = (_a = this.isDataOfType) === null || _a === void 0 ? void 0 : _a.call(this, value)) !== null && _b !== void 0 ? _b : (_d = (_c = this.typePlaceholder).isDataOfType) === null || _d === void 0 ? void 0 : _d.call(_c, value)) !== null && _e !== void 0 ? _e : false;
+    }
+    getLive(version, prop, node, parents) {
+        let value = this.properties.get(version, prop);
+        if (value)
+            return value;
+        return this.checkContextScopes(version, prop, node, parents);
+    }
+    getData(version, prop, node, parents) {
+        let value = this.dataProperties.get(version, prop);
+        if (value)
+            return value;
+        return this.checkContextsData(version, prop, node, parents);
+    }
+}
+export class CustomExpressionTypeAPI {
+    constructor(type, name, source) {
+        _CustomExpressionTypeAPI_private.set(this, void 0);
+        __classPrivateFieldSet(this, _CustomExpressionTypeAPI_private, new CustomType(name, source), "f");
+    }
+    registerIsTypeCheck(isLiveOfType) {
+        __classPrivateFieldGet(this, _CustomExpressionTypeAPI_private, "f").isLiveOfType = isLiveOfType;
+        return this;
+    }
+    registerIsDataCheck(isDataOfType) {
+        __classPrivateFieldGet(this, _CustomExpressionTypeAPI_private, "f").isDataOfType = isDataOfType;
+        return this;
+    }
+    registerIsTypeCastableToThis(typeCastableToThis) {
+        __classPrivateFieldGet(this, _CustomExpressionTypeAPI_private, "f").typeCastableToThis = typeCastableToThis;
+        return this;
+    }
+    addProperty(version, name, types) {
+        InstantPromise.all(types.flatMap((e) => {
+            return Progress.AwaitReplicableFor(e);
+        }).flat()).then((result) => {
+            let types = result.flat();
+            let chains = types.map((e) => {
+                let chain = ValidExpressionTypes.GetTypeChain(e);
+                if (!chain)
+                    throw new Error(`Error, attempted to register type as expression parameter`
+                        + `, but type hasn't been registered with expressions ${e}`);
+                return chain;
+            });
+            let accessor = new ChainProperty(name, "self", chains);
+            for (let after of GetAllVersionsAfter(version)) {
+                __classPrivateFieldGet(this, _CustomExpressionTypeAPI_private, "f").properties.set(after, name, accessor);
+            }
+        });
+        return this;
+    }
+    addMap(version, name, types) {
+        InstantPromise.all(types.flatMap((e) => {
+            return Progress.AwaitReplicableFor(e);
+        }).flat()).then((result) => {
+            let types = result.flat();
+            let chains = types.map((e) => {
+                let chain = ValidExpressionTypes.GetTypeChain(e);
+                if (!chain)
+                    throw new Error(`Error, attempted to register type as expression parameter`
+                        + `, but type hasn't been registered with expressions ${e}`);
+                return chain;
+            });
+            let mapType = ValidExpressionTypes.GetMapType(chains);
+            let accessor = new ChainProperty(name, "self", [mapType]);
+            for (let after of GetAllVersionsAfter(version)) {
+                __classPrivateFieldGet(this, _CustomExpressionTypeAPI_private, "f").properties.set(after, name, accessor);
+            }
+        });
+        return this;
+    }
+    addDict(version, name, types) {
+        InstantPromise.all(types.flatMap((e) => {
+            return Progress.AwaitReplicableFor(e);
+        }).flat()).then((result) => {
+            let types = result.flat();
+            let chains = types.map((e) => {
+                let chain = ValidExpressionTypes.GetTypeChain(e);
+                if (!chain)
+                    throw new Error(`Error, attempted to register type as expression parameter`
+                        + `, but type hasn't been registered with expressions ${e}`);
+                return chain;
+            });
+            let dictType = ValidExpressionTypes.GetDictType(chains);
+            let accessor = new ChainProperty(name, "self", [dictType]);
+            for (let after of GetAllVersionsAfter(version)) {
+                __classPrivateFieldGet(this, _CustomExpressionTypeAPI_private, "f").dataProperties.set(after, name, accessor);
+            }
+        });
+        return this;
+    }
+    addFunction(version, name, types, parameters) {
+        let loadingTypes = types.flatMap((e) => {
+            return Progress.AwaitReplicableFor(e);
+        }).flat();
+        let loadingParams = parameters.map((e) => {
+            return e.map((g) => Progress.AwaitReplicableFor(g)).flat();
+        });
+        InstantPromise.all([...loadingTypes, ...(loadingParams.flat())]).then(() => {
+            types = loadingTypes.map((e) => e.result).flat();
+            parameters = loadingParams.map((e) => e.map((g) => g.result).flat());
+            types = types.map((e) => {
+                let chain = ValidExpressionTypes.GetTypeChain(e);
+                if (!chain) {
+                    throw new Error(`Error, attempted to register type as expression parameter`
+                        + `, but type hasn't been registered with expressions ${e}`);
+                }
+                return chain;
+            });
+            parameters = parameters.map((slot) => slot.map((e) => {
+                let chain = ValidExpressionTypes.GetTypeChain(e);
+                if (!chain)
+                    throw new Error(`Error, attempted to register type as expression parameter`
+                        + `, but type hasn't been registered with expressions ${e}`);
+                return chain;
+            }));
+            let accessor = new ChainFunction(name, "self", types, parameters);
+            for (let after of GetAllVersionsAfter(version)) {
+                __classPrivateFieldGet(this, _CustomExpressionTypeAPI_private, "f").properties.set(after, name, accessor);
+            }
+        });
+        return this;
+    }
+}
+_CustomExpressionTypeAPI_private = new WeakMap();

package/Expressions/TypeRegistry/Primitive.d.ts

@@ -0,0 +1,19 @@
+import { ChainType } from "./ChainTypes.js";
+import { ExpressionGrammar } from "../Compiler/ExpressionGrammar.js";
+import { ChainAccessor } from "./Accessors.js";
+import { ErrorStack } from "../../Constants/Errors.js";
+import { Versions } from "../../Constants/Versions.js";
+export declare class PrimitiveType extends ChainType {
+    type: any;
+    constructor(name: string, type: any);
+    getOwnOutputStyle(): ReturnType<ChainType["getOwnOutputStyle"]>;
+    getOwnOutputTypes(): any[];
+    isAssignableCompile(version: Versions, type: any, style: ReturnType<ChainType["getOwnOutputStyle"]>): 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/TypeRegistry/Primitive.js

@@ -0,0 +1,47 @@
+import { ChainType } from "./ChainTypes.js";
+import { ValidExpressionTypes } from "./Registry.js";
+import { describeObject, ValueIsPrimitiveType } from "../../Constants/SerialisationTypes.js";
+export class PrimitiveType extends ChainType {
+    constructor(name, type) {
+        super(name);
+        this.type = type;
+        ValidExpressionTypes.SetTypeChain(type, this);
+        ValidExpressionTypes.AddAliasForType(this.debugName, type);
+        ValidExpressionTypes.AddAliasForType(describeObject(type), type);
+    }
+    getOwnOutputStyle() {
+        return "Single";
+    }
+    getOwnOutputTypes() {
+        return [this.type];
+    }
+    isAssignableCompile(version, type, style) {
+        return type == this.type && style == "Single";
+    }
+    isAssignableData(version, value, stack) {
+        return ValueIsPrimitiveType(this.type, value);
+    }
+    isAssignableLive(version, value) {
+        return ValueIsPrimitiveType(this.type, value);
+    }
+    isCastableCompile(version, type) {
+        return false;
+    }
+    isCastableData(version, value, stack) {
+        return false;
+    }
+    isCastableLive(version, value) {
+        return false;
+    }
+    getData(version, prop, node, parents) {
+        return this.checkContextsData(version, prop, node, parents);
+    }
+    getLive(version, prop, node, parents) {
+        return this.checkContextScopes(version, prop, node, parents);
+    }
+}
+new PrimitiveType("String", String);
+new PrimitiveType("Boolean", Boolean);
+new PrimitiveType("Number", Number);
+new PrimitiveType("null", null);
+new PrimitiveType("undefined", undefined);

package/Expressions/TypeRegistry/Registry.d.ts

@@ -0,0 +1,27 @@
+import { ChainType } from "./ChainTypes.js";
+export declare namespace ValidExpressionTypes {
+    function GetTypeChain(name: any): ChainType | undefined;
+    function SetTypeChain(name: any, rule: ChainType): void;
+    function ToRawTypes(type: any[]): any[];
+    function AddAliasForType(newAlias: any, existingType: any): void;
+    function GetDictType(types: ChainType[]): ChainType;
+    function GetMapType(types: ChainType[]): ChainType;
+    function GetArrayType(types: ChainType[]): ChainType;
+}
+export declare namespace ExpressionScopes {
+    type ScopeValues = {
+        [variable: string]: any;
+    };
+    /**
+     * This function is only for testing!
+     */
+    export function ResetScopes(): void;
+    export function GetScopeChain(type: any): [ChainType, ChainType | undefined, {
+        local: ScopeValues;
+        global: ScopeValues;
+    }];
+    export function addLocalVariable(scope: any, variableName: string, types: any[], behaviour?: "Map" | "Dict" | "Function", params?: any[][]): void;
+    export function setLocalScope(scope: any, values: ScopeValues): void;
+    export function addGlobalVariable(globalName: string, types: any[], value: any, behaviour?: "Map" | "Dict" | "Function", params?: any[][]): void;
+    export {};
+}

package/Expressions/TypeRegistry/Registry.js

@@ -0,0 +1,270 @@
+import { describeObject } from "../../Constants/SerialisationTypes.js";
+import { ChainFunction, ChainProperty } from "./Accessors.js";
+import { ArrayType, DictType, MapType } from "./ChainCollections.js";
+import { ArrayMap } from "@bikky/smart-collections";
+import { ChainType } from "./ChainTypes.js";
+import { ScopeType } from "./Scope.js";
+import { ReplicableRegistry } from "../../Constants/ReplicableRegistry.js";
+const TypeRules = new Map();
+const AliasMap = new ArrayMap();
+const LiveLocalMaps = new Map();
+const DataLocalMaps = new Map();
+const LocalScopeRules = new Map();
+let liveGlobalMap = {};
+let dataGlobalMap = {};
+let globalScopeRules;
+export var ValidExpressionTypes;
+(function (ValidExpressionTypes) {
+    function GetTypeChain(name) {
+        return TypeRules.get(name);
+    }
+    ValidExpressionTypes.GetTypeChain = GetTypeChain;
+    OnBikDelayCompleted(function MapProgressClasses(old, upd) {
+        let val = TypeRules.get(old);
+        let val2 = TypeRules.get(upd);
+        //If it's registered with the old class, make the new class an alias.
+        if (val) {
+            TypeRules.set(upd, val);
+            AliasMap.push(val, upd);
+        }
+        //If it's registered with the new class, make the old class an alias.
+        else if (val2) {
+            TypeRules.set(old, val2);
+        }
+    });
+    function SetTypeChain(name, rule) {
+        TypeRules.set(name, rule);
+        AliasMap.push(rule, name);
+    }
+    ValidExpressionTypes.SetTypeChain = SetTypeChain;
+    function ToRawTypes(type) {
+        return type.flatMap(t => {
+            if (t instanceof ChainType) {
+                return t.getOwnOutputTypes();
+            }
+            else {
+                let type = ValidExpressionTypes.GetTypeChain(t);
+                return type ? type.getOwnOutputTypes() : [t];
+            }
+        });
+    }
+    ValidExpressionTypes.ToRawTypes = ToRawTypes;
+    ChainType.ToRawTypes = ToRawTypes;
+    function AddAliasForType(newAlias, existingType) {
+        let rule = TypeRules.get(existingType);
+        if (!rule) {
+            throw new Error(`Error, attempted to alias ${existingType} to ${newAlias} but ${existingType} doesn't exist in the parser's lexicon.`);
+        }
+        TypeRules.set(newAlias, rule);
+        AliasMap.push(rule, newAlias);
+        if (LiveLocalMaps.has(existingType)) {
+            LiveLocalMaps.set(newAlias, LiveLocalMaps.get(existingType));
+        }
+        if (DataLocalMaps.has(existingType)) {
+            DataLocalMaps.set(newAlias, DataLocalMaps.get(existingType));
+        }
+        if (LocalScopeRules.has(existingType)) {
+            LocalScopeRules.set(newAlias, LocalScopeRules.get(existingType));
+        }
+    }
+    ValidExpressionTypes.AddAliasForType = AddAliasForType;
+    function GetDictType(types) {
+        let name = DictType.generateName(types);
+        let dict = ValidExpressionTypes.GetTypeChain(name);
+        if (!dict) {
+            dict = new DictType(name, types);
+            ValidExpressionTypes.SetTypeChain(name, dict);
+        }
+        return dict;
+    }
+    ValidExpressionTypes.GetDictType = GetDictType;
+    function GetMapType(types) {
+        let name = MapType.generateName(types);
+        let map = ValidExpressionTypes.GetTypeChain(name);
+        if (!map) {
+            map = new MapType(name, types);
+            ValidExpressionTypes.SetTypeChain(name, map);
+        }
+        return map;
+    }
+    ValidExpressionTypes.GetMapType = GetMapType;
+    function GetArrayType(types) {
+        let name = ArrayType.generateName(types);
+        let array = ValidExpressionTypes.GetTypeChain(name);
+        if (!array) {
+            array = new ArrayType(name, types);
+            ValidExpressionTypes.SetTypeChain(name, array);
+        }
+        return array;
+    }
+    ValidExpressionTypes.GetArrayType = GetArrayType;
+})(ValidExpressionTypes || (ValidExpressionTypes = {}));
+export var ExpressionScopes;
+(function (ExpressionScopes) {
+    var GetTypeChain = ValidExpressionTypes.GetTypeChain;
+    const CurrentLocalScopeValues = new Map();
+    let globalScopeValues = {};
+    /**
+     * This function is only for testing!
+     */
+    function ResetScopes() {
+        if (typeof TestingMode === "boolean" && TestingMode) {
+            CurrentLocalScopeValues.clear();
+            globalScopeValues = {};
+            liveGlobalMap = {};
+            dataGlobalMap = {};
+            LiveLocalMaps.clear();
+            DataLocalMaps.clear();
+            LocalScopeRules.clear();
+            globalScopeRules = new ScopeType("Global", liveGlobalMap, dataGlobalMap);
+        }
+        else {
+            throw new Error("Error, attempted to reset scopes in a non-testing environment.");
+        }
+    }
+    ExpressionScopes.ResetScopes = ResetScopes;
+    function GetScopeChain(type) {
+        if (!globalScopeRules) {
+            globalScopeRules = new ScopeType("Global", liveGlobalMap, dataGlobalMap);
+        }
+        let scopeObj = {};
+        let name = type;
+        if (typeof name !== "string") {
+            name = ReplicableRegistry.GetDataName(name);
+        }
+        Object.defineProperties(scopeObj, {
+            local: {
+                value: Object.assign({}, CurrentLocalScopeValues.get(name)),
+                writable: false,
+                configurable: true,
+                enumerable: true
+            },
+            global: {
+                value: Object.assign({}, globalScopeValues),
+                writable: false,
+                configurable: false,
+                enumerable: true
+            }
+        });
+        return [globalScopeRules, LocalScopeRules.get(name), scopeObj];
+    }
+    ExpressionScopes.GetScopeChain = GetScopeChain;
+    function addLocalVariable(scope, variableName, types, behaviour, params) {
+        var _a;
+        let liveLocalScope = LiveLocalMaps.get(scope);
+        let rule = TypeRules.get(scope);
+        let aliases = [scope];
+        if (rule) {
+            aliases = (_a = AliasMap.get(rule)) !== null && _a !== void 0 ? _a : aliases;
+        }
+        if (!liveLocalScope) {
+            liveLocalScope = {};
+            for (let alias of aliases) {
+                LiveLocalMaps.set(alias, liveLocalScope);
+            }
+        }
+        let dataLocalScope = DataLocalMaps.get(scope);
+        if (!dataLocalScope) {
+            dataLocalScope = {};
+            for (let alias of aliases) {
+                DataLocalMaps.set(alias, dataLocalScope);
+            }
+        }
+        let chain = LocalScopeRules.get(scope);
+        if (!chain) {
+            chain = aliases.map((e) => LocalScopeRules.get(e)).filter((e) => e)[0];
+            if (!chain) {
+                chain = new ScopeType(describeObject(scope) + "_scope", liveLocalScope, dataLocalScope);
+            }
+            aliases.forEach((e) => LocalScopeRules.set(e, chain));
+        }
+        switch (behaviour) {
+            case "Map": {
+                types = [
+                    ValidExpressionTypes.GetMapType(types)
+                ];
+                break;
+            }
+            case "Dict": {
+                types = [
+                    ValidExpressionTypes.GetDictType(types)
+                ];
+                break;
+            }
+        }
+        if (behaviour === "Function") {
+            params = params !== null && params !== void 0 ? params : [];
+            let paramChains = params.map((e) => e.map((p) => {
+                let result = GetTypeChain(p);
+                if (!result) {
+                    throw new Error(`Error, ${p} is not a valid type.`);
+                }
+                return result;
+            }));
+            liveLocalScope[variableName] = new ChainFunction(variableName, "local", types, paramChains);
+        }
+        else {
+            liveLocalScope[variableName] = new ChainProperty(variableName, "local", types);
+            dataLocalScope[variableName] = new ChainProperty(variableName, "local", types);
+        }
+    }
+    ExpressionScopes.addLocalVariable = addLocalVariable;
+    function helpSetLocalScope(scope, values) {
+        if (LiveLocalMaps.has(scope)) {
+            CurrentLocalScopeValues.set(scope, values);
+            return true;
+        }
+        let chain = GetTypeChain(scope);
+        //This is a bit hacky...
+        if (chain && "repl" in chain) {
+            let repl = chain.repl;
+            for (let parent of repl.parents) {
+                if (helpSetLocalScope(parent.classConstructor, values)) {
+                    return true;
+                }
+            }
+        }
+        if (!chain) {
+            let proto = Object.getPrototypeOf(scope);
+            while (proto && proto !== Function.prototype) {
+                scope = proto;
+                if (helpSetLocalScope(scope, values)) {
+                    return true;
+                }
+                proto = Object.getPrototypeOf(scope);
+            }
+        }
+        return false;
+    }
+    function setLocalScope(scope, values) {
+        if (!helpSetLocalScope(scope, values)) {
+            throw new Error(`Error, attempted to set local scope for ${describeObject(scope)} but it doesn't exist.`);
+        }
+    }
+    ExpressionScopes.setLocalScope = setLocalScope;
+    function addGlobalVariable(globalName, types, value, behaviour, params) {
+        switch (behaviour) {
+            case "Map": {
+                types = [
+                    ValidExpressionTypes.GetMapType(types)
+                ];
+                break;
+            }
+            case "Dict": {
+                types = [
+                    ValidExpressionTypes.GetDictType(types)
+                ];
+                break;
+            }
+        }
+        if (behaviour === "Function") {
+            liveGlobalMap[globalName] = new ChainFunction(globalName, "global", types, params !== null && params !== void 0 ? params : []);
+        }
+        else {
+            liveGlobalMap[globalName] = new ChainProperty(globalName, "global", types);
+            dataGlobalMap[globalName] = new ChainProperty(globalName, "global", types);
+        }
+        globalScopeValues[globalName] = value;
+    }
+    ExpressionScopes.addGlobalVariable = addGlobalVariable;
+})(ExpressionScopes || (ExpressionScopes = {}));

package/Expressions/TypeRegistry/ReplAPI.d.ts

@@ -0,0 +1,41 @@
+import { ChainType } from "./ChainTypes.js";
+import { PropertyDoesntExist, PropertyRemoved, ReplicableClass } from "../../Tracking/Class.js";
+import { Versions } from "../../Constants/Versions.js";
+import { ErrorStack } from "../../Constants/Errors.js";
+import type { ReplicableRegistry } from "../../Constants/ReplicableRegistry.js";
+import { ExpressionGrammar } from "../Compiler/ExpressionGrammar.js";
+import Node = ExpressionGrammar.Node;
+import { ComplexPropertyType, PropertyConfiguration } from "../../Tracking/Property.js";
+import type { Definitions } from "../../Transformers/Definitions.js";
+export declare namespace __ReplTypeHelperFunctions {
+    function SetIsLoadableDataForType(func: typeof Definitions.IsLoadableDataForType): void;
+    function SetDataNameTypeLookupFunction(lookupFunc: typeof ReplicableRegistry.GetTypeForDataName): void;
+    function SetPrimOrClassLookupFunction(lookupFunc: typeof ReplicableRegistry.__GetReplOrPrimFor): void;
+}
+export declare class ReplType extends ChainType {
+    repl: ReplicableClass;
+    properties: any;
+    dataProperties: any;
+    constructor(repl: ReplicableClass);
+    getOwnOutputStyle(): ReturnType<ChainType["getOwnOutputStyle"]>;
+    getOwnOutputTypes(): any[];
+    isAssignableCompile(version: Versions, type: any): boolean;
+    isAssignableLive(version: Versions, value: any): boolean;
+    isAssignableData(version: Versions, value: any, stack: ErrorStack): boolean;
+    isCastableCompile(version: Versions, type: any): boolean;
+    isCastableLive(version: Versions, value: any): boolean;
+    isCastableData(version: Versions, value: any, stack: ErrorStack): boolean;
+    getLive(version: Versions, prop: string, node: Node, contexts?: ChainType[]): any;
+    getData(version: Versions, prop: string, node: Node, contexts?: ChainType[]): any;
+}
+export declare class ReplAPI {
+    #private;
+    replicable: ReplicableClass;
+    constructor(type: "Repl", opts: ReplicableClass);
+    addProperty(version: Versions | string, def: PropertyConfiguration | PropertyRemoved | PropertyDoesntExist): Promise<void>;
+    private addPropertyHelper;
+    addFunction(version: Versions, opts: {
+        name: string;
+        exprName: string;
+    }, types: ComplexPropertyType[], parameters: ComplexPropertyType[][]): void;
+}