@bikky/replication 1.0.1

package/Transformers/Configurer.d.ts

@@ -0,0 +1,39 @@
+import { Versions } from "../Constants/Versions.js";
+import { PropertyLoadingTypeInfo, PropertySerialiseTypeInfo } from "../Tracking/Property.js";
+import { PropertyTypes } from "../Constants/SerialisationTypes.js";
+import { ExpressionConfiguration } from "../Expressions/EvaluatorSteps.js";
+import { FunctionConfiguration, PropertyDefinition, PropertyDoesntExist, PropertyRemoved, ReplicableClass } from "../Tracking/Class.js";
+/**
+ * Handles the setup of the replicable class based on the configuration provided via the source code's decorators.
+ * Does some pre-caching of versioning information and other metadata.
+ */
+export declare namespace Configurer {
+    type PartialPropDefs = Map<Versions | string, {
+        [name: string]: PropertyDefinition | PropertyRemoved;
+    }>;
+    type PartialFooDefs = Map<Versions | string, {
+        [name: string]: FunctionConfiguration | PropertyRemoved;
+    }>;
+    type PropDefs = Map<Versions | string, {
+        [name: string]: PropertyDefinition | PropertyRemoved | PropertyDoesntExist;
+    }>;
+    type FooDefs = Map<Versions | string, {
+        [name: string]: FunctionConfiguration | PropertyRemoved | PropertyDoesntExist;
+    }>;
+    function RecursivelyCacheParentProperties(source: ReplicableClass, current: ReplicableClass, propDefs: PartialPropDefs, fooDefs: PartialFooDefs): void;
+    function CacheOwnProperties(repl: ReplicableClass, propDefs: PartialPropDefs, fooDefs: PartialFooDefs): void;
+    function PropagatePropertyCacheForwardInVersions(repl: ReplicableClass, propDefs: PartialPropDefs, fooDefs: PartialFooDefs, computedPropDefs: PropDefs, computedFooDefs: FooDefs): void;
+    function PropagateMissingPropertiesBackwardInVersions(repl: ReplicableClass, computedPropDefs: PropDefs, computedFooDefs: FooDefs): void;
+    function ComputePropertyDefinitionConfiguration(prop: PropertyDefinition): readonly [PropertyLoadingTypeInfo[], PropertyTypes, boolean];
+    function ComputePropertySerialisedConfiguration(prop: PropertyDefinition, loadPresence: boolean | "optional", propAllowsUndefined: boolean): readonly [PropertySerialiseTypeInfo[], PropertyTypes, boolean];
+    function ComputePropertyExpressionConfiguration(repl: ReplicableClass, prop: PropertyDefinition, loadModifiers: PropertyTypes, loadTypes: PropertyLoadingTypeInfo[]): readonly [{
+        "1.0.0": ExpressionConfiguration;
+    } | undefined, {
+        "1.0.0": ExpressionConfiguration;
+    } | undefined, {
+        "1.0.0": ExpressionConfiguration;
+    } | undefined];
+    function ComputePropertyConfigurationsInVersion(repl: ReplicableClass, version: Versions | string, computedPropDefs: PropDefs): void;
+    function ComputeFunctionExpressionConfiguration(repl: ReplicableClass, version: Versions | string, computedFooDefs: FooDefs): void;
+    function CacheClassProperties(repl: ReplicableClass): void;
+}

package/Transformers/Configurer.js

