@bikky/replication 1.0.1

package/Replicatable.js

@@ -0,0 +1,123 @@
+import { BikPath } from "@bikky/path";
+import { ReplicableRegistry } from "./Constants/ReplicableRegistry.js";
+import { getClassOfObject as GetClassOfObjectInternal, TypeSymbol, isPrimitiveType, describeObject } from "./Constants/SerialisationTypes.js";
+import { Versions } from "./Constants/Versions.js";
+import { Expression } from "./Expressions/Expression.js";
+import { ReplicableClass } from "./Tracking/Class.js";
+import { Loader } from "./Transformers/Loader.js";
+import { ErrorStack } from "./Constants/Errors.js";
+import { Definitions } from "./Transformers/Definitions.js";
+import { Referencer } from "./Transformers/Reference.js";
+import { Utils } from "./Transformers/Utils.js";
+import { Serialiser } from "./Transformers/Serialiser.js";
+import { Constructor } from "./Transformers/Constructor.js";
+import { __ReplTypeHelperFunctions } from "./Expressions/TypeRegistry/ReplAPI.js";
+import { Progress } from "./Transformers/Progress.js";
+import { Configurer } from "./Transformers/Configurer.js";
+export var Replicable;
+(function (Replicable) {
+    Referencer.SetDataNameLookupFunction(ReplicableRegistry.__GetReplicableForDataName);
+    Referencer.SetAliasLookupFunction(ReplicableRegistry.__GetReplicablesFor);
+    __ReplTypeHelperFunctions.SetDataNameTypeLookupFunction(ReplicableRegistry.GetTypeForDataName);
+    __ReplTypeHelperFunctions.SetPrimOrClassLookupFunction(ReplicableRegistry.__GetReplOrPrimFor);
+    Progress.RegisterReplInitialisationFunction(Configurer.CacheClassProperties);
+    /**
+     * Can be used to create a new instance of a replicable class, even from serialised data.
+     * When restoring serialised data provide the serialised data as the "data" parameter of the options.
+     * @param Class the class to create an instance of.
+     * @param opts the options for creating the instance.
+     */
+    function Create(Class, opts) {
+        var _a, _b, _c;
+        if (!opts)
+            opts = {};
+        if (!opts.source) {
+            opts.source = {
+                SourceFile: BikPath.getCallerFilepath(),
+                Version: Versions.MAX
+            };
+        }
+        let stack = new ErrorStack(opts.source);
+        let types = (_a = ReplicableRegistry.__GetReplicablesFor(Class)) !== null && _a !== void 0 ? _a : [];
+        if (!Array.isArray(opts.data)) {
+            types = types.filter((e) => {
+                if (e === undefined)
+                    return false;
+                return Definitions.IsLoadableDataForType(e, opts.data, opts.source.Version, stack);
+            });
+            if (types.length === 0) {
+                throw new Error(`Failed to find matching type for data ${(_b = opts.data.Class) !== null && _b !== void 0 ? _b : describeObject(opts.data)} in ${describeObject(Class)}\n` + stack.toString("REP_001"));
+            }
+        }
+        else {
+            let serialisedType = Replicable.GetTypeForDataName(opts.data[0]);
+            if (!types.some((e) => e === serialisedType || (e instanceof ReplicableClass ? e.isChildTypeOfThisType(serialisedType) : false))) {
+                throw new Error(`Failed to find matching type for data ${opts.data[0]} in ${describeObject(Class)}\n` + stack.toString("REP_002"));
+            }
+            types = [serialisedType];
+        }
+        if (isPrimitiveType(types[0])) {
+            return opts.data;
+        }
+        return Constructor.Construct(types[0], opts.source, opts.owner, (_c = opts.args) !== null && _c !== void 0 ? _c : opts.data);
+    }
+    Replicable.Create = Create;
+    function Initialise(object, data, expressionParams) {
+        let type = Replicable.GetClassOfObject(object);
+        let typeDef = type.prototype[TypeSymbol];
+        if (expressionParams) {
+            Expression.setCurrentScope(type, expressionParams);
+        }
+        if (Array.isArray(data.data) && data.data[0] !== typeDef.opts.dataTypeName) {
+            return Replicable.Deserialise(object, data.data);
+        }
+        else {
+            if (!("source" in data)) {
+                throw new Error(`Source not provided for initialisation of ${describeObject(object)}`);
+            }
+            return Replicable.Load(object, data.data, data.source, expressionParams);
+        }
+    }
+    Replicable.Initialise = Initialise;
+    function Load(object, data, source, expressionParams) {
+        let type = Replicable.GetClassOfObject(object);
+        let typeDef = type.prototype[TypeSymbol];
+        if (expressionParams) {
+            Expression.setCurrentScope(expressionParams.type, expressionParams.scope);
+        }
+        return Loader.InitFromData(typeDef, source, object, data);
+    }
+    Replicable.Load = Load;
+    function GetOriginalPropertyValue(object, property) {
+        let typeDef = object[TypeSymbol];
+        return typeDef.getOriginalPropertyValue(object, property);
+    }
+    Replicable.GetOriginalPropertyValue = GetOriginalPropertyValue;
+    function GetChildClassesNames(type) {
+        var _a;
+        let typeDef = (_a = ReplicableRegistry.__GetReplicablesFor(type)) === null || _a === void 0 ? void 0 : _a.filter((e) => !isPrimitiveType(e));
+        if (!typeDef)
+            return [];
+        return typeDef.flatMap((e) => e.getChildClassesNames());
+    }
+    Replicable.GetChildClassesNames = GetChildClassesNames;
+    Replicable.GetClassOfObject = GetClassOfObjectInternal;
+    Replicable.GetDataName = ReplicableRegistry.GetDataName;
+    Replicable.GetTypesForName = ReplicableRegistry.GetTypesForName;
+    Replicable.GetTypeForDataName = ReplicableRegistry.GetTypeForDataName;
+    Replicable.IsType = ReplicableRegistry.IsType;
+    Replicable.getDataNameOfObjectType = ReplicableRegistry.GetDataNameOfObjectType;
+    Replicable.InitialiseData = Definitions.PrePrepareData;
+    Replicable.CanReference = Referencer.CanReference;
+    Replicable.IsReference = Referencer.IsReference;
+    Replicable.Reference = Referencer.Reference;
+    Replicable.Dereference = Referencer.Dereference;
+    Replicable.CompareReferences = Utils.CompareUtils.CompareReferences;
+    Replicable.Serialise = Serialiser.Serialise;
+    Replicable.IsSerialisable = Serialiser.IsSerialisable;
+    Replicable.Deserialise = Serialiser.Deserialise;
+    Replicable.Compare = Utils.CompareUtils.Compare;
+    Replicable.OnReady = ReplicableRegistry.Initialise;
+    Replicable.RegisterTypeAlias = ReplicableRegistry.RegisterTypeAlias;
+    Replicable.ReplaceClass = ReplicableRegistry.ReplaceClass;
+})(Replicable || (Replicable = {}));

