@bikky/replication 1.0.1

package/Tracking/Class.js

@@ -0,0 +1,221 @@
+import { Decorate } from "@bikky/decorators";
+import { BikPath } from "@bikky/path";
+import { VersionMap, WeakArray } from "@bikky/smart-collections";
+import { ClassCategory, DataSymbol, describeObject, generateDataName, isPrimitiveType, TypeSymbol } from "../Constants/SerialisationTypes.js";
+import { GetAllVersions, GetVersionController } from "../Constants/Versions.js";
+import { ReplAPI } from "../Expressions/TypeRegistry/ReplAPI.js";
+import { ExpressionScopes } from "../Expressions/TypeRegistry/Registry.js";
+import { Progress } from "../Transformers/Progress.js";
+const Primitives = ["undefined", "string", "number", "boolean"];
+export class ReplicableClass {
+    constructor(category, typeClass, opts) {
+        var _a, _b, _c, _d, _e;
+        //Items are stored on the object itself (or prototype itself) so that
+        // they survive mixins and stuff.
+        this.properties = new VersionMap(GetVersionController());
+        this.functions = new VersionMap(GetVersionController());
+        this.finalised_properties = new Map();
+        this.finalised_functions = new Map();
+        this.finalised_propertyNames = [];
+        this.finalised_functionNames = [];
+        this.finalised_ownPropertyNames = [];
+        this.finalised_ownFunctionNames = [];
+        //This is a list of all the parameters on the class that can be used to uniquely identify this instance
+        // when reporting errors.
+        this.liveIDs = [];
+        //This is a list of all the parameters on the data that can be used to uniquely identify this instance
+        // when reporting errors.
+        this.dataIDs = [];
+        this.parents = [];
+        //Children is not used for anything except some fancy validation checking by Arkhaven.
+        this.children = new WeakArray();
+        this.classConstructor = typeClass;
+        typeClass.prototype[TypeSymbol] = this;
+        this.category = category;
+        if ("DefinitionType" in this.classConstructor && !("DataIsType" in this.classConstructor)) {
+            throw new Error(`All classes which specify a DefinitionType must also specify a DataIsType function.\n${this.classConstructor.name} does not.`);
+        }
+        this.opts = {
+            version: opts.version,
+            file: opts.file,
+            typescriptTypeName: (_b = (_a = opts.typescriptTypeName) !== null && _a !== void 0 ? _a : opts.name) !== null && _b !== void 0 ? _b : this.classConstructor.name,
+            dataTypeName: (_d = (_c = opts.dataTypeName) !== null && _c !== void 0 ? _c : (opts.name ? generateDataName(opts.name) : undefined)) !== null && _d !== void 0 ? _d : generateDataName(this.classConstructor.name),
+            abstract: (_e = opts.abstract) !== null && _e !== void 0 ? _e : false
+        };
+        let parent = this.classConstructor.prototype.__proto__;
+        while (parent && parent.__proto__ !== Object) {
+            if (parent[TypeSymbol]) {
+                this.parents.push(parent[TypeSymbol]);
+            }
+            parent = parent.__proto__;
+        }
+        this.parents = [...new Set(this.removeParentsParentsFromArray(this.parents))];
+        for (let parent of this.parents) {
+            parent.children.push(this);
+        }
+        this.rule = new ReplAPI("Repl", this);
+        Progress.FinishReplicableType(this);
+    }
+    getIDAsString(val, data = false) {
+        if (data) {
+            if (this.dataIDs.length === 0)
+                return `(<${this.opts.dataTypeName}>` + describeObject(val) + ")";
+            return `(<${this.opts.dataTypeName}>` + this.dataIDs.map((e) => `${e}= ${val[e]}`).join(", ") + ")";
+        }
+        else {
+            if (this.liveIDs.length === 0)
+                return `(<${this.opts.typescriptTypeName}>` + describeObject(val) + ")";
+            return `(<${this.opts.typescriptTypeName}>` + this.liveIDs.map((e) => `${e}= ${val[e]}`).join(", ") + ")";
+        }
+    }
+    getAppropriateEnclosingRule() {
+        let [_, rule] = ExpressionScopes.GetScopeChain(this.opts.dataTypeName);
+        if (rule)
+            return rule;
+        for (let parent of this.parents) {
+            rule = parent.getAppropriateEnclosingRule();
+            if (rule)
+                return rule;
+        }
+        return void 0;
+    }
+    removeParentsParentsFromArray(parents) {
+        let newParents = [...parents];
+        for (let i = 0; i < this.parents.length; i++) {
+            let parent = this.parents[i];
+            newParents = parent.removeParentsParentsFromArray(newParents);
+        }
+        let parentsParents = new Set(this.parents.flatMap((e) => e.parents));
+        newParents = newParents.filter((e) => !parentsParents.has(e));
+        return newParents;
+    }
+    isObjectOfThisType(object) {
+        if (typeof object !== "object" || object === null) {
+            return false;
+        }
+        if (object[TypeSymbol] === this) {
+            return true;
+        }
+        while (object.__proto__ && object.__proto__ !== Object.prototype) {
+            if (object.__proto__[TypeSymbol] === this) {
+                return true;
+            }
+            object = object.__proto__;
+        }
+        return false;
+    }
+    isChildTypeOfThisType(specificType) {
+        if ((typeof specificType != "object" && typeof specificType !== "function") || specificType == null)
+            return false;
+        if (specificType == this)
+            return true;
+        if (specificType instanceof ReplicableClass) {
+            for (let parent of specificType.parents) {
+                if (this.isChildTypeOfThisType(parent)) {
+                    return true;
+                }
+            }
+            return this.isObjectOfThisType(specificType.classConstructor.prototype);
+        }
+        else {
+            return this.isObjectOfThisType(specificType.prototype);
+        }
+    }
+    getPropDefinition(version, property) {
+        var _a;
+        let definition = (_a = this.finalised_properties.get(version)) === null || _a === void 0 ? void 0 : _a[property];
+        if (!definition) {
+            throw new Error(`Failed to retrieve definition for property ${property}, as it was not found in class ${this.opts.typescriptTypeName}`);
+        }
+        return definition;
+    }
+    getPropHistoryDefinition(property) {
+        let allDefinitions = {};
+        for (let version of GetAllVersions()) {
+            let history = this.finalised_properties.get(version);
+            allDefinitions[version] = history[property];
+        }
+        return allDefinitions;
+    }
+    addProperty(version, property, data) {
+        var _a, _b;
+        let propDef = Object.assign(Object.assign({}, data), { property,
+            version, dataName: (_b = (_a = data.customLoad) !== null && _a !== void 0 ? _a : data.dataName) !== null && _b !== void 0 ? _b : generateDataName(property) });
+        this.properties.set(version, property, propDef);
+        switch (propDef.id) {
+            case "Live":
+                this.liveIDs.push(property);
+                break;
+            case "Data":
+                this.dataIDs.push(propDef.dataName);
+                break;
+            case true:
+                this.liveIDs.push(property);
+                this.dataIDs.push(propDef.dataName);
+                break;
+        }
+    }
+    removeProperty(version, property, opts) {
+        let propDef = Object.assign({ property,
+            version, removed: true, dataName: generateDataName(property) }, opts);
+        this.properties.set(version, property, propDef);
+    }
+    addFunction(version, funcName, outputType, parameters, options) {
+        var _a;
+        let dataName = (_a = options === null || options === void 0 ? void 0 : options.dataName) !== null && _a !== void 0 ? _a : generateDataName(funcName);
+        this.functions.set(version, funcName, {
+            dataName,
+            funcName,
+            parameters,
+            outputType,
+            options,
+            version
+        });
+        // this.rule.addFunction(version as Versions, { name: funcName, exprName: dataName }, outputType, parameters);
+    }
+    static typesToString(allTypes) {
+        return allTypes.map((e) => {
+            if (typeof e === "string")
+                return e;
+            if (typeof e === "undefined")
+                return "undefined";
+            if (e === null)
+                return "null";
+            return isPrimitiveType(e) ? e.name.toLowerCase() : e.opts.dataTypeName;
+        });
+    }
+    getOriginalPropertyValue(object, property) {
+        var _a;
+        let def = this.properties.get(this.opts.version, property);
+        if (!def)
+            return undefined;
+        if ("removed" in def)
+            return undefined;
+        let data = object[DataSymbol];
+        return (_a = data[def.dataName]) !== null && _a !== void 0 ? _a : def.default;
+    }
+    /**
+     * Used for some fancy Arkhaven type checking.
+     */
+    getChildClassesNames() {
+        return this.children.map((e) => e === null || e === void 0 ? void 0 : e.opts.typescriptTypeName).filter((e) => !!e);
+    }
+}
+const ClassDecorator = Decorate.Class({
+    onDecorate: (classConstructor, type, opts) => {
+        new ReplicableClass(type, classConstructor, opts);
+    }
+});
+export function Type(version, opts) {
+    return ClassDecorator(ClassCategory.Pointer, Object.assign(Object.assign({}, (opts !== null && opts !== void 0 ? opts : {})), { version: version, file: BikPath.getCallerFilepath() }));
+}
+export function Struct(version, opts) {
+    return ClassDecorator(ClassCategory.Struct, Object.assign(Object.assign({}, (opts !== null && opts !== void 0 ? opts : {})), { version: version, file: BikPath.getCallerFilepath() }));
+}
+export function CustomReplicableType(version, _class, opts) {
+    if (!("prototype" in _class)) {
+        _class.prototype = {};
+    }
+    new ReplicableClass(ClassCategory.Custom, _class, Object.assign(Object.assign({}, (opts !== null && opts !== void 0 ? opts : {})), { version: version, file: BikPath.getCallerFilepath() }));
+    return _class;
+}