@@ -0,0 +1,415 @@
+import { GetAllVersions } from "../Constants/Versions.js";
+import { generateDataName, GetTypeName, isPrimitiveType, primitiveTypeName, PropertyTypes } from "../Constants/SerialisationTypes.js";
+import { ReplicableRegistry } from "../Constants/ReplicableRegistry.js";
+import { Utils } from "./Utils.js";
+import { Expression } from "../Expressions/Expression.js";
+import { ReplicableClass } from "../Tracking/Class.js";
+/**
+ * Handles the setup of the replicable class based on the configuration provided via the source code's decorators.
+ * Does some pre-caching of versioning information and other metadata.
+ */
+export var Configurer;
+(function (Configurer) {
+    function RecursivelyCacheParentProperties(source, current, propDefs, fooDefs) {
+        var _a, _b;
+        let versions = GetAllVersions();
+        for (let parent of current.parents) {
+            // For each parent we need to add all of their properties to our own.
+            RecursivelyCacheParentProperties(source, parent, propDefs, fooDefs);
+            // Then iterate through our own properties and override the existing ones with our own.
+            for (let version of versions) {
+                let props = parent.properties.all(version);
+                let newProps = (_a = propDefs.get(version)) !== null && _a !== void 0 ? _a : {};
+                for (let [property, def] of Object.entries(props)) {
+                    if (!source.finalised_propertyNames.includes(property)) {
+                        source.finalised_propertyNames.push(property);
+                    }
+                    newProps[property] = def;
+                }
+                propDefs.set(version, newProps);
+                let foos = parent.functions.all(version);
+                let newFoos = (_b = fooDefs.get(version)) !== null && _b !== void 0 ? _b : {};
+                for (let [foo, def] of Object.entries(foos)) {
+                    if (!source.finalised_functionNames.includes(foo)) {
+                        source.finalised_functionNames.push(foo);
+                    }
+                    newFoos[foo] = def;
+                }
+                fooDefs.set(version, newFoos);
+            }
+        }
+    }
+    Configurer.RecursivelyCacheParentProperties = RecursivelyCacheParentProperties;
+    function CacheOwnProperties(repl, propDefs, fooDefs) {
+        var _a, _b;
+        let versions = GetAllVersions();
+        for (let version of versions) {
+            let props = repl.properties.all(version);
+            let new_props = (_a = propDefs.get(version)) !== null && _a !== void 0 ? _a : {};
+            for (let [property, def] of Object.entries(props)) {
+                if (!repl.finalised_propertyNames.includes(property)) {
+                    repl.finalised_propertyNames.push(property);
+                }
+                if (!repl.finalised_ownPropertyNames.includes(property)) {
+                    repl.finalised_ownPropertyNames.push(property);
+                }
+                new_props[property] = def;
+            }
+            propDefs.set(version, new_props);
+            let foos = repl.functions.all(version);
+            let new_foos = (_b = fooDefs.get(version)) !== null && _b !== void 0 ? _b : {};
+            for (let [foo, def] of Object.entries(foos)) {
+                if (!repl.finalised_functionNames.includes(foo)) {
+                    repl.finalised_functionNames.push(foo);
+                }
+                if (!repl.finalised_ownFunctionNames.includes(foo)) {
+                    repl.finalised_ownFunctionNames.push(foo);
+                }
+                new_foos[foo] = def;
+            }
+            fooDefs.set(version, new_foos);
+        }
+        repl.finalised_propertyNames.sort();
+        repl.finalised_ownPropertyNames.sort();
+        repl.finalised_functionNames.sort();
+        repl.finalised_ownFunctionNames.sort();
+    }
+    Configurer.CacheOwnProperties = CacheOwnProperties;
+    function PropagatePropertyCacheForwardInVersions(repl, propDefs, fooDefs, computedPropDefs, computedFooDefs) {
+        let carriedProps = {};
+        let carriedFoos = {};
+        let versions = GetAllVersions();
+        // Go through the versions forwards and propagate properties into the later versions if they don't exist.
+        for (let version of versions) {
+            let definedProps = propDefs.get(version);
+            let computedProps = computedPropDefs.get(version);
+            if (!definedProps)
+                definedProps = {};
+            if (!computedProps)
+                computedPropDefs.set(version, computedProps = {});
+            for (let name of repl.finalised_propertyNames) {
+                let prop = definedProps[name];
+                // If the property doesn't exist and hasn't existed, make an empty entry.
+                if (!prop && !carriedProps[name]) {
+                    computedProps[name] = { version, property: name, doesntExist: true };
+                }
+                // If the property doesn't exist but has existed, use the existing definition.
+                else if (!prop) {
+                    computedProps[name] = carriedProps[name];
+                }
+                // If the proeprty does exist, then use that and update the carry.
+                else {
+                    carriedProps[name] = prop;
+                    computedProps[name] = prop;
+                }
+            }
+            //Functions.
+            let definedFoos = fooDefs.get(version);
+            let computedFoos = computedFooDefs.get(version);
+            if (!definedFoos)
+                definedFoos = {};
+            if (!computedFoos)
+                computedFooDefs.set(version, computedFoos = {});
+            for (let name of repl.finalised_functionNames) {
+                let foo = definedFoos[name];
+                if (!foo && !carriedFoos[name]) {
+                    computedFoos[name] = { version, property: name, doesntExist: true };
+                }
+                else if (!foo) {
+                    computedFoos[name] = carriedFoos[name];
+                }
+                else {
+                    carriedFoos[name] = foo;
+                    computedFoos[name] = foo;
+                }
+            }
+        }
+    }
+    Configurer.PropagatePropertyCacheForwardInVersions = PropagatePropertyCacheForwardInVersions;
+    function PropagateMissingPropertiesBackwardInVersions(repl, computedPropDefs, computedFooDefs) {
+        // Go backwards through the versions and remember all migrations or deletions. Then apply them
+        // to the earlier versions.
+        let carriedProps = {};
+        let carriedFoos = {};
+        let carriedPropNames = {};
+        let carriedFooNames = {};
+        let versions = GetAllVersions().toReversed();
+        for (let version of versions) {
+            let props = computedPropDefs.get(version);
+            for (let name of repl.finalised_propertyNames) {
+                let prop = props[name];
+                if ("doesntExist" in prop) {
+                    continue;
+                }
+                if (carriedProps[name] && "removed" in carriedProps[name]) {
+                    //TODO: Update to allow for double-migrations.
+                    prop = props[name] = carriedProps[name];
+                }
+                if (carriedPropNames[prop.dataName]) {
+                    prop = props[name] = Object.assign(Object.assign({}, prop), { property: carriedPropNames[prop.dataName] });
+                }
+                if ("removed" in prop) {
+                    carriedProps[name] = prop;
+                }
+                else {
+                    carriedPropNames[prop.dataName] = name;
+                }
+            }
+            //Functions
+            let foos = computedFooDefs.get(version);
+            for (let name of repl.finalised_functionNames) {
+                let foo = foos[name];
+                if ("doesntExist" in foo) {
+                    continue;
+                }
+                if (carriedFoos[name] && "removed" in carriedFoos[name]) {
+                    foo = foos[name] = carriedProps[name];
+                }
+                if (carriedFooNames[foo.dataName]) {
+                    foo = foos[name] = Object.assign(Object.assign({}, foo), { property: carriedFooNames[foo.dataName] });
+                }
+                if ("removed" in foo) {
+                    carriedFoos[name] = foo;
+                }
+                else {
+                    carriedFooNames[foo.dataName] = name;
+                }
+            }
+        }
+    }
+    Configurer.PropagateMissingPropertiesBackwardInVersions = PropagateMissingPropertiesBackwardInVersions;
+    function ComputeDefinitionModifiers(prop, typeDef) {
+        let key = undefined;
+        let modifiers = PropertyTypes.AsIs;
+        if ("array" in typeDef && typeDef.array == 2) {
+            modifiers |= PropertyTypes.Array2;
+        }
+        else if ("array" in typeDef && typeDef.array) {
+            modifiers |= PropertyTypes.Array;
+        }
+        else if ("mapKey" in typeDef) {
+            modifiers |= PropertyTypes.Map;
+            key = typeDef.mapKey;
+        }
+        else if ("dictKey" in typeDef) {
+            modifiers |= PropertyTypes.Dictionary;
+            key = typeDef.dictKey;
+        }
+        else {
+            modifiers |= PropertyTypes.Solo;
+        }
+        if (typeDef.data) {
+            modifiers |= PropertyTypes.Definition;
+        }
+        if (typeDef.serialised) {
+            modifiers |= PropertyTypes.Serialised;
+        }
+        if (prop.expression !== false) {
+            modifiers |= PropertyTypes.Expression;
+        }
+        return [modifiers, key];
+    }
+    function ComputeSerialisationModifiers(prop, typeDef) {
+        let modifiers = PropertyTypes.AsIs;
+        let key = undefined;
+        if ("array" in typeDef && typeDef.array == 2) {
+            modifiers |= PropertyTypes.Array2;
+        }
+        else if ("array" in typeDef && typeDef.array) {
+            modifiers |= PropertyTypes.Array;
+        }
+        else if ("mapKey" in typeDef) {
+            modifiers |= PropertyTypes.Map;
+            key = typeDef.mapKey;
+        }
+        else if ("dictKey" in typeDef) {
+            modifiers |= PropertyTypes.Dictionary;
+            key = typeDef.dictKey;
+        }
+        else {
+            modifiers |= PropertyTypes.Solo;
+        }
+        if (typeDef.data) {
+            modifiers |= PropertyTypes.Definition;
+        }
+        if (typeDef.serialised) {
+            modifiers |= PropertyTypes.Serialised;
+        }
+        if (prop.expression !== false) {
+            modifiers |= PropertyTypes.Expression;
+        }
+        if (prop.inline) {
+            modifiers |= PropertyTypes.ForceInline;
+        }
+        return [modifiers, key];
+    }
+    function ComputePropertyDefinitionConfiguration(prop) {
+        var _a;
+        let loadTypes = [];
+        let loadModifiers = PropertyTypes.AsIs;
+        let propAllowsUndefined = false;
+        let dataTypes = (_a = prop.customDataType) !== null && _a !== void 0 ? _a : prop.type;
+        for (let i = 0; i < dataTypes.length; i++) {
+            let typeDef = dataTypes[i];
+            let [modifiers, key] = ComputeDefinitionModifiers(prop, typeDef);
+            loadModifiers |= PropertyTypes.ModOnly(modifiers);
+            let result;
+            if (typeDef.type.length === 1 && typeof typeDef.type[0] == "string" && !ReplicableRegistry.GetTypesForName(typeDef.type[0])) {
+                result = typeDef.type[0];
+            }
+            else {
+                result = [];
+                for (let repl of typeDef.type) {
+                    if (loadModifiers === PropertyTypes.Solo && typeDef.type === undefined) {
+                        propAllowsUndefined = true;
+                    }
+                    let types = isPrimitiveType(repl) ? [repl] : ReplicableRegistry.__GetReplicablesFor(repl);
+                    result.push(...types);
+                }
+                result.sort((a, b) => {
+                    return GetTypeName(a) > GetTypeName(b) ? 1 : -1;
+                });
+            }
+            let namesForValues = (Array.isArray(result)
+                ? result.map((e) => e instanceof ReplicableClass
+                    ? e.opts.dataTypeName : primitiveTypeName(e)) : [result]).sort();
+            loadTypes.push(Object.assign(Object.assign({ types: result, sortIndex: namesForValues.join(", "), modifiers }, (key ? { keyType: Array.isArray(key) ? key : [key] } : {})), ("restrictedTo" in typeDef ? { restrictedTo: typeDef.restrictedTo } : {})));
+        }
+        return [loadTypes, loadModifiers, propAllowsUndefined];
+    }
+    Configurer.ComputePropertyDefinitionConfiguration = ComputePropertyDefinitionConfiguration;
+    function ComputePropertySerialisedConfiguration(prop, loadPresence, propAllowsUndefined) {
+        let serTypes = [];
+        let serModifiers = PropertyTypes.AsIs;
+        //If the property is optional, add undefined to the list of allowed serialised types.
+        if (loadPresence === "optional") {
+            serTypes.push({
+                types: [undefined],
+                sortIndex: "undefined",
+                modifiers: prop.expression != false ? PropertyTypes.Solo | PropertyTypes.Expression : PropertyTypes.Solo
+            });
+            serModifiers |= PropertyTypes.Solo;
+        }
+        for (let i = 0; i < prop.type.length; i++) {
+            let typeDef = prop.type[i];
+            let [modifiers, key] = ComputeSerialisationModifiers(prop, typeDef);
+            serModifiers |= PropertyTypes.ModOnly(modifiers);
+            let result = [];
+            for (let repl of typeDef.type) {
+                if (serModifiers === PropertyTypes.Solo && typeDef.type === undefined) {
+                    propAllowsUndefined = true;
+                }
+                let types = isPrimitiveType(repl) ? [repl] : ReplicableRegistry.__GetReplicablesFor(repl);
+                result.push(...types);
+            }
+            result.sort((a, b) => {
+                return GetTypeName(a) > GetTypeName(b) ? 1 : -1;
+            });
+            let namesForValues = (result.map((e) => e instanceof ReplicableClass
+                ? e.opts.dataTypeName : primitiveTypeName(e))).sort();
+            serTypes.push(Object.assign(Object.assign({ types: result, sortIndex: namesForValues.join(", "), modifiers }, (key ? { keyType: Array.isArray(key) ? key : [key] } : {})), ("restrictedTo" in typeDef ? { restrictedTo: typeDef.restrictedTo } : {})));
+        }
+        return [serTypes, serModifiers, propAllowsUndefined];
+    }
+    Configurer.ComputePropertySerialisedConfiguration = ComputePropertySerialisedConfiguration;
+    function ComputePropertyExpressionConfiguration(repl, prop, loadModifiers, loadTypes) {
+        let exprPropertyConf = undefined;
+        let exprValueConf = undefined;
+        let exprKeyConf = undefined;
+        if (prop.expression !== false) {
+            let conf = {};
+            let conf2 = {};
+            let conf3 = {};
+            for (let version of GetAllVersions()) {
+                conf[version] = Utils.ExpressionUtils.MakePropExpressionConfig(version, prop, repl.classConstructor);
+                conf2[version] = Object.assign({}, conf[version]);
+                conf2[version].outputMap = false;
+                conf2[version].outputArray = 0;
+                conf2[version].outputDict = false;
+                conf3[version] = Object.assign(Object.assign({}, conf2[version]), { outputTypes: ["any"] });
+            }
+            exprPropertyConf = conf;
+            exprValueConf = conf2;
+            if (PropertyTypes.isType(loadModifiers, PropertyTypes.Map) && loadTypes.some((e) => { var _a; return (_a = e.keyType) === null || _a === void 0 ? void 0 : _a.includes(Expression); })) {
+                exprKeyConf = conf3;
+            }
+        }
+        return [exprPropertyConf, exprValueConf, exprKeyConf];
+    }
+    Configurer.ComputePropertyExpressionConfiguration = ComputePropertyExpressionConfiguration;
+    function ComputePropertyConfigurationsInVersion(repl, version, computedPropDefs) {
+        var _a;
+        let props = computedPropDefs.get(version);
+        let finalisedProps = {};
+        repl.finalised_properties.set(version, finalisedProps);
+        let propAllowsUndefined = false;
+        for (let name of repl.finalised_propertyNames) {
+            let prop = props[name];
+            if ("doesntExist" in prop || "removed" in prop) {
+                finalisedProps[name] = prop;
+                repl.rule.addProperty(version, prop);
+                continue;
+            }
+            let loadPresence = prop.optional || ("default" in prop) || propAllowsUndefined ? "optional" : prop.computed == "manualLoad" ? true : !prop.computed;
+            let [loadTypes, loadModifiers, defAllowsUndefined] = ComputePropertyDefinitionConfiguration(prop);
+            propAllowsUndefined || (propAllowsUndefined = defAllowsUndefined);
+            let [serTypes, serModifiers, serAllowsUndefined] = ComputePropertySerialisedConfiguration(prop, loadPresence, propAllowsUndefined);
+            propAllowsUndefined || (propAllowsUndefined = serAllowsUndefined);
+            let [exprPropertyConf, exprValueConf, exprKeyConf] = ComputePropertyExpressionConfiguration(repl, prop, loadModifiers, loadTypes);
+            let def = finalisedProps[name] = {
+                name: name,
+                load: {
+                    //If property is computed, if it has a default value it's actually optional.
+                    present: loadPresence,
+                    skipLoad: prop.computed == "manualLoad",
+                    name: (_a = prop.dataName) !== null && _a !== void 0 ? _a : generateDataName(name),
+                    default: prop.default,
+                    possibleModifiers: loadModifiers,
+                    types: loadTypes.sort((a, b) => a.sortIndex > b.sortIndex ? 1 : -1)
+                },
+                serialisation: {
+                    present: prop.manualRestore ? "writeOnly" : !prop.readonly,
+                    inline: prop.inline,
+                    types: serTypes.sort((a, b) => a.sortIndex > b.sortIndex ? 1 : -1),
+                    possibleModifiers: serModifiers
+                },
+                expressionForProperty: exprPropertyConf,
+                expressionForValue: exprValueConf,
+                expressionForKey: exprKeyConf
+            };
+            repl.rule.addProperty(version, def);
+            //TODO: Run definitions check to see if default is a valid value for property.
+        }
+    }
+    Configurer.ComputePropertyConfigurationsInVersion = ComputePropertyConfigurationsInVersion;
+    function ComputeFunctionExpressionConfiguration(repl, version, computedFooDefs) {
+        let foos = computedFooDefs.get(version);
+        let finalisedFoos = {};
+        repl.finalised_functions.set(version, finalisedFoos);
+        for (let name of repl.finalised_functionNames) {
+            let foo = foos[name];
+            if ("doesntExist" in foo || "removed" in foo) {
+                continue;
+            }
+            repl.rule.addFunction(version, { name: foo.funcName, exprName: foo.dataName }, foo.outputType, foo.parameters);
+        }
+    }
+    Configurer.ComputeFunctionExpressionConfiguration = ComputeFunctionExpressionConfiguration;
+    function CacheClassProperties(repl) {
+        let propDefs = new Map();
+        let fooDefs = new Map();
+        // Grab all the properties from the parents and create a flat map for them.
+        RecursivelyCacheParentProperties(repl, repl, propDefs, fooDefs);
+        CacheOwnProperties(repl, propDefs, fooDefs);
+        let computedPropDefs = new Map();
+        let computedFooDefs = new Map();
+        PropagatePropertyCacheForwardInVersions(repl, propDefs, fooDefs, computedPropDefs, computedFooDefs);
+        PropagateMissingPropertiesBackwardInVersions(repl, computedPropDefs, computedFooDefs);
+        let versions = GetAllVersions();
+        for (let version of versions) {
+            ComputePropertyConfigurationsInVersion(repl, version, computedPropDefs);
+            ComputeFunctionExpressionConfiguration(repl, version, computedFooDefs);
+        }
+    }
+    Configurer.CacheClassProperties = CacheClassProperties;
+})(Configurer || (Configurer = {}));