package/Tracking/Buffable.d.ts

@@ -0,0 +1,68 @@
+import { Expression } from "../Expressions/Expression.js";
+interface BuffableEvents {
+    onChange: (newVal: number, oldVal: number) => void;
+}
+/**
+ * Similar to Pointer.ts but instead allows values to be altered by "buffs". Replaces the value itself with a
+ * buffable object that has a .val, .raw, .buffs and other useful properties for values that are buffed.
+ * Numbers only would be buffable by default (worked into the replication API).
+ *
+ * NOTE: This is designed to handle only periodic updates. If you want to deal with streaming resources it's
+ * advised to treat the whole value as though it's a streaming value and handle it's application on-tick to the
+ * storage separately.
+ */
+export declare class Buffable {
+    protected original: number | Expression;
+    protected computed: number;
+    protected eventListeners: {
+        onChange: any;
+    };
+    protected resolution: Buffable.MultiBuffResolution;
+    protected buffs: any;
+    get raw(): number;
+    set raw(val: number);
+    get val(): number;
+    set val(val: number);
+    constructor(original: number, resolution?: Buffable.MultiBuffResolution);
+    addEventListener<eventName extends keyof BuffableEvents>(event: eventName, callback: BuffableEvents[eventName]): void;
+    removeEventListener<eventName extends keyof BuffableEvents>(event: eventName, callback: BuffableEvents[eventName]): void;
+    addBuff(source: Buffable.BuffSource): void;
+    removeBuff(source: Buffable.BuffSource): void;
+    protected isResolvedAs(type: Buffable.MultiBuffResolution): boolean;
+    protected calculate(): void;
+}
+export declare namespace Buffable {
+    interface BuffSource {
+        op: Operator;
+        value: number;
+        addEventListener: <eventName extends keyof BuffableEvents>(event: eventName, callback: BuffableEvents[eventName]) => void;
+        removeEventListener: <eventName extends keyof BuffableEvents>(event: eventName, callback: BuffableEvents[eventName]) => void;
+    }
+    /**
+     * Note that only AddBuffs supports multiplication and division.
+     */
+    enum Operator {
+        Replace = 0,
+        Multiply = 1,
+        Divide = 2,
+        Add = 3,
+        Subtract = 4,
+        BuffMultiplier = 5,
+        BuffDivider = 6
+    }
+    /**
+     * Note that only AddBuffs supports multiplication and division, everything else only supports add and subtract.
+     */
+    enum MultiBuffResolution {
+        ApplyAllBuffs = 0,
+        UseAverageBuff = 1,
+        UseHighestBuff = 9,
+        UseLowestBuff = 17,
+        UseAverageDebuff = 64,
+        UseHighestDebuff = 576,
+        UseLowestDebuff = 1088,
+        Average = 65,
+        HighestBuffLowestDebuff = 8465
+    }
+}
+export {};