package/Tracking/Functions.d.ts

@@ -0,0 +1,14 @@
+import { Versions } from "../Constants/Versions.js";
+export interface FunctionOptions {
+    dataName?: string;
+}
+export declare function Method(version: Versions, properties: any[][], outputTypes: any[], options?: FunctionOptions): (_class: any, property: (string | symbol)) => {
+    configurable: true;
+    enumerable: true;
+    writable: true;
+};
+export declare function Accessor(version: Versions, outputType: any[], options?: FunctionOptions): (_class: any, property: (string | symbol)) => {
+    configurable: true;
+    enumerable: true;
+    writable: true;
+};

package/Tracking/Functions.js

@@ -0,0 +1,27 @@
+import { Progress } from "../Transformers/Progress.js";
+import { FormatPropInput } from "./Property.js";
+export function Method(version, properties, outputTypes, options) {
+    let compOutputTypes = FormatPropInput(outputTypes);
+    let compProperties = [];
+    for (let i = 0; i < properties.length; i++) {
+        compProperties[i] = FormatPropInput(properties[1]);
+    }
+    return (_class, property) => {
+        if (typeof property === "symbol") {
+            throw new Error("Cannot use a symbol as a property name.");
+        }
+        // Decorating a property typically returns the class' .prototype value instead of the class itself,
+        // we want the class so we fix that here (with an exception for interfaces that have modules as representatives):
+        if (!("prototype" in _class) && "constructor" in _class)
+            _class = _class.constructor;
+        Progress.RegisterFunctionAdd(_class, [version, property, compOutputTypes, compProperties, options !== null && options !== void 0 ? options : {}]);
+        return {
+            configurable: true,
+            enumerable: true,
+            writable: true
+        };
+    };
+}
+export function Accessor(version, outputType, options) {
+    return Method(version, [], outputType, options !== null && options !== void 0 ? options : {});
+}

