@bikky/replication 1.0.1

package/Transformers/Utils.js

@@ -0,0 +1,287 @@
+import { describeObject, getPrimitiveClass, isPrimitiveType, isPrimitiveValue, PropertyTypes, TypeSymbol } from "../Constants/SerialisationTypes.js";
+import { Pointer } from "./Reference.js";
+import { ReplicableRegistry } from "../Constants/ReplicableRegistry.js";
+import { Expression } from "../Expressions/Expression.js";
+import { EvaluationChain } from "../Expressions/EvaluatorChain.js";
+import { EvaluationString } from "../Expressions/EvaluatorString.js";
+import { MinVersion } from "../Constants/Versions.js";
+export var Utils;
+(function (Utils) {
+    // export interface PropertyDecoratorExtendedInfo {
+    //     type: ReplicableClass | Primitive;
+    //     modifier: "Class" | "Definition" | "Serialised" | "Reference";
+    //     category: PropertyTypes;
+    //     restrictedTo?: (string | number)[];
+    //     keyType?: (typeof String | typeof Number | typeof Expression)[];
+    //     propertyName: string;
+    //     ownerName: string;
+    //     load: boolean | string;
+    // }
+    //
+    // export interface PropertyDecoratorExtendedInfoData extends Omit<PropertyDecoratorExtendedInfo, "type"> {
+    //     type: ReplicableClass | Primitive | string;
+    // }
+    let PrintUtils;
+    (function (PrintUtils) {
+        /**
+         * Turns a given config into a modifier string ignoring the types, for easier comparison and error reporting.
+         * @param config The configuration to get the visual aid for.
+         * @private
+         */
+        function ConfigVisualModifierAid(config) {
+            if (config.outputArray == 2)
+                return "1[][]";
+            if (config.outputArray == 1)
+                return "1[]";
+            if (config.outputMap)
+                return "Map<string, 1>";
+            if (config.outputDict)
+                return "{[key: string]: 1 }";
+            return "1";
+        }
+        PrintUtils.ConfigVisualModifierAid = ConfigVisualModifierAid;
+        function DefVisualModifierAid(def) {
+            let dictKey = ("dictKey" in def && def.dictKey) || def.type.map((e) => "dictKey" in e && e.dictKey).reduce((a, b) => a || b) || undefined;
+            let mapKey = ("mapKey" in def && def.mapKey) || def.type.map((e) => "mapKey" in e && e.mapKey).reduce((a, b) => a || b) || undefined;
+            let array = ("array" in def && def.array) || def.type.map((e) => "array" in e && e.array).reduce((a, b) => a || b) || undefined;
+            if (dictKey) {
+                return "{[key: string]: 1 }";
+            }
+            else if (mapKey) {
+                return "Map<string, 1>";
+            }
+            else if (array == 2) {
+                return "1[][]";
+            }
+            else if (array == 1 || array == true) {
+                return "1[]";
+            }
+            else {
+                return "1";
+            }
+        }
+        PrintUtils.DefVisualModifierAid = DefVisualModifierAid;
+        function CategoryVisualModifierAid(category) {
+            let result = "";
+            if (PropertyTypes.isType(category, PropertyTypes.Solo))
+                result += " 1";
+            if (PropertyTypes.isType(category, PropertyTypes.Array2))
+                result += " 1[][]";
+            if (PropertyTypes.isType(category, PropertyTypes.Array))
+                result += " 1[]";
+            if (PropertyTypes.isType(category, PropertyTypes.Map))
+                result += " Map<string, 1>";
+            if (PropertyTypes.isType(category, PropertyTypes.Dictionary))
+                result += " {[key: string]: 1 }";
+            result = result.slice(1);
+            result.replace(/ /g, " | ");
+            return result;
+        }
+        PrintUtils.CategoryVisualModifierAid = CategoryVisualModifierAid;
+        function ReplPrimOrRawToName(val) {
+            if (isPrimitiveType(val)) {
+                return describeObject(val);
+            }
+            if (isPrimitiveValue(val)) {
+                return describeObject(getPrimitiveClass(val));
+            }
+            if ("opts" in val && "typescriptTypeName" in val.opts) {
+                return val.opts.typescriptTypeName;
+            }
+            return describeObject(val);
+        }
+        PrintUtils.ReplPrimOrRawToName = ReplPrimOrRawToName;
+        function ValVisualAidBestGuess(val) {
+            let typesString = [];
+            let modString = "";
+            let gatherTypes = (e) => {
+                let newTypeName = ReplPrimOrRawToName(e);
+                if (!typesString.includes(newTypeName)) {
+                    typesString.push(newTypeName);
+                }
+            };
+            if (Array.isArray(val)) {
+                if (val.every((e) => Array.isArray(e))) {
+                    val.forEach((e) => e.forEach(gatherTypes));
+                    modString = "1[][]";
+                }
+                else {
+                    val.forEach(gatherTypes);
+                    modString = "1[]";
+                }
+            }
+            else if (val !== null && typeof val === "object" && val.__proto__ === Object.prototype && !("Class" in val)) {
+                modString = "{[key: string]: 1 }";
+                Object.values(val).forEach(gatherTypes);
+            }
+            else if (val instanceof Map) {
+                modString = "Map<string, 1>";
+                Array.from(val.values()).forEach(gatherTypes);
+            }
+            else {
+                gatherTypes(val);
+                modString = "1";
+            }
+            if (typesString.length == 1) {
+                return modString.replace("1", typesString.join(" | "));
+            }
+            else {
+                return modString.replace("1", "(" + typesString.join(" | ") + ")");
+            }
+        }
+        PrintUtils.ValVisualAidBestGuess = ValVisualAidBestGuess;
+    })(PrintUtils = Utils.PrintUtils || (Utils.PrintUtils = {}));
+    let ExpressionUtils;
+    (function (ExpressionUtils) {
+        function MakePropExpressionConfig(version, def, startType) {
+            if (def.expression === false)
+                return;
+            let exprArray = def.type.flatMap((e) => "array" in e && e.array).reduce((a, b) => {
+                if (a !== b) {
+                    throw new Error(`Error, ${def.property} has inconsistent type categories `
+                        + `(array & not array, etc).\nExpressions don't support this currently.`);
+                }
+                return a;
+            });
+            //TODO: Do we care if the key types don't match? It will work fine at runtime.
+            let exprMap = def.type.flatMap((e) => "mapKey" in e).reduce((a, b) => {
+                if (a !== b) {
+                    throw new Error(`Error, ${def.property} has inconsistent type categories `
+                        + `(map & not map, etc).\nExpressions don't support this currently.`);
+                }
+                return a;
+            });
+            //TODO: Do we care if the key types don't match? It will work fine at runtime.
+            let exprDict = def.type.flatMap((e) => "dictKey" in e).reduce((a, b) => {
+                if (a !== b) {
+                    throw new Error(`Error, ${def.property} has inconsistent type categories `
+                        + `(dict & not dict, etc).\nExpressions don't support this currently.`);
+                }
+                return a;
+            });
+            return {
+                version: MinVersion(version, def.version),
+                cacheable: false,
+                outputTypes: def.type.flatMap((e) => e.type),
+                //TODO: Probably should have a way to override this *shrug*
+                startType: startType !== null && startType !== void 0 ? startType : Expression.getLatestSetScope(),
+                outputMap: exprMap,
+                outputDict: exprDict,
+                duringLoad: false,
+                outputArray: exprArray == 2 ? 2 : exprArray ? 1 : 0
+            };
+        }
+        ExpressionUtils.MakePropExpressionConfig = MakePropExpressionConfig;
+        function DoesExpressionMatchPropType(expr, propType) {
+            if (expr instanceof Expression) {
+                expr = expr.expression;
+            }
+            let outputTypes = propType.expressionForProperty[expr.config.version].outputTypes;
+            if (expr instanceof EvaluationString) {
+                return outputTypes.some((e) => e == String);
+            }
+            //Every type output by the expression must match at least one of the types in the property.
+            return expr.outputTypes.every((type) => {
+                return outputTypes.some((e) => e == type);
+            });
+        }
+        ExpressionUtils.DoesExpressionMatchPropType = DoesExpressionMatchPropType;
+    })(ExpressionUtils = Utils.ExpressionUtils || (Utils.ExpressionUtils = {}));
+    let CompareUtils;
+    (function (CompareUtils) {
+        function CompareValWithSerialisedVal(val, serialised, debuginfo) {
+            if (Array.isArray(val)) {
+                if (!Array.isArray(serialised))
+                    return false;
+                if (val.length !== serialised.length)
+                    return false;
+                for (let i = 0; i < val.length; i++) {
+                    if (!(i in serialised))
+                        return false;
+                    if (!CompareValWithSerialisedVal(val[i], serialised[i][1], `${debuginfo}[${i}]`))
+                        return false;
+                }
+                return true;
+            }
+            if (val instanceof Map) {
+                for (let [name, value] of val.entries()) {
+                    if (!(name in serialised))
+                        return false;
+                    if (!CompareValWithSerialisedVal(value, serialised[name][1], `${debuginfo}.${name}`))
+                        return false;
+                }
+                return true;
+            }
+            if (isPrimitiveValue(val)) {
+                return val === serialised;
+            }
+            //TODO: Should we test expression properly? We're assuming the rawText never gets replicated.
+            if (val instanceof Expression || val instanceof EvaluationChain || val instanceof EvaluationString) {
+                return true;
+            }
+            if (val instanceof Pointer) {
+                return JSON.stringify(val.ref) === JSON.stringify(serialised);
+            }
+            if (val instanceof Object) {
+                for (let [name, value] of Object.entries(val)) {
+                    if (!(name in serialised))
+                        return false;
+                    if (!CompareValWithSerialisedVal(value, serialised[name][1], `${debuginfo}.${name}`))
+                        return false;
+                }
+                return true;
+            }
+            return CompareRepl(val[TypeSymbol], val, serialised);
+        }
+        CompareUtils.CompareValWithSerialisedVal = CompareValWithSerialisedVal;
+        function CompareRepl(type, object, serialised) {
+            let props = type.finalised_properties.get(type.opts.version);
+            for (let [name, def] of Object.entries(props)) {
+                if ("removed" in def || "doesntExist" in def)
+                    continue;
+                if (def.serialisation.present != true)
+                    continue;
+                if (def.serialisation.inline && object[name] instanceof Pointer) {
+                    let subType = object[name].val[TypeSymbol];
+                    if (!CompareRepl(subType, object[name].val, serialised[name][1])) {
+                        return false;
+                    }
+                }
+                else if (object[name] instanceof Pointer) {
+                    if (!CompareValWithSerialisedVal(object[name], serialised[name], `${describeObject(object)}.${name}`)) {
+                        return false;
+                    }
+                }
+                else if (!CompareValWithSerialisedVal(object[name], serialised[name][1], `${describeObject(object)}.${name}`)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        CompareUtils.CompareRepl = CompareRepl;
+        function Compare(a, b) {
+            let sTypeDef = ReplicableRegistry.__GetReplicableForDataName(b[0]);
+            let typeDef = a[TypeSymbol];
+            if (sTypeDef != typeDef) {
+                //Items are of different types, so inherently fails.
+                return false;
+            }
+            return CompareRepl(typeDef, a, b[1]);
+        }
+        CompareUtils.Compare = Compare;
+        function CompareReferences(a, b) {
+            if (!Array.isArray(a))
+                return a === b;
+            if (!Array.isArray(b))
+                return false;
+            if (a.length !== b.length)
+                return false;
+            for (let i = 0; i < a.length; i++) {
+                if (a[i] !== b[i])
+                    return false;
+            }
+            return true;
+        }
+        CompareUtils.CompareReferences = CompareReferences;
+    })(CompareUtils = Utils.CompareUtils || (Utils.CompareUtils = {}));
+})(Utils || (Utils = {}));

package/Transformers/__tests__/Examples.d.ts

@@ -0,0 +1,168 @@
+import { Pointer } from "../Reference.js";
+export declare namespace TestPropertyDecorators {
+    class TransformersTheLotClass {
+        val: string;
+        val2: number;
+        val3: Map<string, number>;
+        val4: {
+            [name: number]: string;
+        };
+        val5: string[];
+        val6: number[][];
+        val7: TransformersBasicStruct;
+        val8: string | number | null;
+        val9: Pointer<TransformersBasicClass>;
+        val10: Pointer<TransformersBasicClass>;
+        val11?: string;
+        val13: number[][];
+        val14: number;
+    }
+    namespace TransformersTheLotClass {
+        function MakeExampleObj(): TransformersTheLotClass;
+    }
+    class TransformersBasicStruct {
+        val: string;
+    }
+    class TransformersBasicClass {
+        val: string;
+    }
+    class TransformersBasicChild extends TestPropertyDecorators.TransformersTheLotClass {
+        valX: string;
+    }
+    class VariedSerialisationStruct {
+        ser: Pointer<TransformersBasicClass>;
+        ser2: Pointer<TransformersBasicClass>;
+        ser4: any;
+        ser5: any;
+        ser7: TransformersBasicStruct;
+        ser9: any;
+        ser10: any;
+    }
+    namespace VariedSerialisationStruct {
+        function MakeExampleObj(): VariedSerialisationStruct;
+    }
+    const TransformersTheLotData: {
+        Class: string;
+        Val: string;
+        Val2: number;
+        Val3: {
+            hello: number;
+        };
+        Val4: {
+            1: string;
+        };
+        Val5: string[];
+        Val6: number[][];
+        Val7: {
+            Class: string;
+            Val: string;
+        };
+        Val8: string;
+        Val9: {
+            Class: string;
+            Val: string;
+        };
+        Val10: {
+            Class: string;
+            Val: string;
+        };
+        Val11: string;
+        Val13: number[][];
+    };
+    const TransformersTheLotExpression: {
+        Class: string;
+        Val: string;
+        Val2: string;
+        Val3: string;
+        Val4: string;
+        Val5: string;
+        Val6: string;
+        Val7: string;
+        Val8: string;
+        Val9: string;
+        Val10: string;
+        Val11: string;
+        Val13: number[][];
+    };
+    const TransformersTheLotInnerExpression: {
+        Class: string;
+        Val: string;
+        Val2: string;
+        Val3: {
+            hello: string;
+        };
+        Val4: {
+            1: string;
+        };
+        Val5: string[];
+        Val6: string[][];
+        Val7: {
+            Class: string;
+            Val: string;
+        };
+        Val8: string;
+        Val9: {
+            Class: string;
+            Val: string;
+        };
+        Val10: {
+            Class: string;
+            Val: string;
+        };
+        Val11: string;
+        Val13: number[][];
+    };
+    const TransformersBasicChildData: {
+        Class: string;
+        ValX: string;
+        Val: string;
+        Val2: number;
+        Val3: {
+            hello: number;
+        };
+        Val4: {
+            1: string;
+        };
+        Val5: string[];
+        Val6: number[][];
+        Val7: {
+            Class: string;
+            Val: string;
+        };
+        Val8: string;
+        Val9: {
+            Class: string;
+            Val: string;
+        };
+        Val10: {
+            Class: string;
+            Val: string;
+        };
+        Val11: string;
+        Val13: number[][];
+    };
+    const InvalidTransformersTheLotData: {
+        Class: string;
+        Val2: string;
+        Val3: string;
+        Val4: number;
+        Val5: string[][];
+        Val6: number[];
+        Val7: {
+            Class: string;
+            Val: string;
+        };
+        Val8: number[][];
+        Val9: {
+            Class: string;
+            Val: number;
+        };
+        Val10: number[];
+        Val11: {
+            1: string;
+        };
+        Val12: number;
+        Val13: string;
+        Val14: string;
+    };
+}