package/Tracking/Buffable.js

@@ -0,0 +1,194 @@
+import { SmartArray } from "@bikky/smart-collections";
+/**
+ * Similar to Pointer.ts but instead allows values to be altered by "buffs". Replaces the value itself with a
+ * buffable object that has a .val, .raw, .buffs and other useful properties for values that are buffed.
+ * Numbers only would be buffable by default (worked into the replication API).
+ *
+ * NOTE: This is designed to handle only periodic updates. If you want to deal with streaming resources it's
+ * advised to treat the whole value as though it's a streaming value and handle it's application on-tick to the
+ * storage separately.
+ */
+export class Buffable {
+    get raw() {
+        return typeof this.original === "number" ? this.original : this.original.get();
+    }
+    set raw(val) {
+        this.original = val;
+    }
+    get val() {
+        return this.computed;
+    }
+    set val(val) {
+        throw new Error(`Cannot set the value of a buffable object, did you mean to set the raw instead?.`);
+    }
+    constructor(original, resolution = Buffable.MultiBuffResolution.ApplyAllBuffs) {
+        this.eventListeners = {
+            onChange: new SmartArray()
+        };
+        this.resolution = Buffable.MultiBuffResolution.ApplyAllBuffs;
+        this.buffs = new SmartArray();
+        this.original = original;
+        this.resolution = resolution;
+        this.computed = this.raw;
+        this.calculate = this.calculate.bind(this);
+    }
+    addEventListener(event, callback) {
+        this.eventListeners[event].push(callback);
+    }
+    removeEventListener(event, callback) {
+        this.eventListeners[event].remove(callback);
+    }
+    addBuff(source) {
+        this.buffs.push(source);
+        this.buffs = this.buffs.sort((a, b) => a.op - b.op);
+        source.addEventListener("onChange", this.calculate);
+        this.calculate();
+    }
+    removeBuff(source) {
+        this.buffs.remove(source);
+        source.removeEventListener("onChange", this.calculate);
+        this.calculate();
+    }
+    isResolvedAs(type) {
+        return (this.resolution & type) == type;
+    }
+    //Calculate the amount that a buff would currently apply
+    calculate() {
+        let newValue = this.raw;
+        if (this.isResolvedAs(Buffable.MultiBuffResolution.ApplyAllBuffs)) {
+            for (let buff of this.buffs) {
+                switch (buff.op) {
+                    case Buffable.Operator.Replace: {
+                        newValue = buff.value;
+                        break;
+                    }
+                    case Buffable.Operator.Add: {
+                        newValue += buff.value;
+                        break;
+                    }
+                    case Buffable.Operator.Subtract: {
+                        newValue -= buff.value;
+                        break;
+                    }
+                    case Buffable.Operator.Multiply: {
+                        newValue *= buff.value;
+                        break;
+                    }
+                    case Buffable.Operator.Divide: {
+                        newValue /= buff.value;
+                        break;
+                    }
+                    case Buffable.Operator.BuffMultiplier: {
+                        newValue *= buff.value;
+                        break;
+                    }
+                    case Buffable.Operator.BuffDivider: {
+                        newValue /= buff.value;
+                        break;
+                    }
+                }
+            }
+        }
+        if (this.isResolvedAs(Buffable.MultiBuffResolution.UseHighestBuff)) {
+            let val = 0;
+            for (let buff of this.buffs) {
+                if (buff.op != Buffable.Operator.Add)
+                    continue;
+                if (buff.value > val)
+                    val = buff.value;
+            }
+            newValue += val;
+        }
+        else if (this.isResolvedAs(Buffable.MultiBuffResolution.UseLowestBuff)) {
+            if (this.buffs.length > 0) {
+                let val = Number.POSITIVE_INFINITY;
+                for (let buff of this.buffs) {
+                    if (buff.op != Buffable.Operator.Add)
+                        continue;
+                    if (buff.value < val)
+                        val = buff.value;
+                }
+                newValue += val;
+            }
+        }
+        else if (this.isResolvedAs(Buffable.MultiBuffResolution.UseAverageBuff)) {
+            let total = 0;
+            for (let buff of this.buffs) {
+                if (buff.op != Buffable.Operator.Add)
+                    continue;
+                total += buff.value;
+            }
+            newValue += total / this.buffs.length;
+        }
+        if (this.isResolvedAs(Buffable.MultiBuffResolution.UseHighestDebuff)) {
+            let val = 0;
+            for (let buff of this.buffs) {
+                if (buff.op != Buffable.Operator.Subtract)
+                    continue;
+                if (buff.value > val)
+                    val = buff.value;
+            }
+            newValue -= val;
+        }
+        else if (this.isResolvedAs(Buffable.MultiBuffResolution.UseLowestDebuff)) {
+            if (this.buffs.length > 0) {
+                let val = Number.POSITIVE_INFINITY;
+                for (let buff of this.buffs) {
+                    if (buff.op != Buffable.Operator.Subtract)
+                        continue;
+                    if (buff.value < val)
+                        val = buff.value;
+                }
+                newValue -= val;
+            }
+        }
+        else if (this.isResolvedAs(Buffable.MultiBuffResolution.UseAverageDebuff)) {
+            let total = 0;
+            for (let buff of this.buffs) {
+                if (buff.op != Buffable.Operator.Subtract)
+                    continue;
+                total += buff.value;
+            }
+            newValue -= total / this.buffs.length;
+        }
+        if (newValue != this.computed) {
+            let old = this.computed;
+            this.computed = newValue;
+            this.eventListeners.onChange.callEach(old, newValue);
+        }
+    }
+}
+(function (Buffable) {
+    /**
+     * Note that only AddBuffs supports multiplication and division.
+     */
+    let Operator;
+    (function (Operator) {
+        Operator[Operator["Replace"] = 0] = "Replace";
+        Operator[Operator["Multiply"] = 1] = "Multiply";
+        Operator[Operator["Divide"] = 2] = "Divide";
+        Operator[Operator["Add"] = 3] = "Add";
+        Operator[Operator["Subtract"] = 4] = "Subtract";
+        //This one is a bit special, because is read instead of set and it alters the value of every property in the buff.
+        Operator[Operator["BuffMultiplier"] = 5] = "BuffMultiplier";
+        Operator[Operator["BuffDivider"] = 6] = "BuffDivider";
+    })(Operator = Buffable.Operator || (Buffable.Operator = {}));
+    /**
+     * Note that only AddBuffs supports multiplication and division, everything else only supports add and subtract.
+     */
+    let MultiBuffResolution;
+    (function (MultiBuffResolution) {
+        //Just add each buff together.
+        MultiBuffResolution[MultiBuffResolution["ApplyAllBuffs"] = 0] = "ApplyAllBuffs";
+        MultiBuffResolution[MultiBuffResolution["UseAverageBuff"] = 1] = "UseAverageBuff";
+        MultiBuffResolution[MultiBuffResolution["UseHighestBuff"] = 9] = "UseHighestBuff";
+        MultiBuffResolution[MultiBuffResolution["UseLowestBuff"] = 17] = "UseLowestBuff";
+        MultiBuffResolution[MultiBuffResolution["UseAverageDebuff"] = 64] = "UseAverageDebuff";
+        MultiBuffResolution[MultiBuffResolution["UseHighestDebuff"] = 576] = "UseHighestDebuff";
+        MultiBuffResolution[MultiBuffResolution["UseLowestDebuff"] = 1088] = "UseLowestDebuff";
+        //Average buff + average debuff.
+        MultiBuffResolution[MultiBuffResolution["Average"] = 65] = "Average";
+        //Highest buff + lowest debuff.
+        MultiBuffResolution[MultiBuffResolution["HighestBuffLowestDebuff"] = 8465] = "HighestBuffLowestDebuff";
+    })(MultiBuffResolution = Buffable.MultiBuffResolution || (Buffable.MultiBuffResolution = {}));
+})(Buffable || (Buffable = {}));