package/Tracking/GlobalGroup.d.ts

@@ -0,0 +1,5 @@
+export declare namespace GlobalGroup {
+    function getGroupID(object: any): any;
+    function AddToGroup(name: string, object: any): void;
+    function AddToGroups(groupNames: string[], object: any): void;
+}

package/Tracking/GlobalGroup.js

@@ -0,0 +1,39 @@
+import { ExpressionScopes } from "../Expressions/TypeRegistry/Registry.js";
+export var GlobalGroup;
+(function (GlobalGroup) {
+    const groups = new Map();
+    function getGroupID(object) {
+        let type = object.__proto__.constructor;
+        if (type.Reference) {
+            return type.Reference(object).join(".");
+        }
+        else if (typeof object !== "object") {
+            return object;
+        }
+        else {
+            return JSON.stringify(object);
+        }
+    }
+    GlobalGroup.getGroupID = getGroupID;
+    function AddToGroup(name, object) {
+        var _a;
+        let type = object.__proto__.constructor;
+        if (type === Object) {
+            type = (_a = object.Class) !== null && _a !== void 0 ? _a : Object;
+        }
+        let group = groups.get(name);
+        if (!group) {
+            group = {};
+            groups.set(name, group);
+            ExpressionScopes.addGlobalVariable(name, [type], group, "Map");
+        }
+        group[getGroupID(object)] = object;
+    }
+    GlobalGroup.AddToGroup = AddToGroup;
+    function AddToGroups(groupNames, object) {
+        for (let name of groupNames) {
+            AddToGroup(name, object);
+        }
+    }
+    GlobalGroup.AddToGroups = AddToGroups;
+})(GlobalGroup || (GlobalGroup = {}));

