@bikky/replication 1.0.1

package/Transformers/Serialiser.d.ts

@@ -0,0 +1,31 @@
+import { PropertyTypes } from "../Constants/SerialisationTypes.js";
+import { SourceMap } from "../Constants/SourceMaps.js";
+import { ReplicableClass } from "../Tracking/Class.js";
+import { PropertyConfiguration } from "../Tracking/Property.js";
+/**
+ * Keeps track of references that need to be changed on load.
+ * TODO: This may not be necessary anymore with Authority having a remapper system.
+ */
+export declare namespace Serialiser {
+    interface SerialisationInformation {
+        ownerRepl: ReplicableClass;
+        owner?: any;
+        source: SourceMap;
+    }
+    function SerialiseSingle(info: SerialisationInformation, conf: PropertyConfiguration, val: any, mods: PropertyTypes): [string, ...any[]];
+    function DeserialiseSingle(info: SerialisationInformation, conf: PropertyConfiguration, target: any, val: any, mod: PropertyTypes): any;
+    function SerialiseProp(info: SerialisationInformation, conf: PropertyConfiguration, val: any): any;
+    function DeserialiseProp(info: SerialisationInformation, conf: PropertyConfiguration, target: any, val: [name: string, data: any]): any;
+    function SerialiseRepl(type: ReplicableClass, source: SourceMap, object: any): [string, any];
+    function DeserialiseRepl(type: ReplicableClass, source: SourceMap, target: {
+        [key: string | symbol]: any;
+    }, serialised: [string, {
+        [key: string]: any[];
+    }], skipCustomDeserialiser?: boolean): {
+        [key: string]: any;
+        [key: symbol]: any;
+    };
+    function IsSerialisable(object: any): boolean;
+    function Serialise<T>(object: T): [string, any];
+    function Deserialise<T>(object: T, data: [string, any]): T;
+}

package/Transformers/Serialiser.js