package/Tracking/Class.d.ts

@@ -0,0 +1,97 @@
+import { ClassCategory, Primitive } from "../Constants/SerialisationTypes.js";
+import { Versions } from "../Constants/Versions.js";
+import type { FunctionOptions } from "./Functions.js";
+import { ComplexPropertyType, PropertyConfiguration, PropertyOptions } from "./Property.js";
+import type { CustomClass, ReplicableClassConstructor, StructClass, TypeClass } from "./Types.js";
+import type { TraversalScope } from "../Expressions/TypeRegistry/Types.js";
+import { ReplAPI } from "../Expressions/TypeRegistry/ReplAPI.js";
+import { ChainType } from "../Expressions/TypeRegistry/ChainTypes.js";
+export interface ReplicableTypeOptions {
+    version: Versions;
+    file?: string;
+    name?: string;
+    dataTypeName?: string;
+    typescriptTypeName?: string;
+    abstract?: boolean;
+}
+export interface RatifiedPropertyOptions extends PropertyOptions {
+    type: ComplexPropertyType[];
+    customDataType?: ComplexPropertyType[];
+}
+export interface PropertyDefinition extends RatifiedPropertyOptions {
+    version: Versions | string;
+    property: string;
+    dataName: string;
+}
+export interface FunctionConfiguration {
+    version: Versions | string;
+    funcName: string;
+    dataName: string;
+    outputType: ComplexPropertyType[];
+    parameters: ComplexPropertyType[][];
+    options: FunctionOptions;
+}
+export interface PropertyRemoved {
+    version: Versions | string;
+    property: string;
+    removed: true;
+    dataName: string;
+    expressionMigration?: (scope: TraversalScope) => any;
+    dataMigration?: (value: any) => [key: string, value: any];
+    type: any[];
+    customDataType?: any[];
+}
+export interface PropertyDoesntExist {
+    version: Versions | string;
+    property: string;
+    doesntExist: true;
+}
+export declare class ReplicableClass {
+    category: ClassCategory;
+    classConstructor: ReplicableClassConstructor;
+    properties: any;
+    functions: any;
+    finalised_properties: Map<string, {
+        [name: string]: PropertyConfiguration | PropertyRemoved | PropertyDoesntExist;
+    }>;
+    finalised_functions: Map<string, {
+        [name: string]: PropertyRemoved | PropertyDoesntExist | FunctionConfiguration;
+    }>;
+    finalised_propertyNames: string[];
+    finalised_functionNames: string[];
+    finalised_ownPropertyNames: string[];
+    finalised_ownFunctionNames: string[];
+    opts: Required<Omit<ReplicableTypeOptions, "name">>;
+    liveIDs: string[];
+    dataIDs: string[];
+    parents: ReplicableClass[];
+    children: any;
+    rule: ReplAPI;
+    constructor(category: ClassCategory, typeClass: ReplicableClassConstructor, opts: ReplicableTypeOptions);
+    getIDAsString(val: any, data?: boolean): string;
+    protected getAppropriateEnclosingRule(): ChainType | undefined;
+    protected removeParentsParentsFromArray(parents: ReplicableClass[]): ReplicableClass[];
+    isObjectOfThisType(object: any): boolean;
+    isChildTypeOfThisType(specificType: any): boolean;
+    getPropDefinition(version: Versions | string, property: string): PropertyConfiguration | PropertyDoesntExist | PropertyRemoved;
+    getPropHistoryDefinition(property: string): {
+        "1.0.0": PropertyConfiguration | PropertyRemoved | PropertyDoesntExist;
+    };
+    addProperty(version: Versions | string, property: string, data: RatifiedPropertyOptions): void;
+    removeProperty(version: Versions | string, property: string, opts: Pick<PropertyRemoved, "type" | "expressionMigration" | "dataMigration" | "customDataType">): void;
+    addFunction(version: Versions | string, funcName: string, outputType: ComplexPropertyType[], parameters: ComplexPropertyType[][], options: FunctionOptions): void;
+    static typesToString(allTypes: (ReplicableClass | Primitive | string)[]): string[];
+    getOriginalPropertyValue(object: any, property: string): any;
+    /**
+     * Used for some fancy Arkhaven type checking.
+     */
+    getChildClassesNames(): any;
+}
+export declare function Type(version: Versions, opts?: Omit<ReplicableTypeOptions, "version" | "file">): (classConstructor: TypeClass) => void;
+export declare function Struct(version: Versions, opts?: Omit<ReplicableTypeOptions, "version" | "file">): (classConstructor: StructClass) => void;
+export declare function CustomReplicableType(version: Versions, _class: CustomClass & {
+    [name: string | symbol]: any;
+}, opts?: Omit<ReplicableTypeOptions, "version" | "file">): CustomClass & {
+    [name: string]: any;
+    [name: symbol]: any;
+};