package/Tracking/Property.d.ts

@@ -0,0 +1,95 @@
+import { Versions } from "../Constants/Versions.js";
+import { ReplicableClassConstructor } from "./Types.js";
+import { IDPool } from "../IDPool.js";
+import UUID = IDPool.UUID;
+import { Primitive, PropertyTypes } from "../Constants/SerialisationTypes.js";
+import { ReplicableClass } from "./Class.js";
+import { Expression } from "../Expressions/Expression.js";
+import { ExpressionConfiguration } from "../Expressions/EvaluatorSteps.js";
+export type ComplexPropertyType = {
+    type: (string | any)[];
+    reference?: boolean;
+    serialised?: boolean;
+    data?: boolean;
+} & ({} | {
+    type: String;
+    restrictedTo?: readonly (number | string)[];
+} | {
+    type: Number;
+    restrictedTo?: readonly (number | string)[];
+} | {
+    array: boolean | 2;
+} | {
+    mapKey: typeof String | typeof Number | typeof Expression | (typeof String | typeof Number | typeof Expression)[];
+    restrictedTo?: readonly (number | string)[];
+} | {
+    dictKey: typeof String | typeof Number | (typeof String | typeof Number)[];
+    restrictedTo?: readonly (number | string)[];
+});
+export interface PropertyOptions {
+    computed?: boolean | "manualLoad";
+    customLoad?: string;
+    readonly?: boolean;
+    manualRestore?: boolean;
+    expression?: boolean;
+    setter?: boolean;
+    inline?: boolean;
+    optional?: boolean;
+    default?: any;
+    dataName?: string;
+    id?: "Live" | "Data" | true;
+    customDataType?: ReplicableClassConstructor | UUID | string | (string | any)[] | ComplexPropertyType | ComplexPropertyType[];
+}
+export interface PropertyLoadingTypeInfo {
+    types: (ReplicableClass | Primitive)[] | string;
+    sortIndex: string;
+    modifiers: PropertyTypes;
+    restrictedTo?: (string | number)[];
+    keyType?: (typeof String | typeof Number | typeof Expression)[];
+}
+export interface PropertySerialiseTypeInfo {
+    types: (ReplicableClass | Primitive)[];
+    sortIndex: string;
+    modifiers: PropertyTypes;
+    restrictedTo?: (string | number)[];
+    keyType?: (typeof String | typeof Number | typeof Expression)[];
+}
+export interface PropertyConfiguration {
+    name: string;
+    load: {
+        present: true | false | "optional";
+        skipLoad: boolean;
+        name: string;
+        default: any;
+        possibleModifiers: PropertyTypes;
+        types: PropertyLoadingTypeInfo[];
+    };
+    serialisation: {
+        present: true | false | "writeOnly";
+        inline: boolean;
+        possibleModifiers: PropertyTypes;
+        types: PropertySerialiseTypeInfo[];
+    };
+    expressionForProperty: {
+        [version in Versions | string]: ExpressionConfiguration;
+    } | undefined;
+    expressionForValue: {
+        [version in Versions | string]: ExpressionConfiguration;
+    } | undefined;
+    expressionForKey: {
+        [version in Versions | string]: ExpressionConfiguration;
+    } | undefined;
+}
+/**
+ * Converts a prop input of [Class], "ClassName", or any other configuration into { type: [Class] }.
+ * It does do a ton of fancy string manipulation, so you can enter "Serialised:ClassName" etc. to get
+ * the serialised version without needing to write out an entire complex type.
+ * @param raw The raw input.
+ * @constructor
+ */
+export declare function FormatPropInput(raw: any): ComplexPropertyType[];
+export declare function Property(version: Versions, type: ComplexPropertyType | ComplexPropertyType[], options?: PropertyOptions): (_class: any, property: (string | symbol)) => void;
+export declare function Property(version: Versions, type: any, options?: PropertyOptions): (_class: any, property: (string | symbol)) => void;
+export declare namespace Property {
+    function Remove(version: Versions, opts: Parameters<ReplicableClass["removeProperty"]>[2]): (_class: any, property: (string | symbol)) => void;
+}