@@ -0,0 +1,366 @@
+import { ClassCategory, describeObject, isPrimitiveType, isPrimitiveValue, PropertyTypes, TypeSymbol, ValueIsPrimitiveType } from "../Constants/SerialisationTypes.js";
+import { Expression } from "../Expressions/Expression.js";
+import { ReplicableRegistry } from "../Constants/ReplicableRegistry.js";
+import { Pointer, Referencer } from "./Reference.js";
+import { __PrivateConstructorSetup, Constructor } from "./Constructor.js";
+import { Versions } from "../Constants/Versions.js";
+import { Loader } from "./Loader.js";
+/**
+ * Keeps track of references that need to be changed on load.
+ * TODO: This may not be necessary anymore with Authority having a remapper system.
+ */
+export var Serialiser;
+(function (Serialiser) {
+    var IsPropertyExpression = Loader.IsPropertyExpression;
+    var __GetReplicableForDataName = ReplicableRegistry.__GetReplicableForDataName;
+    function SerialiseSingle(info, conf, val, mods) {
+        for (let typeInfo of conf.serialisation.types) {
+            if (!PropertyTypes.isType(typeInfo.modifiers, mods)) {
+                continue;
+            }
+            if (isPrimitiveValue(val)) {
+                for (let type of typeInfo.types) {
+                    if (isPrimitiveType(type)) {
+                        if (!ValueIsPrimitiveType(type, val)) {
+                            continue;
+                        }
+                        return ["Primitive", val];
+                    }
+                    if (isPrimitiveValue(val) && ClassCategory.isType(type.category, ClassCategory.Custom)) {
+                        return Referencer.Reference(val, type);
+                    }
+                }
+                continue;
+            }
+            if (PropertyTypes.isType(typeInfo.modifiers, PropertyTypes.ForceInline)) {
+                let rawVal = val;
+                if (val instanceof Pointer) {
+                    rawVal = val.valOrNull;
+                }
+                if (rawVal === null) {
+                    return ["Primitive", null];
+                }
+                if (TypeSymbol in rawVal) {
+                    return Serialiser.Serialise(rawVal);
+                }
+                continue;
+            }
+            else if (PropertyTypes.isType(typeInfo.modifiers, PropertyTypes.Serialised)) {
+                if (Array.isArray(val) && val.length === 2 && ReplicableRegistry.HasType(val[0])) {
+                    return val;
+                }
+                continue;
+            }
+            else if (PropertyTypes.isType(typeInfo.modifiers, PropertyTypes.Definition)) {
+                if (val.__proto__ === Object.prototype && "Class" in val) {
+                    return [val.Class, val];
+                }
+            }
+            else {
+                for (let unknownType of typeInfo.types) {
+                    if (isPrimitiveType(unknownType)) {
+                        continue;
+                    }
+                    //We handled primitives earlier.
+                    let type = unknownType;
+                    if (ClassCategory.isType(type.category, ClassCategory.Inlined)) {
+                        if (val.valOrNull == null)
+                            return ["Primitive", null];
+                        return Serialiser.Serialise(val.val);
+                    }
+                    else if (ClassCategory.isType(type.category, ClassCategory.Pointer)) {
+                        if (!(val instanceof Pointer)) {
+                            throw new Error(`Error serialising value! Expected ${info.ownerRepl.opts.dataTypeName}.${conf.name} ${describeObject(val)} to be a pointer!`);
+                        }
+                        if (val.ref === null || typeof val.ref === "undefined") {
+                            return ["Primitive", null];
+                        }
+                        return [...val.ref];
+                    }
+                    else if (ClassCategory.isType(type.category, ClassCategory.Custom)) {
+                        return Referencer.Reference(val, type);
+                    }
+                    else if (ClassCategory.isType(type.category, ClassCategory.Struct)) {
+                        return Serialiser.Serialise(val);
+                    }
+                }
+            }
+        }
+        throw new Error(`${info.ownerRepl.opts.dataTypeName}.${conf.name} is not a valid type for serialisation.`);
+    }
+    Serialiser.SerialiseSingle = SerialiseSingle;
+    function DeserialiseSingle(info, conf, target, val, mod) {
+        for (let typeInfo of conf.serialisation.types) {
+            if (!PropertyTypes.isType(typeInfo.modifiers, mod)) {
+                continue;
+            }
+            for (let type of typeInfo.types) {
+                if (val[0] === "Primitive") {
+                    if (!isPrimitiveType(type)) {
+                        if (typeof val[1] === "undefined" || val[1] == null && ClassCategory.isType(type.category, ClassCategory.Pointer)) {
+                            return new Pointer(null);
+                        }
+                        continue;
+                    }
+                    //JSON.serialise turns undefined into null.
+                    if (type === undefined && val[1] === null) {
+                        return void 0;
+                    }
+                    if (!ValueIsPrimitiveType(type, val[1])) {
+                        continue;
+                    }
+                    return val[1];
+                }
+                if (isPrimitiveType(type)) {
+                    continue;
+                }
+                let replType = ReplicableRegistry.__GetReplicableForDataName(val[0]);
+                if (replType != type && !type.isChildTypeOfThisType(replType)) {
+                    continue;
+                }
+                if (!PropertyTypes.isType(typeInfo.modifiers, PropertyTypes.ForceInline)) {
+                    if (PropertyTypes.isType(typeInfo.modifiers, PropertyTypes.Serialised)) {
+                        return val;
+                    }
+                    else if (PropertyTypes.isType(typeInfo.modifiers, PropertyTypes.Definition)) {
+                        return val[1];
+                    }
+                }
+                if (!type.isChildTypeOfThisType(replType)) {
+                    continue;
+                }
+                if (ClassCategory.isType(type.category, ClassCategory.Inlined) || PropertyTypes.isType(typeInfo.modifiers, PropertyTypes.ForceInline)) {
+                    if (target && target instanceof Pointer && target.valOrNull) {
+                        return new Pointer(Serialiser.Deserialise(target.val, val));
+                    }
+                    else {
+                        return new Pointer(Constructor.Construct(replType, info.source, info.owner, val));
+                    }
+                }
+                else if (ClassCategory.isType(type.category, ClassCategory.Pointer)) {
+                    return new Pointer(Referencer.Dereference(val));
+                }
+                else if (ClassCategory.isType(type.category, ClassCategory.Custom)) {
+                    return Referencer.Dereference(val, type);
+                }
+                else if (ClassCategory.isType(type.category, ClassCategory.Struct)) {
+                    if (target) {
+                        return Serialiser.Deserialise(target, val);
+                    }
+                    else {
+                        //Since type is a struct, we can just construct a new entry without worries.
+                        return Constructor.Construct(replType, info.source, info.owner, val);
+                    }
+                }
+            }
+        }
+        throw new Error(`${info.ownerRepl.opts.dataTypeName}.${conf.name} has an invalid value in it's serialised data.`);
+    }
+    Serialiser.DeserialiseSingle = DeserialiseSingle;
+    function SerialiseProp(info, conf, val) {
+        if (conf.expressionForProperty && val instanceof Expression) {
+            return ["Expression", val.expression.rawText];
+        }
+        if (PropertyTypes.isType(conf.serialisation.possibleModifiers, PropertyTypes.Dictionary)
+            && typeof val === "object" && val !== null && val.__proto__ === Object.prototype && !val[TypeSymbol]) {
+            let result = ["Dict", {}];
+            for (let [k, v] of Object.entries(val)) {
+                result[1][k] = Serialiser.SerialiseSingle(info, conf, v, PropertyTypes.Dictionary);
+            }
+            return result;
+        }
+        else if (PropertyTypes.isType(conf.serialisation.possibleModifiers, PropertyTypes.Map)
+            && val instanceof Map) {
+            let result = ["Map", {}];
+            for (let [k, v] of val.entries()) {
+                result[1][k] = Serialiser.SerialiseSingle(info, conf, v, PropertyTypes.Map);
+            }
+            return result;
+        }
+        else if (PropertyTypes.isType(conf.serialisation.possibleModifiers, PropertyTypes.Array)
+            && Array.isArray(val)) {
+            let result = ["Array", []];
+            for (let v of val) {
+                result[1].push(Serialiser.SerialiseSingle(info, conf, v, PropertyTypes.Array));
+            }
+            return result;
+        }
+        else if (PropertyTypes.isType(conf.serialisation.possibleModifiers, PropertyTypes.Array2)
+            && Array.isArray(val)) {
+            let result = ["Array2", []];
+            for (let v of val) {
+                let row = [];
+                for (let vv of v) {
+                    row.push(Serialiser.SerialiseSingle(info, conf, vv, PropertyTypes.Array2));
+                }
+                result[1].push(row);
+            }
+            return result;
+        }
+        else if (PropertyTypes.isType(conf.serialisation.possibleModifiers, PropertyTypes.Solo)) {
+            return Serialiser.SerialiseSingle(info, conf, val, PropertyTypes.Solo);
+        }
+    }
+    Serialiser.SerialiseProp = SerialiseProp;
+    function DeserialiseProp(info, conf, target, val) {
+        if (val[0] === "Expression") {
+            throw new Error(`Deserialising expressions is not implemented currently.`);
+        }
+        if (val[0] === "Dict") {
+            if (!PropertyTypes.isType(conf.serialisation.possibleModifiers, PropertyTypes.Dictionary)) {
+                throw new Error(`Property does not allow for dictionary values, but has been serialised as one.`);
+            }
+            if (!target || (target.__proto__ != Object.prototype))
+                target = {};
+            for (let [k, v] of Object.entries(val[1])) {
+                target[k] = Serialiser.DeserialiseSingle(info, conf, target[k], v, PropertyTypes.Dictionary);
+            }
+            return target;
+        }
+        if (val[0] === "Map") {
+            if (!PropertyTypes.isType(conf.serialisation.possibleModifiers, PropertyTypes.Map)) {
+                throw new Error(`Property does not allow for map values, but has been serialised as one.`);
+            }
+            if (!target || !(target instanceof Map))
+                target = new Map();
+            for (let [k, v] of Object.entries(val[1])) {
+                target.set(k, Serialiser.DeserialiseSingle(info, conf, target.get(k), v, PropertyTypes.Map));
+            }
+            return target;
+        }
+        if (val[0] === "Array") {
+            if (!PropertyTypes.isType(conf.serialisation.possibleModifiers, PropertyTypes.Array)) {
+                throw new Error(`Property does not allow for array values, but has been serialised as one.`);
+            }
+            if (!target || !Array.isArray(target))
+                target = [];
+            for (let [i, v] of val[1].entries()) {
+                target[i] = Serialiser.DeserialiseSingle(info, conf, target[i], v, PropertyTypes.Array);
+            }
+            return target;
+        }
+        if (val[0] === "Array2") {
+            if (!PropertyTypes.isType(conf.serialisation.possibleModifiers, PropertyTypes.Array2)) {
+                throw new Error(`Property does not allow for double array values, but has been serialised as one.`);
+            }
+            if (!target || !Array.isArray(target))
+                target = [];
+            for (let [i, r] of val[1].entries()) {
+                if (!target[i] || !Array.isArray(target[i]))
+                    target[i] = [];
+                for (let [ii, v] of r.entries()) {
+                    target[i][ii] = Serialiser.DeserialiseSingle(info, conf, target[i][ii], v, PropertyTypes.Array2);
+                }
+            }
+            return target;
+        }
+        return Serialiser.DeserialiseSingle(info, conf, target, val, PropertyTypes.Solo);
+    }
+    Serialiser.DeserialiseProp = DeserialiseProp;
+    function SerialiseRepl(type, source, object) {
+        if ("Serialise" in type.classConstructor) {
+            return [type.opts.dataTypeName, type.classConstructor.Serialise(object)];
+        }
+        let serialised = {};
+        serialised.version = Versions.MAX;
+        let vers = type.finalised_properties.get(Versions.MAX);
+        let info = {
+            ownerRepl: type,
+            source: source,
+            owner: object
+        };
+        for (let name of type.finalised_propertyNames) {
+            let def = vers[name];
+            if ("removed" in def || "doesntExist" in def)
+                continue;
+            if (!def.serialisation.present)
+                continue;
+            serialised[name] = Serialiser.SerialiseProp(info, def, object[name]);
+        }
+        return [type.opts.dataTypeName, serialised];
+    }
+    Serialiser.SerialiseRepl = SerialiseRepl;
+    function DeserialiseRepl(type, source, target, serialised, skipCustomDeserialiser = false) {
+        if ("Deserialise" in type.classConstructor && !skipCustomDeserialiser) {
+            //Mark initialised afterwards just in case Deserialise wants to use Load.
+            target = type.classConstructor.Deserialise(serialised[1], target);
+            Loader.MarkInitialised(target);
+            return target;
+        }
+        Loader.MarkInitialised(target);
+        let sObject = serialised[1];
+        let setting = {
+            source, owner: target
+        };
+        let vers = type.finalised_properties.get(Versions.MAX);
+        let info = {
+            ownerRepl: type,
+            source: setting.source,
+            owner: setting.owner
+        };
+        for (let name of type.finalised_propertyNames) {
+            let def = vers[name];
+            if ("removed" in def || "doesntExist" in def) {
+                if (name in sObject) {
+                    console.warn(`Property ${type.opts.typescriptTypeName}.${name} has been removed and cannot be loaded.`);
+                }
+                continue;
+            }
+            if (def.serialisation.present != true)
+                continue;
+            let propType = sObject[name][0], propValue = sObject[name][1];
+            if (propType === "Expression" && def.expressionForProperty) {
+                if (IsPropertyExpression(target, name)) {
+                    if (Loader.GetExprText(target, name) === propValue) {
+                        continue;
+                    }
+                    Loader.ClearPropertyExpression(target, name);
+                }
+                let expr = new Expression(propValue, def.expressionForProperty[Versions.MAX]);
+                Loader.SetPropertyToExpression(target, name, expr);
+                continue;
+            }
+            if (!(def.name in sObject)) {
+                throw new Error(`Property ${type.opts.typescriptTypeName}.${name} is not present in the serialised data.`);
+            }
+            if (IsPropertyExpression(target, name)) {
+                //TODO: Override local expression with the value from the serialised one (if present - otherwise leave unchanged).
+                continue;
+                // Loader.ClearPropertyExpression(target, name);
+            }
+            target[name] = DeserialiseProp(info, def, target[name], sObject[name]);
+        }
+        return target;
+    }
+    Serialiser.DeserialiseRepl = DeserialiseRepl;
+    function IsSerialisable(object) {
+        return !isPrimitiveValue(object) && !!(object[TypeSymbol]);
+    }
+    Serialiser.IsSerialisable = IsSerialisable;
+    function Serialise(object) {
+        let typeDef = object[TypeSymbol];
+        if (!typeDef) {
+            throw new Error(`Tried to serialise non-replicable type! ${describeObject(object)}`);
+        }
+        let source = { SourceFile: "Serialise Function", Version: Versions.MAX };
+        return SerialiseRepl(typeDef, source, object);
+    }
+    Serialiser.Serialise = Serialise;
+    function Deserialise(object, data) {
+        if (data[0] === "Primitive") {
+            return data[1];
+        }
+        if (data[0] === "Expression" || data[0] === "Dict" || data[0] === "Map" || data[0] === "Array" || data[0] === "Array2") {
+            throw new Error(`Cannot deserialise data of type ${data[0]}.`);
+        }
+        let sTypeDef = __GetReplicableForDataName(data[0]);
+        let typeDef = object[TypeSymbol];
+        if (sTypeDef != typeDef) {
+            throw new Error(`Cannot deserialise data of ${data[0]} into ${typeDef.classConstructor.name}.`);
+        }
+        let source = { SourceFile: "Deserialise Function", Version: Versions.MAX };
+        return DeserialiseRepl(typeDef, source, object, data);
+    }
+    Serialiser.Deserialise = Deserialise;
+})(Serialiser || (Serialiser = {}));
+__PrivateConstructorSetup.RegisterDeserialiser(Serialiser.Deserialise);