package/Transformers/Constructor.d.ts

@@ -0,0 +1,12 @@
+import { SourceMap } from "../Constants/SourceMaps.js";
+import { ReplicableClass } from "../Tracking/Class.js";
+import type { Loader } from "./Loader.js";
+import type { Serialiser } from "./Serialiser.js";
+export declare namespace __PrivateConstructorSetup {
+    function RegisterDeserialiser(deserialiser: typeof Serialiser.Deserialise): void;
+    function RegisterInitialiser(initialiser: typeof Loader.InitFromData): void;
+    function RegisterHasBeenInitialised(initCheck: typeof Loader.HasObjectBeenInitialised): void;
+}
+export declare namespace Constructor {
+    function Construct(type: ReplicableClass, source: SourceMap, owner?: any, args?: any): any;
+}

package/Transformers/Constructor.js

@@ -0,0 +1,44 @@
+import { describeObject } from "../Constants/SerialisationTypes.js";
+let Deserialise;
+let InitFromData;
+let HasObjectBeenInitialised;
+export var __PrivateConstructorSetup;
+(function (__PrivateConstructorSetup) {
+    function RegisterDeserialiser(deserialiser) {
+        Deserialise = deserialiser;
+    }
+    __PrivateConstructorSetup.RegisterDeserialiser = RegisterDeserialiser;
+    function RegisterInitialiser(initialiser) {
+        InitFromData = initialiser;
+    }
+    __PrivateConstructorSetup.RegisterInitialiser = RegisterInitialiser;
+    function RegisterHasBeenInitialised(initCheck) {
+        HasObjectBeenInitialised = initCheck;
+    }
+    __PrivateConstructorSetup.RegisterHasBeenInitialised = RegisterHasBeenInitialised;
+})(__PrivateConstructorSetup || (__PrivateConstructorSetup = {}));
+export var Constructor;
+(function (Constructor) {
+    function Construct(type, source, owner, args) {
+        let result;
+        if ("Create" in type.classConstructor) {
+            result = type.classConstructor.Create({ data: args, source, owner });
+        }
+        else if ("Reference" in type.classConstructor) {
+            throw new Error(`Cannot construct ${type.opts.typescriptTypeName} for ${describeObject(owner)} because ${type.opts.typescriptTypeName} doesn't specify a static Create function.`);
+        }
+        else {
+            result = new type.classConstructor({ data: args, source, owner });
+        }
+        if (!HasObjectBeenInitialised(result)) {
+            if (Array.isArray(args) && args[0] === type.opts.dataTypeName && args.length == 2) {
+                return Deserialise(result, args);
+            }
+            else {
+                return InitFromData(type, source, result, args);
+            }
+        }
+        return result;
+    }
+    Constructor.Construct = Construct;
+})(Constructor || (Constructor = {}));