package/Tracking/Property.js

@@ -0,0 +1,125 @@
+import { isPrimitiveType } from "../Constants/SerialisationTypes.js";
+import { Progress } from "../Transformers/Progress.js";
+/**
+ * Converts a prop input of [Class], "ClassName", or any other configuration into { type: [Class] }.
+ * It does do a ton of fancy string manipulation, so you can enter "Serialised:ClassName" etc. to get
+ * the serialised version without needing to write out an entire complex type.
+ * @param raw The raw input.
+ * @constructor
+ */
+export function FormatPropInput(raw) {
+    if (Array.isArray(raw)) {
+        return raw.flatMap(FormatPropInput);
+    }
+    if (typeof raw !== "string") {
+        if (Array.isArray(raw)) {
+            return [{ type: raw }];
+        }
+        if (isPrimitiveType(raw)) {
+            return [{ type: [raw] }];
+        }
+        if ("type" in raw) {
+            if (!Array.isArray(raw.type)) {
+                raw = [Object.assign(Object.assign({}, raw), { type: [raw.type] })];
+            }
+            else if (raw.__proto__ === Object.prototype) {
+                return [raw];
+            }
+            return raw;
+        }
+        return [{ type: [raw] }];
+    }
+    //raw is string:
+    let input = raw.trim();
+    let complex = {
+        type: []
+    };
+    if (input.endsWith("[][]")) {
+        complex = Object.assign(Object.assign({}, complex), { array: 2 });
+        input = input.slice(0, -4);
+    }
+    else if (input.endsWith("[]")) {
+        complex = Object.assign(Object.assign({}, complex), { array: true });
+        input = input.slice(0, -2);
+    }
+    if (input.startsWith("{")) {
+        input = input.slice(1, -1);
+        let [index, type] = input.split(":", 1).map((e) => e.trim());
+        let indexType;
+        switch (index.toLowerCase()) {
+            case "string": {
+                indexType = String;
+                break;
+            }
+            case "number": {
+                indexType = Number;
+                break;
+            }
+            default: {
+                throw new Error(`Map index type is invalid: ${index}.`);
+            }
+        }
+        complex = Object.assign(Object.assign({}, complex), { dictKey: indexType });
+        input = type;
+    }
+    if (input.includes(":")) {
+        let [restraint, type] = input.split(":", 1);
+        switch (restraint.toLowerCase()) {
+            case "reference": {
+                complex.reference = true;
+                break;
+            }
+            case "serialised": {
+                complex.serialised = true;
+                break;
+            }
+            case "data": {
+                complex.data = true;
+                break;
+            }
+            default: {
+                throw new Error(`Property type prefix ${restraint} is unknown.`);
+            }
+        }
+        input = type;
+    }
+    complex.type = [input];
+    return [complex];
+}
+export function Property(version, type, options) {
+    let compType = FormatPropInput(type);
+    let compCustomType = undefined;
+    if (options && options.customDataType) {
+        compCustomType = FormatPropInput(options.customDataType);
+    }
+    return (_class, property) => {
+        if (typeof property === "symbol")
+            throw new Error("Cannot use a symbol as a property name.");
+        // Decorating a property typically returns the class' .prototype value instead of the class itself,
+        // we want the class so we fix that here (with an exception for interfaces that have modules as representatives):
+        if (!("prototype" in _class) && "constructor" in _class)
+            _class = _class.constructor;
+        let propOpts = Object.assign(Object.assign({}, options), { type: compType });
+        if (compCustomType)
+            propOpts.customDataType = compCustomType;
+        Progress.RegisterPropertyLoad(_class, [version, property, propOpts]);
+        return {
+            configurable: true,
+            enumerable: true,
+            writable: true
+        };
+    };
+}
+(function (Property) {
+    function Remove(version, opts) {
+        return (_class, property) => {
+            Progress.RegisterPropertyRemove(_class, [version, property, opts]);
+            return {
+                configurable: true,
+                enumerable: true,
+                writable: true
+            };
+        };
+    }
+    Property.Remove = Remove;
+})(Property || (Property = {}));