package/Transformers/Utils.d.ts

@@ -0,0 +1,33 @@
+import { PropertyTypes } from "../Constants/SerialisationTypes.js";
+import { Referencer } from "./Reference.js";
+import type { PropertyDefinition, ReplicableClass } from "../Tracking/Class.js";
+import { Expression } from "../Expressions/Expression.js";
+import { EvaluationChain } from "../Expressions/EvaluatorChain.js";
+import { EvaluationString } from "../Expressions/EvaluatorString.js";
+import { Versions } from "../Constants/Versions.js";
+import { ExpressionConfiguration } from "../Expressions/EvaluatorSteps.js";
+import { PropertyConfiguration } from "../Tracking/Property.js";
+export declare namespace Utils {
+    namespace 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: ExpressionConfiguration): string;
+        function DefVisualModifierAid(def: PropertyDefinition): string;
+        function CategoryVisualModifierAid(category: PropertyTypes): string;
+        function ReplPrimOrRawToName(val: any): string;
+        function ValVisualAidBestGuess(val: any): string;
+    }
+    namespace ExpressionUtils {
+        function MakePropExpressionConfig(version: Versions | string, def: PropertyDefinition, startType?: any): ExpressionConfiguration | undefined;
+        function DoesExpressionMatchPropType(expr: Expression | EvaluationChain | EvaluationString, propType: PropertyConfiguration): boolean;
+    }
+    namespace CompareUtils {
+        function CompareValWithSerialisedVal(val: any, serialised: any, debuginfo: string): boolean;
+        function CompareRepl(type: ReplicableClass, object: any, serialised: any): boolean;
+        function Compare<T>(a: T, b: [string, any]): boolean;
+        function CompareReferences(a: Referencer.Reference, b: Referencer.Reference): boolean;
+    }
+}