package/Transformers/Definitions.d.ts

@@ -0,0 +1,102 @@
+import { SourceMap } from "../Constants/SourceMaps.js";
+import { Expression } from "../Expressions/Expression.js";
+import { PropertyTypes } from "../Constants/SerialisationTypes.js";
+import { ErrorStack } from "../Constants/Errors.js";
+import { EvaluationChain } from "../Expressions/EvaluatorChain.js";
+import { EvaluationString } from "../Expressions/EvaluatorString.js";
+import { ExpressionConfiguration } from "../Expressions/EvaluatorSteps.js";
+import { Versions } from "../Main.js";
+import { ReplicableClass } from "../Tracking/Class.js";
+import { PropertyConfiguration, PropertyLoadingTypeInfo } from "../Tracking/Property.js";
+export declare namespace Definitions {
+    /**
+     * Determines if the expression results matches the modifiers for the given property definition.
+     *  Modifiers include array, map, dictionary and optional.
+     * @param errorContext The context to add to the error message, should be ClassName.PropertyName.
+     * @param def The property definition to check against.
+     * @param val The value to check.
+     * @param errorStack The error stack to add errors to.
+     */
+    function DoExprOutputsMatchPropertyModifier(errorContext: string, def: ExpressionConfiguration, val: Expression | EvaluationChain | EvaluationString, errorStack: ErrorStack): boolean;
+    /**
+     * Determines if the expression results match the types for the given property definition, ignores modifiers
+     * like array, map and dictionary.
+     * @param errorContext The context to add to the error message, should be ClassName.PropertyName.
+     * @param def The property definition to check against.
+     * @param propVal The value to check.
+     * @param errorStack The error stack to add errors to.
+     * @constructor
+     */
+    function DoExprOutputsMatchPropertyType(errorContext: string, def: ExpressionConfiguration, propVal: Expression | EvaluationChain | EvaluationString, errorStack: ErrorStack): boolean;
+    /**
+     * Determines if value matches the modifiers for the given property definition.
+     *  Modifiers include array, map, dictionary and optional.
+     *  Also checks map index requirements.
+     * @param def The property definition to check against.
+     * @param val The value to check. DOES NOT SUPPORT EXPRESSIONS.
+     * @param errorStack The error stack to add errors to.
+     */
+    function DoesValMatchPropertyModifier(def: PropertyLoadingTypeInfo, val: any): boolean;
+    /**
+     * ASSUMES INPUTS ARE CORRECT - DOES NOT CHECK FOR ERRORS.
+     * Get all of the assigned property values, so that they can individually be checked against the type requirements
+     *  of the definiton. Turns single values, double arrays, maps and dicts all into a single flat array of values.
+     * @param def The property definition to get the values for.
+     * @param val The value to get the values from.
+     */
+    function GetPropValuesFromData(def: PropertyConfiguration, val: any): [any[], PropertyTypes];
+    /**
+     * ASSUMES INPUTS ARE CORRECT - DOES NOT CHECK FOR ERRORS.
+     * Runs a function on every value, setting the value to the results of the function.
+     * @param def The property definition to get the values for.
+     * @param val The value to get the values from.
+     * @param cb The function to run on every value.
+     */
+    function MapEveryPropValue(def: PropertyConfiguration, val: any, cb: (val: any) => any): any;
+    /**
+     * Check if the given value is assignable to the given class.
+     * @param type The type to check against.
+     * @param val The value to check.
+     * @param errorStack The error stack to add errors to.
+     * @param skipCustomOverride allows us to skip the class specific "DataIsType" function and use the default checks
+     *     instead. This should mostly be used by the class itself when checking its own properties.
+     */
+    function DoesDataClassMatchRepl(version: Versions | string, type: ReplicableClass, val: any, errorStack: ErrorStack, skipCustomOverride?: boolean): null | ReplicableClass;
+    /**
+     * Check if the given expression matches the property definition.
+     * @param errorContext The context to add to the error message, should be ClassName.PropertyName.
+     * @param conf The expression configuration to check against.
+     * @param propVal The value to check.
+     * @param errorStack The error stack to add errors to.
+     * @param instanceOnly If true, will check the expression to match a single value of the property,
+     *  	rather than an array or a map.
+     */
+    function DoesExpressionMatchProperty(errorContext: string, conf: ExpressionConfiguration | undefined, propVal: any, errorStack: ErrorStack, instanceOnly?: boolean): boolean;
+    /**
+     * Check if the given data is loadable for this ReplicableClass.
+     * @param type The type to check against.
+     * @param val The data to check.
+     * @param source The source file that the data comes from.
+     * @param errorStack The error stack to add errors to.
+     * @param skipCustomOverride If true, will skip the class' "DataIsType" function and use the default checks instead.
+     */
+    function IsLoadableDataForRepl(type: ReplicableClass, val: any, version: Versions | string, errorStack: ErrorStack, skipCustomOverride?: boolean): any;
+    /**
+     * Check if the given value is loadable for the given type.
+     * @param type The repl class or primitive type to check against.
+     * @param val The value to check.
+     * @param version The version to check against.
+     * @param errorStack The error stack to add errors to.
+     * @param skipCustomOverride If true, will skip the class' "DataIsType" function and use the default checks instead.
+     */
+    function IsLoadableDataForType(type: any, val: any, version: Versions | string, errorStack: ErrorStack, skipCustomOverride?: boolean): boolean;
+    /**
+     * Setup and cache parsed expressions so that they don't have to be re-parsed every time an object is created with
+     * type data.
+     * Perform property migration for removed properties.
+     * @param rawType The type to setup expressions for.
+     * @param data
+     * @param source
+     */
+    function PrePrepareData(rawType: any, data: any, source: SourceMap, expressionStartOverride?: string): any;
+}