package/Tracking/Types.d.ts

@@ -0,0 +1,33 @@
+import { SourceMap } from "../Constants/SourceMaps.js";
+import { ErrorStack } from "../Constants/Errors.js";
+import { Primitive } from "../Constants/SerialisationTypes.js";
+import { Versions } from "../Main.js";
+import { ComplexPropertyType } from "./Property.js";
+export interface ConstructorArgs<DefinitionType = any, OwnerType = any> {
+    data: DefinitionType | [type: string, data: any];
+    source: SourceMap;
+    owner?: OwnerType;
+}
+export type TypeClass = {
+    DefinitionType?: string | ComplexPropertyType | ComplexPropertyType[];
+    SerialisedType?: string | ComplexPropertyType | ComplexPropertyType[];
+    DataIsType?: (val: any, errors: string[]) => boolean;
+    Create?: (config: ConstructorArgs) => object;
+    Reference(value: any): any[];
+    Dereference(value: any[]): any;
+};
+export type StructClass = AbstractClass<object>;
+export type CustomClass = {
+    name: string;
+    Create: (config: ConstructorArgs) => object;
+    DefinitionType?: string | ComplexPropertyType | ComplexPropertyType[];
+    SerialisedType?: string | ComplexPropertyType | ComplexPropertyType[];
+    DataIsType: (version: Versions, val: any, errors: ErrorStack) => boolean;
+    Reference(value: any): any[];
+    Dereference(value: any[]): any;
+};
+export type ReplicableBaseType = TypeClass | StructClass | CustomClass;
+export type AnyReplType = ReplicableBaseType | Primitive;
+export type ReplicableClassConstructor = ((TypeClass | StructClass) & Function) | (CustomClass & {
+    prototype: any;
+});

package/Tracking/Types.js

@@ -0,0 +1 @@
+export {};

package/Tracking/__tests__/Replicable.Tracking.Decorator.test.d.ts

@@ -0,0 +1 @@
+export {};