@bikky/replication 1.0.1

package/Transformers/Definitions.js

@@ -0,0 +1,626 @@
+import { Expression } from "../Expressions/Expression.js";
+import { ReplicableRegistry } from "../Constants/ReplicableRegistry.js";
+import { DataSymbol, describeObject, isPrimitiveType, isPrimitiveValue, PropertyTypes, TypeSymbol, ValueIsPrimitiveType } from "../Constants/SerialisationTypes.js";
+import { ErrorStack } from "../Constants/Errors.js";
+import { Utils } from "./Utils.js";
+import { Pointer } from "./Reference.js";
+import { MinVersion } from "../Constants/Versions.js";
+import { ReplicableClass } from "../Tracking/Class.js";
+import { __ReplTypeHelperFunctions } from "../Expressions/TypeRegistry/ReplAPI.js";
+export var Definitions;
+(function (Definitions) {
+    var isExpressionKind = Expression.isExpressionKind;
+    function ProducePropertyError(errorStack, errorContext, expected, got) {
+        let expectedString;
+        if (typeof expected === "string") {
+            expectedString = expected;
+        }
+        else if ("load" in expected) {
+            expectedString = Utils.PrintUtils.CategoryVisualModifierAid(expected.load.possibleModifiers);
+            let multi = expected.load.types.length > 1;
+            let types = (expected.load.types)
+                .flatMap((e) => {
+                var _a;
+                let vals = e.types;
+                if (typeof vals === "string") {
+                    vals = (_a = [ReplicableRegistry.__GetReplicableForDataName(vals)]) !== null && _a !== void 0 ? _a : vals;
+                    if (typeof vals === "string") {
+                        return vals;
+                    }
+                }
+                return vals.map((currentVal) => {
+                    let stringName = Utils.PrintUtils.ReplPrimOrRawToName(currentVal);
+                    if (stringName.includes("|"))
+                        multi = true;
+                    return stringName;
+                });
+            });
+            if (multi) {
+                expectedString = expectedString.replace("1", "(" + types.join(" | ") + ")");
+            }
+            else {
+                expectedString = expectedString.replace("1", types.join(" | "));
+            }
+        }
+        else {
+            expectedString = Utils.PrintUtils.ConfigVisualModifierAid(expected);
+            let types = expected.outputTypes.flatMap((e) => typeof e === "string" ? ReplicableRegistry.__GetReplicableForDataName(e) : e);
+            if (types.length > 1) {
+                expectedString = expectedString.replace("1", "(" + types.map((e) => Utils.PrintUtils.ReplPrimOrRawToName(e)).join(" | ") + ")");
+            }
+            else {
+                expectedString = expectedString.replace("1", Utils.PrintUtils.ReplPrimOrRawToName(types[0]));
+            }
+        }
+        let gotString = "value" in got ? Utils.PrintUtils.ValVisualAidBestGuess(got.value) : got.aid;
+        errorStack.add("REP_TD001", `${errorContext} expects ${expectedString} but got a ${gotString}.`);
+    }
+    function ProducePropertyExpressionError(errorStack, errorContext, expected, got) {
+        let expectedString = typeof expected === "string" ? expected : Utils.PrintUtils.ConfigVisualModifierAid(expected);
+        if (typeof expected !== "string") {
+            let expectedTypes = expected.outputTypes.flatMap((e) => typeof e === "string" ? ReplicableRegistry.__GetReplicableForDataName(e) : e);
+            if (expectedTypes.length == 1) {
+                expectedString = expectedString.replace("1", Utils.PrintUtils.ReplPrimOrRawToName(expectedTypes[0]));
+            }
+            else {
+                expectedString = expectedString.replace("1", "(" + expectedTypes.map((e) => Utils.PrintUtils.ReplPrimOrRawToName(e)).join(" | ")) + ")";
+            }
+        }
+        let gotString = Utils.PrintUtils.ConfigVisualModifierAid(got.config);
+        let gotTypes = got.config.outputTypes.flatMap((e) => typeof e === "string" ? ReplicableRegistry.__GetReplicableForDataName(e) : e);
+        if (gotTypes.length == 1) {
+            gotString = gotString.replace("1", Utils.PrintUtils.ReplPrimOrRawToName(gotTypes[0]));
+        }
+        else {
+            gotString = gotString.replace("1", "(" + gotTypes.map((e) => Utils.PrintUtils.ReplPrimOrRawToName(e)).join(" | ")) + ")";
+        }
+        errorStack.add("REP_TD002", `${errorContext} expects ${expectedString} but Expression produces ${gotString}. Expression is ${got.rawText}.`);
+    }
+    /**
+     * 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, def, val, errorStack) {
+        if (val instanceof Expression)
+            val = val.expression;
+        let defStyle = Utils.PrintUtils.ConfigVisualModifierAid(def);
+        let valStyle = Utils.PrintUtils.ConfigVisualModifierAid(val.config);
+        if (defStyle !== valStyle) {
+            ProducePropertyExpressionError(errorStack, errorContext, def, val);
+            return false;
+        }
+        return true;
+    }
+    Definitions.DoExprOutputsMatchPropertyModifier = DoExprOutputsMatchPropertyModifier;
+    /**
+     * 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, def, propVal, errorStack) {
+        if (propVal instanceof Expression)
+            propVal = propVal.expression;
+        let outputTypes = def.outputTypes.flatMap((e) => typeof e === "string" ? ReplicableRegistry.GetTypesForName(e) : e);
+        outputTypes = outputTypes.map((e) => e instanceof ReplicableClass ? e.classConstructor : e);
+        if (!propVal.outputTypes.every((t) => outputTypes.some((e) => e == t))) {
+            ProducePropertyExpressionError(errorStack, errorContext, def, propVal);
+            return false;
+        }
+        return true;
+    }
+    Definitions.DoExprOutputsMatchPropertyType = DoExprOutputsMatchPropertyType;
+    /**
+     * 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, val) {
+        let modifiers = PropertyTypes.ModOnly(def.modifiers);
+        let succeeded = true;
+        switch (modifiers) {
+            case PropertyTypes.Solo: {
+                // Everything matches!
+                // Can't do a strict check on this because some classes might have special conditions for
+                // what is a valid value, including arrays and objects without "Class" in them.
+                succeeded = true;
+                break;
+            }
+            case PropertyTypes.Array: {
+                succeeded = Array.isArray(val);
+                break;
+            }
+            case PropertyTypes.Array2: {
+                succeeded = Array.isArray(val) && val.every((e) => Array.isArray(e));
+                break;
+            }
+            case PropertyTypes.Map:
+                if (val instanceof Map) {
+                    succeeded = true;
+                    break;
+                }
+            //Fall through
+            case PropertyTypes.Dictionary: {
+                succeeded = typeof val === "object" && val.__proto__ === Object.prototype;
+                break;
+            }
+        }
+        return succeeded;
+    }
+    Definitions.DoesValMatchPropertyModifier = DoesValMatchPropertyModifier;
+    /**
+     * 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, val) {
+        let result = [];
+        let type;
+        if (PropertyTypes.isType(def.load.possibleModifiers, PropertyTypes.Array2) && Array.isArray(val) && (val.length == 0 || Array.isArray(val[0]))) {
+            type = PropertyTypes.Array2;
+            result = val.flat(2);
+        }
+        else if (PropertyTypes.isType(def.load.possibleModifiers, PropertyTypes.Array) && Array.isArray(val)) {
+            type = PropertyTypes.Array;
+            result = [...val];
+        }
+        else if (PropertyTypes.isType(def.load.possibleModifiers, PropertyTypes.Map) && val instanceof Map) {
+            type = PropertyTypes.Map;
+            result = [...val.values()];
+        }
+        else if (PropertyTypes.isTypeOr(def.load.possibleModifiers, PropertyTypes.Dictionary, PropertyTypes.Map) && typeof val === "object" && val.__proto__ === Object.prototype) {
+            type = PropertyTypes.Dictionary | PropertyTypes.Map;
+            result = Object.values(val);
+        }
+        else if (PropertyTypes.isType(def.load.possibleModifiers, PropertyTypes.Solo)) {
+            type = PropertyTypes.Solo;
+            result = [val];
+        }
+        if (type === undefined) {
+            throw new Error(`Property ${def.load.name} has no valid type for the value ${describeObject(val)}.`);
+        }
+        return [result.map((e) => e instanceof Pointer ? e.val : e), type];
+    }
+    Definitions.GetPropValuesFromData = GetPropValuesFromData;
+    /**
+     * 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, val, cb) {
+        if (PropertyTypes.isType(def.load.possibleModifiers, PropertyTypes.Array2) && Array.isArray(val) && (val.length == 0 || Array.isArray(val[0]))) {
+            for (let i = 0; i < val.length; i++) {
+                for (let j = 0; j < val[i].length; j++) {
+                    val[i][j] = cb(val[i][j]);
+                }
+            }
+        }
+        else if (PropertyTypes.isType(def.load.possibleModifiers, PropertyTypes.Array) && Array.isArray(val)) {
+            for (let i = 0; i < val.length; i++) {
+                val[i] = cb(val[i]);
+            }
+        }
+        else if (PropertyTypes.isType(def.load.possibleModifiers, PropertyTypes.Map) && val instanceof Map) {
+            for (let k of val.keys()) {
+                let v = val.get(k);
+                val.set(k, cb(v));
+            }
+        }
+        else if (PropertyTypes.isTypeOr(def.load.possibleModifiers, PropertyTypes.Dictionary, PropertyTypes.Map) && typeof val === "object" && val.__proto__ === Object.prototype) {
+            for (let v in val) {
+                val[v] = cb(val[v]);
+            }
+        }
+        else if (PropertyTypes.isType(def.load.possibleModifiers, PropertyTypes.Solo)) {
+            val = cb(val);
+        }
+        return val;
+    }
+    Definitions.MapEveryPropValue = MapEveryPropValue;
+    /**
+     * 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, type, val, errorStack, skipCustomOverride = false) {
+        if (!skipCustomOverride && "DataIsType" in type.classConstructor) {
+            return type.classConstructor.DataIsType(version, val, errorStack) ? type : null;
+        }
+        if (isPrimitiveValue(val)) {
+            return null;
+        }
+        if (val[TypeSymbol]) {
+            if ((val[TypeSymbol] === type || type.isChildTypeOfThisType(val[TypeSymbol]))) {
+                return val[TypeSymbol];
+            }
+            else {
+                errorStack.add("REP_TD003", `Data is of type ${val[TypeSymbol].opts.dataTypeName} which is not assignable to ${type.opts.dataTypeName}.`);
+                return null;
+            }
+        }
+        if (!("Class" in val)) {
+            errorStack.add("REP_TD004", `Data is missing a "Class" property.`);
+            return null;
+        }
+        let specificType = ReplicableRegistry.GetTypeForDataName(val.Class);
+        //If value thinks it's of type Class, but type Class doesn't exist, that's an error.
+        if (!specificType) {
+            errorStack.add("REP_TD005", `Data claims to be of type ${val.Class} but no such type exists.`);
+            return null;
+        }
+        //If value thinks it's of type Class, but Class isn't assignable to type, then miss-match.
+        if (type !== specificType && !type.isChildTypeOfThisType(specificType)) {
+            let aliases = ReplicableRegistry.__GetReplicablesFor(type.classConstructor);
+            if (aliases) {
+                let valids = aliases.filter((e) => e === specificType || (e instanceof ReplicableClass && e.isChildTypeOfThisType(specificType)));
+                if (valids.length > 0) {
+                    //TODO: Handle Primitive returns?
+                    return valids[0];
+                }
+            }
+            errorStack.add("REP_TD006", `Data claims to be of type ${specificType.opts.dataTypeName} which is not assignable to ${type.opts.dataTypeName}.`);
+            return null;
+        }
+        return specificType;
+    }
+    Definitions.DoesDataClassMatchRepl = DoesDataClassMatchRepl;
+    /**
+     * 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, conf, propVal, errorStack, instanceOnly = false) {
+        if (!conf) {
+            errorStack.add("REP_TD007", `${errorContext} does not allow for expressions.`);
+            return false;
+        }
+        if (instanceOnly) {
+            conf = Object.assign(Object.assign({}, conf), { outputArray: 0, outputDict: false, outputMap: false });
+        }
+        if (!DoExprOutputsMatchPropertyModifier(errorContext, conf, propVal, errorStack)) {
+            return false;
+        }
+        return DoExprOutputsMatchPropertyType(errorContext, conf, propVal, errorStack);
+    }
+    Definitions.DoesExpressionMatchProperty = DoesExpressionMatchProperty;
+    /**
+     * 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, val, version, errorStack, skipCustomOverride = false) {
+        if (typeof val === "object" && val !== null) {
+            if (val[DataSymbol] && val[DataSymbol] instanceof ReplicableClass) {
+                let result = type.isChildTypeOfThisType(val[DataSymbol]);
+                if (!result) {
+                    errorStack.add("REP_TD008", `Data is of type ${val[DataSymbol].opts.dataTypeName} which is not assignable to ${type.opts.dataTypeName}.`);
+                }
+                return result;
+            }
+            if (val[TypeSymbol]) {
+                let result = type.isChildTypeOfThisType(val[TypeSymbol]);
+                if (!result) {
+                    errorStack.add("REP_TD009", `Data is of type ${val[TypeSymbol].opts.dataTypeName} which is not assignable to ${type.opts.dataTypeName}.`);
+                }
+                return result;
+            }
+        }
+        let subStack = new ErrorStack(errorStack.source);
+        if (isPrimitiveValue(val)) {
+            if (skipCustomOverride) {
+                errorStack.add("REP_TD010", `Data is a primitive value (${describeObject(val)}), and is not a valid value for ${type.opts.dataTypeName}.`);
+                return false;
+            }
+            if ("DataIsType" in type.classConstructor) {
+                return type.classConstructor.DataIsType(version, val, errorStack);
+            }
+            errorStack.add("REP_TD011", `Data is a primitive value (${describeObject(val)}), and is not a valid value for ${type.opts.dataTypeName}.`);
+            return false;
+        }
+        if ("DataIsType" in type.classConstructor && !skipCustomOverride) {
+            if (typeof val === "object" && val.__proto__ == Object.prototype) {
+                val[DataSymbol] = type;
+            }
+            return type.classConstructor.DataIsType(version, val, errorStack);
+        }
+        let repl = DoesDataClassMatchRepl(version, type, val, subStack, skipCustomOverride);
+        if (!repl) {
+            errorStack.appendAndIndent(subStack);
+            errorStack.add("REP_TD012", `Error parsing data. Data ${type.getIDAsString(val, true)} is not assignable to class ${type.opts.typescriptTypeName}, see above errors for details.`);
+            return false;
+        }
+        let classStack = new ErrorStack(errorStack.source);
+        let optionalClassErrors = new ErrorStack(errorStack.source);
+        let props = type.finalised_properties.get(type.opts.version);
+        // eslint-disable-next-line @typescript-eslint/naming-convention
+        iterateProperties: for (let name of type.finalised_propertyNames) {
+            let propInfo = props[name];
+            if ("removed" in propInfo || "doesntExist" in propInfo) {
+                continue;
+            }
+            if (!propInfo.load.present || propInfo.load.skipLoad) {
+                continue;
+            }
+            if (propInfo.load.present == "optional" && typeof val[propInfo.load.name] === "undefined") {
+                continue;
+            }
+            //If the needed variable is not present...
+            if (!(propInfo.load.name in val)) {
+                classStack.add("REP_TD013", `${type.opts.typescriptTypeName}.${propInfo.load.name} is missing and is not optional.`);
+                continue;
+            }
+            let propVal = val[propInfo.load.name];
+            //There should be no expression strings as InitialiseData preps them all as EvaluationChains or
+            // EvaluationStrings.
+            if (Expression.isExpressionString(propVal)) {
+                if (!propInfo.expressionForProperty) {
+                    classStack.add("REP_TD014", `${type.opts.typescriptTypeName}.${propInfo.load.name} does not allow for expressions.`);
+                    continue;
+                }
+                else {
+                    throw new Error(`Data should be initialised before being verified, ${type.getIDAsString(val)} has not been initialised.`);
+                }
+            }
+            //Evaluate expressions to see if they're correct, if they are then skip everything after.
+            if (isExpressionKind(propVal)) {
+                DoesExpressionMatchProperty(`${repl.opts.dataTypeName}.${propInfo.load.name}`, propInfo.expressionForProperty[version], propVal, classStack);
+                continue;
+            }
+            //Only keep values that match the modifiers we have. So if we have a dict or map we don't care about
+            // matching the values of an array.
+            let validTypes = propInfo.load.types.filter((e) => DoesValMatchPropertyModifier(e, propVal));
+            if (validTypes.length == 0) {
+                let subStack = new ErrorStack(errorStack.source);
+                ProducePropertyError(subStack, `${type.opts.dataTypeName}.${propInfo.load.name}`, propInfo, { value: propVal });
+                classStack.appendWithoutIndent(subStack);
+                continue;
+            }
+            let [values, modifier] = GetPropValuesFromData(propInfo, propVal);
+            let propErrorStack = new ErrorStack(errorStack.source);
+            let valid = false;
+            //Most of the time this loop will only execute once.
+            //Must match one of the type groups.
+            iterateTypeGroup: for (let propTypeGroup of propInfo.load.types) {
+                if (!PropertyTypes.isType(propTypeGroup.modifiers, modifier)) {
+                    continue;
+                }
+                //If using a string definition, assume correct data since we can't actually verify it.
+                if (typeof propTypeGroup.types === "string") {
+                    break;
+                }
+                let subValid = true;
+                let primitives = propTypeGroup.types.filter((e) => isPrimitiveType(e));
+                let overrides = propTypeGroup.types.filter((e) => !isPrimitiveType(e) && ("DataIsType" in e.classConstructor));
+                let repls = propTypeGroup.types.filter((e) => !isPrimitiveType(e) && !("DataIsType" in e.classConstructor));
+                //Each value must match one of the types.
+                checkValues: for (let value of values) {
+                    //There should be no expression strings as InitialiseData preps them all as EvaluationChains or
+                    // EvaluationStrings.
+                    if (Expression.isExpressionString(value)) {
+                        if (!propInfo.expressionForValue) {
+                            propErrorStack.add("REP_TD015", `${type.opts.dataTypeName}.${propInfo.load.name} does not allow for expressions.`);
+                            subValid = false;
+                            //This value is invalid, report it and check the next one.
+                            continue checkValues;
+                        }
+                        else {
+                            throw new Error(`Data should be initialised before being verified, ${type.getIDAsString(val)} has not been initialised.`);
+                        }
+                    }
+                    //If this value matches one of the special class overrides for the valid types, then it's valid.
+                    //Otherwise we continue as normal.
+                    for (let def of overrides) {
+                        if (def.classConstructor.DataIsType(version, value, propErrorStack)) {
+                            //This value is valid, now check the next one.
+                            continue checkValues;
+                        }
+                    }
+                    if (isPrimitiveValue(value)) {
+                        if (!primitives.some((e) => ValueIsPrimitiveType(e, value))) {
+                            ProducePropertyError(propErrorStack, `${type.opts.typescriptTypeName}.${propInfo.load.name}`, propInfo, { value });
+                            subValid = false;
+                        }
+                        //This value has been validated, report the results and check the next one.
+                        continue checkValues;
+                    }
+                    if (isExpressionKind(value)) {
+                        if (!propInfo.expressionForValue) {
+                            propErrorStack.add("REP_TD017", `${type.opts.dataTypeName}.${propInfo.load.name} does not allow for expressions.`);
+                            subValid = false;
+                            //This value is invalid, report it and check the next one.
+                            continue checkValues;
+                        }
+                        let errStr = `${repl.opts.dataTypeName}.${propInfo.load.name}'s individual values`;
+                        if (!DoesExpressionMatchProperty(errStr, propInfo.expressionForValue[version], value, propErrorStack, true)) {
+                            subValid = false;
+                        }
+                        //This value has been validated, report the results and check the next one.
+                        continue checkValues;
+                    }
+                    if (value[TypeSymbol]) {
+                        if (!repls.some((e) => e instanceof ReplicableClass && e.isChildTypeOfThisType(value[TypeSymbol]))) {
+                            subValid = false;
+                            propErrorStack.add("REP_TD018", `Data is of type ${value[TypeSymbol].opts.dataTypeName} which is not assignable to ${type.opts.dataTypeName}.${propInfo.load.name}.`);
+                        }
+                        //This value is invalid, report it and check the next one.
+                        continue checkValues;
+                    }
+                    let subErrorStack = new ErrorStack(errorStack.source);
+                    if (!repls.some((e) => IsLoadableDataForRepl(e, value, version, subErrorStack))) {
+                        propErrorStack.appendAndIndent(subErrorStack);
+                        // let subInfo = {...propInfo, type: propInfo.type.map((e) => {return { type: e.type }})};
+                        ProducePropertyError(propErrorStack, `${type.opts.typescriptTypeName}.${propInfo.load.name}`, propInfo, { value: propVal });
+                        subValid = false;
+                        //This value has been validated, report the results and check the next one.
+                        continue checkValues;
+                    }
+                }
+                if (subValid) {
+                    valid = true;
+                    break;
+                }
+            }
+            //Only add the various errors to the stack if one of the values doesn't match any valid types.
+            if (!valid) {
+                classStack.appendWithoutIndent(propErrorStack);
+            }
+        }
+        if (optionalClassErrors.hasErrors()) {
+            errorStack.appendAndIndent(optionalClassErrors);
+        }
+        if (classStack.hasErrors()) {
+            errorStack.appendAndIndent(classStack);
+            errorStack.add("REP_TD019", `Failed to parse ${type.getIDAsString(val, true)} for class ${type.opts.typescriptTypeName}, see above errors for details.`);
+            return false;
+        }
+        if (errorStack.hasErrors()) {
+            errorStack.add("REP_TD020", `Warnings present when parsing ${type.getIDAsString(val, true)} for class ${type.opts.typescriptTypeName}, see above warnings for details.`);
+        }
+        val[DataSymbol] = type;
+        return true;
+    }
+    Definitions.IsLoadableDataForRepl = IsLoadableDataForRepl;
+    /**
+     * 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, val, version, errorStack, skipCustomOverride = false) {
+        if (isPrimitiveType(type)) {
+            let result = ValueIsPrimitiveType(type, val);
+            if (!result) {
+                errorStack.add("REP_TD021", `Tried to assign ${describeObject(val)} to ${describeObject(type)}.`);
+            }
+            return result;
+        }
+        if (!(type instanceof ReplicableClass)) {
+            let types = ReplicableRegistry.__GetReplOrPrimFor(type);
+            if (!types) {
+                throw new Error(`Type ${describeObject(type)} is not a valid type.`);
+            }
+            let stack = new ErrorStack(errorStack.source);
+            for (let type of types) {
+                if (isPrimitiveType(type)) {
+                    if (ValueIsPrimitiveType(type, val)) {
+                        return true;
+                    }
+                    stack.add("REP_TD022", `Tried to assign ${describeObject(val)} to ${describeObject(type)}.`);
+                    continue;
+                }
+                if (IsLoadableDataForRepl(type, val, version, stack, skipCustomOverride)) {
+                    return true;
+                }
+            }
+            errorStack.appendWithoutIndent(stack);
+            if (typeof val === "object" && "Class" in val) {
+            }
+            return false;
+        }
+        return IsLoadableDataForRepl(type, val, version, errorStack, skipCustomOverride);
+    }
+    Definitions.IsLoadableDataForType = IsLoadableDataForType;
+    /**
+     * 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, data, source, expressionStartOverride) {
+        let types = rawType instanceof ReplicableClass ? [rawType] : ReplicableRegistry.__GetReplicablesFor(rawType);
+        if (!types) {
+            throw new Error(`Type ${describeObject(rawType)} is not a valid type.`);
+        }
+        //Hard-coded to one for now.
+        let type = types[0];
+        if (isPrimitiveType(type)) {
+            return data;
+        }
+        let version = MinVersion(source.Version, type.opts.version);
+        let props = type.finalised_properties.get(version);
+        for (let tsProp of type.finalised_propertyNames) {
+            let propInfo = props[tsProp];
+            if ("doesntExist" in propInfo || "removed" in propInfo) {
+                continue;
+            }
+            if (!propInfo.load.present || propInfo.load.skipLoad) {
+                continue;
+            }
+            if (propInfo.load.present == "optional" && typeof data[propInfo.load.name] === "undefined") {
+                continue;
+            }
+            let dataName = propInfo.load.name;
+            if (Expression.isExpressionString(data[dataName])) {
+                //If no config then the property doesn't allow expressions.
+                if (!propInfo.expressionForProperty)
+                    continue;
+                if (expressionStartOverride) {
+                    data[dataName] = Expression.Parse(data[dataName], source.SourceFile, Object.assign(Object.assign({}, propInfo.expressionForProperty[version]), { startType: expressionStartOverride }));
+                }
+                else {
+                    data[dataName] = Expression.Parse(data[dataName], source.SourceFile, propInfo.expressionForProperty[version]);
+                }
+            }
+            else if (typeof data[dataName] === "object") {
+                data[dataName] = MapEveryPropValue(propInfo, data[dataName], (val) => {
+                    if (Expression.isExpressionString(val)) {
+                        //If no config then the property doesn't allow expressions.
+                        if (!propInfo.expressionForValue)
+                            return val;
+                        return Expression.Parse(val, source.SourceFile, propInfo.expressionForValue[version]);
+                    }
+                    if (isPrimitiveValue(val) || !("Class" in val)) {
+                        //Not an object that can have expressions.
+                        return val;
+                    }
+                    let specificType = ReplicableRegistry.GetTypeForDataName(val.Class);
+                    if (!specificType || isPrimitiveType(specificType)) {
+                        return val;
+                    }
+                    for (let group of propInfo.load.types) {
+                        if (typeof group.types === "string") {
+                            continue;
+                        }
+                        for (let type of group.types) {
+                            if (type instanceof ReplicableClass && type.isChildTypeOfThisType(specificType)) {
+                                return PrePrepareData(type, val, source, expressionStartOverride);
+                            }
+                        }
+                    }
+                    return val;
+                });
+            }
+        }
+        return data;
+    }
+    Definitions.PrePrepareData = PrePrepareData;
+})(Definitions || (Definitions = {}));
+__ReplTypeHelperFunctions.SetIsLoadableDataForType(Definitions.IsLoadableDataForType);

package/Transformers/Loader.d.ts

@@ -0,0 +1,45 @@
+import { Primitive, PropertyTypes } from "../Constants/SerialisationTypes.js";
+import { Expression } from "../Expressions/Expression.js";
+import { ReplicableClass } from "../Tracking/Class.js";
+import { SourceMap } from "../Constants/SourceMaps.js";
+import { ErrorStack } from "../Constants/Errors.js";
+import { PropertyConfiguration, PropertyLoadingTypeInfo } from "../Tracking/Property.js";
+export declare namespace Loader {
+    interface ObjectData {
+        root: any;
+        source: SourceMap;
+        rootRepl: ReplicableClass;
+    }
+    interface PropertyData {
+        name: string;
+        dataName: string;
+        conf: PropertyConfiguration;
+    }
+    function LoadSingleValueAsType(propErrors: ErrorStack, obj: ObjectData, prop: PropertyData, propInfo: PropertyLoadingTypeInfo, propType: ReplicableClass | Primitive, val: any): any;
+    function PerValueCallback(value: any, idxName: any, triggeredMod: PropertyTypes, propErrors: ErrorStack, obj: ObjectData, prop: PropertyData): [val: any, idx: any];
+    /**
+     * 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 LoadPropValuesFromData(val: any, propErrors: ErrorStack, obj: ObjectData, prop: PropertyData): any;
+    /**
+     *
+     * @param type The type that the property is defined for.
+     * @param source The location that the property's definition was defined at.
+     * @param name The name of the property that will be instantiated, used for looking up property info.
+     * @param val The data value that will be used to instantiate the property
+     * @param target The 'this' object that will house the property
+     */
+    function CalcPropInitialValue(obj: ObjectData, name: string, val: any, target: any): any;
+    function SetPropertyToExpression(target: any, property: string, expression: Expression): void;
+    function IsPropertyExpression(target: any, property: string): boolean;
+    function ClearPropertyExpression(target: any, property: string): void;
+    function GetExprText(target: any, property: string): any;
+    function InitFromData(type: ReplicableClass, source: SourceMap, target: any, data: any): any;
+    function MarkInitialised(object: any): void;
+    function HasObjectBeenInitialised(obj: any): any;
+    function GetExpression(obj: any, propName: string): Expression | undefined;
+}