@bikky/replication 1.0.1

package/__tests__/Replicable.Expressions.test.js

@@ -0,0 +1,166 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { BikPath } from "@bikky/path";
+import { expect, test } from "vitest";
+import { Expression } from "../Expressions/Expression.js";
+import { Property, Struct, Versions } from "../Main.js";
+import { ExpressionScopes } from "../Expressions/TypeRegistry/Registry.js";
+import { Progress } from "../Transformers/Progress.js";
+test("Test create expression to access property on replicable", () => {
+    Progress.ClearCaches();
+    let BaseTest = class BaseTest {
+    };
+    __decorate([
+        Property(Versions.v1_0_0, Number)
+    ], BaseTest.prototype, "test", void 0);
+    BaseTest = __decorate([
+        Struct(Versions.v1_0_0)
+    ], BaseTest);
+    Progress.FinishedAllLoading();
+    ExpressionScopes.addLocalVariable(BaseTest.name, "thisEntity", [BaseTest]);
+    let result = Expression.Parse("@{thisEntity.Test}", BikPath.getCurrentFilepath(), {
+        duringLoad: false,
+        cacheable: true,
+        version: Versions.v1_0_0,
+        startType: BaseTest.name,
+        outputTypes: [Number],
+    });
+    expect(result).not.toBeUndefined();
+});
+test("Get property on replicable via expression.", () => {
+    Progress.ClearCaches();
+    let BaseTestX = class BaseTestX {
+    };
+    __decorate([
+        Property(Versions.v1_0_0, Number)
+    ], BaseTestX.prototype, "test", void 0);
+    BaseTestX = __decorate([
+        Struct(Versions.v1_0_0)
+    ], BaseTestX);
+    Progress.FinishedAllLoading();
+    ExpressionScopes.addLocalVariable(BaseTestX.name, "thisEntity", [BaseTestX]);
+    let result = Expression.Parse("@{thisEntity.Test}", BikPath.getCurrentFilepath(), {
+        duringLoad: false,
+        cacheable: true,
+        version: Versions.v1_0_0,
+        startType: BaseTestX.name,
+        outputTypes: [Number],
+    });
+    expect(result).not.toBeUndefined();
+    let obj = new BaseTestX();
+    obj.test = 4;
+    let outcome = result.get({
+        version: Versions.v1_0_0,
+        data: false,
+        local: {
+            thisEntity: obj
+        },
+        self: obj,
+        global: {}
+    });
+    expect(outcome).toBe(4);
+});
+test("Test calling base property on child class", () => {
+    Progress.ClearCaches();
+    let BaseTest = class BaseTest {
+    };
+    __decorate([
+        Property(Versions.v1_0_0, Number)
+    ], BaseTest.prototype, "test", void 0);
+    BaseTest = __decorate([
+        Struct(Versions.v1_0_0)
+    ], BaseTest);
+    let TestTwo = class TestTwo extends BaseTest {
+    };
+    __decorate([
+        Property(Versions.v1_0_0, Number)
+    ], TestTwo.prototype, "second", void 0);
+    TestTwo = __decorate([
+        Struct(Versions.v1_0_0)
+    ], TestTwo);
+    Progress.FinishedAllLoading();
+    ExpressionScopes.addLocalVariable(BaseTest.name, "thisEntity", [BaseTest]);
+    let result = Expression.Parse("@{thisEntity.Test}", BikPath.getCurrentFilepath(), {
+        duringLoad: false,
+        cacheable: true,
+        version: Versions.v1_0_0,
+        startType: BaseTest.name,
+        outputTypes: [Number],
+    });
+    expect(result).not.toBeUndefined();
+});
+test("Test casting to child class", () => {
+    Progress.ClearCaches();
+    let BaseTest = class BaseTest {
+    };
+    __decorate([
+        Property(Versions.v1_0_0, Number)
+    ], BaseTest.prototype, "test", void 0);
+    BaseTest = __decorate([
+        Struct(Versions.v1_0_0)
+    ], BaseTest);
+    let TestTwo = class TestTwo extends BaseTest {
+    };
+    __decorate([
+        Property(Versions.v1_0_0, Number)
+    ], TestTwo.prototype, "second", void 0);
+    TestTwo = __decorate([
+        Struct(Versions.v1_0_0)
+    ], TestTwo);
+    Progress.FinishedAllLoading();
+    ExpressionScopes.addLocalVariable(BaseTest.name, "thisEntity", [BaseTest]);
+    let result = Expression.Parse("@{thisEntity:TestTwo.Test}", BikPath.getCurrentFilepath(), {
+        duringLoad: false,
+        cacheable: true,
+        version: Versions.v1_0_0,
+        startType: BaseTest.name,
+        outputTypes: [Number],
+    });
+    expect(result).not.toBeUndefined();
+});
+test("Test getting value on child class", () => {
+    Progress.ClearCaches();
+    let BaseTestY = class BaseTestY {
+    };
+    __decorate([
+        Property(Versions.v1_0_0, Number)
+    ], BaseTestY.prototype, "test", void 0);
+    BaseTestY = __decorate([
+        Struct(Versions.v1_0_0)
+    ], BaseTestY);
+    let TestTwo = class TestTwo extends BaseTestY {
+    };
+    __decorate([
+        Property(Versions.v1_0_0, Number)
+    ], TestTwo.prototype, "second", void 0);
+    TestTwo = __decorate([
+        Struct(Versions.v1_0_0)
+    ], TestTwo);
+    Progress.FinishedAllLoading();
+    ExpressionScopes.addLocalVariable(BaseTestY.name, "thisEntity", [BaseTestY]);
+    let result = Expression.Parse("@{thisEntity:TestTwo.Second}", BikPath.getCurrentFilepath(), {
+        duringLoad: false,
+        cacheable: true,
+        version: Versions.v1_0_0,
+        startType: BaseTestY.name,
+        outputTypes: [Number],
+    });
+    expect(result).not.toBeUndefined();
+    let obj = new TestTwo();
+    obj.test = 4;
+    obj.second = 3;
+    let outcome = result.get({
+        version: Versions.v1_0_0,
+        data: false,
+        local: {
+            thisEntity: obj
+        },
+        self: obj,
+        global: {}
+    });
+    expect(outcome).toBe(3);
+});

package/__tests__/Replicable.IDPool.test.d.ts

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

package/__tests__/Replicable.IDPool.test.js

@@ -0,0 +1,11 @@
+import { describe, expect, test } from "vitest";
+import { Progress } from "../Transformers/Progress.js";
+describe("IDPool", () => {
+    test("Registering ID Pool", async () => {
+        const { ReplicableRegistry } = await import("../Constants/ReplicableRegistry.js");
+        await import("../IDPool.js");
+        await ReplicableRegistry.Initialise();
+        Progress.AwaitReplicableFor("UUID");
+        expect(ReplicableRegistry.__GetReplicablesFor("UUID")).not.toBeUndefined();
+    });
+});

package/__tests__/Replicable.ReplicableRegistry.test.d.ts

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

package/__tests__/Replicable.ReplicableRegistry.test.js

@@ -0,0 +1,154 @@
+//<reference path="@bikky/compiler/Libraries/GlobalTypes.d.ts">
+import { WaitableMap } from "@bikky/smart-collections";
+import { beforeAll, expect, test } from "vitest";
+import { ReplicableRegistry } from "../Constants/ReplicableRegistry.js";
+import { AddVersion, Versions } from "../Constants/Versions.js";
+import { Struct, Type } from "../Tracking/Class.js";
+import { Property } from "../Tracking/Property.js";
+import { Progress } from "../Transformers/Progress.js";
+import { Configurer } from "../Transformers/Configurer.js";
+import { fn } from "@vitest/spy";
+let version = "version";
+beforeAll(() => {
+    AddVersion(version, Versions.v1_0_0);
+});
+//TODO: Test multiple aliases for the same type (was broken by overwriting old results with new results when returned from Progress).
+test("Struct is created.", () => {
+    Progress.ClearCaches();
+    class TestStruct {
+    }
+    let edited = Struct(version)(TestStruct);
+    Progress.FinishedAllLoading();
+    expect(edited).not.toBeUndefined();
+    let def = ReplicableRegistry.__GetReplicablesFor(edited)[0];
+    expect(def).not.toBeUndefined();
+    expect(def.opts.dataTypeName).toBe("TestStruct");
+    expect(def.classConstructor).toBe(edited);
+});
+// test("Struct is registered in registry and can be awaited by name.", async () => {
+//     let promise = ReplicableRegistry.__awaitReplicableFor("TestStruct");
+//     class TestStruct {}
+//     let edited = Struct(version)(TestStruct);
+//     await promise;
+//     expect(true).toBe(true);
+// });
+test("Objects can be matched keys in waitmap", async () => {
+    const waitMap = new WaitableMap();
+    class TestStruct {
+    }
+    let promise = waitMap.get(TestStruct);
+    waitMap.resolve(TestStruct, 4);
+    await promise;
+});
+test("Edited classes can be matched keys in waitmap", async () => {
+    const waitMap = new WaitableMap();
+    class TestStruct {
+    }
+    let promise = waitMap.get(TestStruct);
+    let edited = Struct(version)(TestStruct);
+    waitMap.resolve(edited, 4);
+    await promise;
+});
+test("Can register a replicable", async () => {
+    let old = Configurer.CacheClassProperties;
+    let watch = Configurer.CacheClassProperties = fn();
+    Progress.ClearCaches();
+    const testObj = {
+        classConstructor: { name: "Test" },
+        opts: { dataTypeName: "test", typescriptTypeName: "TSTest" },
+        isPrimitive() {
+            return false;
+        },
+        onComplete() { }
+    };
+    Progress.FinishReplicableType(testObj);
+    let promise1 = (Progress.AwaitReplicableFor(testObj.classConstructor));
+    let promise2 = (Progress.AwaitReplicableFor(testObj.opts.dataTypeName));
+    let promise3 = (Progress.AwaitReplicableFor(testObj.opts.typescriptTypeName));
+    Progress.FinishedAllLoading();
+    let result = ReplicableRegistry.__GetReplicablesFor(testObj.classConstructor)[0];
+    expect(result, "Get replicable from class.").toBe(testObj);
+    result = ReplicableRegistry.__GetReplicablesFor(testObj.opts.dataTypeName)[0];
+    expect(result, "Get replicable from data name.").toBe(testObj);
+    result = ReplicableRegistry.__GetReplicablesFor(testObj.opts.typescriptTypeName)[0];
+    expect(result, "Get replicable from class name.").toBe(testObj);
+    let promise1result = await promise1;
+    expect(promise1result[0], "Get replicable from class async before load.").toBe(testObj);
+    let promise2result = await promise2;
+    expect(promise2result[0], "Get replicable from data name async before load.").toBe(testObj);
+    let promise3result = await promise3;
+    expect(promise3result[0], "Get replicable from class name async before load.").toBe(testObj);
+    let afterPromise = (await Progress.AwaitReplicableFor(testObj.classConstructor));
+    expect(afterPromise ? afterPromise[0] : undefined, "Get replicable from class async after load.").toBe(testObj);
+    afterPromise = (await Progress.AwaitReplicableFor(testObj.opts.dataTypeName));
+    expect(afterPromise ? afterPromise[0] : undefined, "Get replicable from data name async after load.").toBe(testObj);
+    afterPromise = (await Progress.AwaitReplicableFor(testObj.opts.typescriptTypeName));
+    expect(afterPromise ? afterPromise[0] : undefined, "Get replicable from class name async after load.").toBe(testObj);
+    Configurer.CacheClassProperties = old;
+});
+test("Struct is registered in registry and can be awaited by returned class.", async () => {
+    Progress.ClearCaches();
+    class TestStruct {
+    }
+    let edited = Struct(version)(TestStruct);
+    setTimeout(Progress.FinishedAllLoading, 1);
+    let promise = Progress.AwaitReplicableFor(edited);
+    await promise;
+    expect(true).toBe(true);
+});
+test("Struct is registered in registry and can be awaited by original class.", async () => {
+    Progress.ClearCaches();
+    class TestStruct {
+    }
+    let promise = Progress.AwaitReplicableFor(TestStruct);
+    let edited = Struct(version)(TestStruct);
+    Progress.FinishedAllLoading();
+    await promise;
+    expect(true).toBe(true);
+});
+test("Property.setParent adds itself to type.", async () => {
+    Progress.ClearCaches();
+    class TestStruct {
+    }
+    let edited = Struct(version)(TestStruct);
+    setTimeout(Progress.FinishedAllLoading, 1);
+    expect(edited).not.toBeUndefined();
+    let def = (await Progress.AwaitReplicableFor(TestStruct))[0];
+    expect([...Object.values(def.properties.all(version))]).toHaveLength(0);
+    def.addProperty(version, "prop", { type: [{ type: [String] }] });
+    expect([...Object.values(def.properties.all(version))]).toHaveLength(1);
+});
+test("Adding @Property to @Struct adds the property to the type's list of properties.", async () => {
+    Progress.ClearCaches();
+    class TestStruct {
+    }
+    let edited = Struct(version)(TestStruct);
+    setTimeout(Progress.FinishedAllLoading, 1);
+    expect(edited).not.toBeUndefined();
+    expect(edited).toBe(TestStruct);
+    let result = Property(version, String)(TestStruct.prototype, "prop");
+    let def = (await Progress.AwaitReplicableFor(TestStruct))[0];
+    await new Promise((res) => setTimeout(res, 10));
+    expect([...Object.values(def.finalised_properties.get(version))]).toHaveLength(1);
+});
+test("Type is created.", () => {
+    Progress.ClearCaches();
+    let TestType = class TestClass {
+    };
+    TestType.Reference = function (value) {
+        return ["First"];
+    };
+    TestType.Dereference = function (value) {
+        return null;
+    };
+    // TestType.IsType = function(value: any): value is TestObject {
+    //     return value instanceof TestType;
+    // }
+    let edited = Type(version)(TestType);
+    Progress.FinishedAllLoading();
+    expect(edited).not.toBeUndefined();
+    let def = ReplicableRegistry.__GetReplicablesFor(edited)[0];
+    expect(def).not.toBeUndefined();
+    expect(def.opts.dataTypeName).toBe("TestClass");
+    expect(def.classConstructor).toBe(edited);
+});

package/__tests__/Replicable.Serialisation.test.d.ts

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

package/__tests__/Replicable.Serialisation.test.js

@@ -0,0 +1,283 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { MixableClass } from "@bikky/compiler/Libraries/MixinCode.mjs";
+import { beforeAll, expect, test } from "vitest";
+import { AddVersion, Versions } from "../Constants/Versions.js";
+import { Replicable } from "../Replicatable.js";
+import { Struct } from "../Tracking/Class.js";
+import { Property } from "../Tracking/Property.js";
+import { Progress } from "../Transformers/Progress.js";
+let version = "version";
+beforeAll(() => {
+    AddVersion(version, Versions.v1_0_0);
+});
+test("Serialise Class", () => {
+    Progress.ClearCaches();
+    let Serialise_Test_1 = class Serialise_Test_1 {
+    };
+    Serialise_Test_1 = __decorate([
+        Struct(version)
+    ], Serialise_Test_1);
+    Progress.FinishedAllLoading();
+    let testObject = new Serialise_Test_1();
+    let serialised = Replicable.Serialise(testObject);
+    expect(serialised).toStrictEqual([Serialise_Test_1.name, { version }]);
+});
+test("Serialise Class with String prop", () => {
+    Progress.ClearCaches();
+    let Serialise_Test_2 = class Serialise_Test_2 {
+        constructor() {
+            this.prop = "Hello";
+        }
+    };
+    __decorate([
+        Property(version, String)
+    ], Serialise_Test_2.prototype, "prop", void 0);
+    Serialise_Test_2 = __decorate([
+        Struct(version)
+    ], Serialise_Test_2);
+    Progress.FinishedAllLoading();
+    let testObject = new Serialise_Test_2();
+    let serialised = Replicable.Serialise(testObject);
+    expect(serialised).toStrictEqual([Serialise_Test_2.name, { prop: ["Primitive", "Hello"], version }]);
+});
+test("Serialise Class with String | Number prop", () => {
+    Progress.ClearCaches();
+    let Serialise_Test_3 = class Serialise_Test_3 {
+        constructor() {
+            this.prop = "Hello";
+        }
+    };
+    __decorate([
+        Property(version, [String, Number])
+    ], Serialise_Test_3.prototype, "prop", void 0);
+    Serialise_Test_3 = __decorate([
+        Struct(version)
+    ], Serialise_Test_3);
+    Progress.FinishedAllLoading();
+    let testObject = new Serialise_Test_3();
+    let serialised = Replicable.Serialise(testObject);
+    expect(serialised).toStrictEqual([Serialise_Test_3.name, { prop: ["Primitive", "Hello"], version }]);
+});
+test("Serialise Class with Dict prop", () => {
+    Progress.ClearCaches();
+    let Serialise_Test_3b = class Serialise_Test_3b {
+        constructor() {
+            this.prop = { hello: "world" };
+        }
+    };
+    __decorate([
+        Property(version, { type: String, dictKey: String })
+    ], Serialise_Test_3b.prototype, "prop", void 0);
+    Serialise_Test_3b = __decorate([
+        Struct(version)
+    ], Serialise_Test_3b);
+    Progress.FinishedAllLoading();
+    let testObject = new Serialise_Test_3b();
+    let serialised = Replicable.Serialise(testObject);
+    expect(serialised).toStrictEqual([Serialise_Test_3b.name, {
+            prop: ["Dict", { hello: ["Primitive", "world"] }],
+            version
+        }]);
+});
+test("Serialise Class with Map prop", () => {
+    Progress.ClearCaches();
+    let Serialise_Test_4 = class Serialise_Test_4 {
+        constructor() {
+            this.prop = new Map([["hello", "world"]]);
+        }
+    };
+    __decorate([
+        Property(version, { type: String, mapKey: String })
+    ], Serialise_Test_4.prototype, "prop", void 0);
+    Serialise_Test_4 = __decorate([
+        Struct(version)
+    ], Serialise_Test_4);
+    Progress.FinishedAllLoading();
+    let testObject = new Serialise_Test_4();
+    let serialised = Replicable.Serialise(testObject);
+    expect(serialised).toStrictEqual([Serialise_Test_4.name, {
+            prop: ["Map", { hello: ["Primitive", "world"] }],
+            version
+        }]);
+});
+test("Serialise Class with Array prop", () => {
+    Progress.ClearCaches();
+    let Serialise_Test_5 = class Serialise_Test_5 {
+        constructor() {
+            this.prop = ["Hello", "World"];
+        }
+    };
+    __decorate([
+        Property(version, { type: String, array: true })
+    ], Serialise_Test_5.prototype, "prop", void 0);
+    Serialise_Test_5 = __decorate([
+        Struct(version)
+    ], Serialise_Test_5);
+    Progress.FinishedAllLoading();
+    let testObject = new Serialise_Test_5();
+    let serialised = Replicable.Serialise(testObject);
+    expect(serialised).toStrictEqual([Serialise_Test_5.name, {
+            prop: ["Array", [["Primitive", "Hello"], ["Primitive", "World"]]],
+            version
+        }]);
+});
+test("Serialise Class with two props", () => {
+    Progress.ClearCaches();
+    let Serialise_Test_6 = class Serialise_Test_6 {
+        constructor() {
+            this.propOne = "Hello";
+            this.propTwo = "World";
+        }
+    };
+    __decorate([
+        Property(version, String)
+    ], Serialise_Test_6.prototype, "propOne", void 0);
+    __decorate([
+        Property(version, String)
+    ], Serialise_Test_6.prototype, "propTwo", void 0);
+    Serialise_Test_6 = __decorate([
+        Struct(version)
+    ], Serialise_Test_6);
+    Progress.FinishedAllLoading();
+    let testObject = new Serialise_Test_6();
+    let serialised = Replicable.Serialise(testObject);
+    expect(serialised).toStrictEqual([Serialise_Test_6.name, {
+            propOne: ["Primitive", "Hello"],
+            propTwo: ["Primitive", "World"],
+            version
+        }]);
+});
+test("Serialise Class with class prop", () => {
+    Progress.ClearCaches();
+    let Serialised_Subtest_6 = class Serialised_Subtest_6 {
+        constructor() {
+            this.propOne = "Hello";
+            this.propTwo = "World";
+        }
+    };
+    __decorate([
+        Property(version, String)
+    ], Serialised_Subtest_6.prototype, "propOne", void 0);
+    __decorate([
+        Property(version, String)
+    ], Serialised_Subtest_6.prototype, "propTwo", void 0);
+    Serialised_Subtest_6 = __decorate([
+        Struct(version)
+    ], Serialised_Subtest_6);
+    let Serialise_Test_6 = class Serialise_Test_6 {
+        constructor() {
+            this.prop = new Serialised_Subtest_6();
+        }
+    };
+    __decorate([
+        Property(version, Serialised_Subtest_6)
+    ], Serialise_Test_6.prototype, "prop", void 0);
+    Serialise_Test_6 = __decorate([
+        Struct(version)
+    ], Serialise_Test_6);
+    Progress.FinishedAllLoading();
+    let testObject = new Serialise_Test_6();
+    let serialised = Replicable.Serialise(testObject);
+    expect(serialised).toStrictEqual([Serialise_Test_6.name,
+        {
+            prop: [Serialised_Subtest_6.name, {
+                    propOne: ["Primitive", "Hello"],
+                    propTwo: ["Primitive", "World"],
+                    version
+                }],
+            version
+        }]);
+});
+test("Serialise Child class with parent and child props", () => {
+    Progress.ClearCaches();
+    let Serialised_ParentTest_7 = class Serialised_ParentTest_7 {
+        constructor() {
+            this.propOne = "Hello";
+        }
+    };
+    __decorate([
+        Property(version, String)
+    ], Serialised_ParentTest_7.prototype, "propOne", void 0);
+    Serialised_ParentTest_7 = __decorate([
+        Struct(version)
+    ], Serialised_ParentTest_7);
+    let Serialise_ChildTest_7 = class Serialise_ChildTest_7 extends Serialised_ParentTest_7 {
+        constructor() {
+            super(...arguments);
+            this.propTwo = "World";
+        }
+    };
+    __decorate([
+        Property(version, String)
+    ], Serialise_ChildTest_7.prototype, "propTwo", void 0);
+    Serialise_ChildTest_7 = __decorate([
+        Struct(version)
+    ], Serialise_ChildTest_7);
+    Progress.FinishedAllLoading();
+    let testObject = new Serialise_ChildTest_7();
+    let serObject = Replicable.Serialise(testObject);
+    expect(serObject).toStrictEqual([
+        Serialise_ChildTest_7.name,
+        {
+            propOne: ["Primitive", "Hello"],
+            propTwo: ["Primitive", "World"],
+            version
+        },
+    ]);
+});
+test("Serialise Child mixin with parent and child prop", () => {
+    Progress.ClearCaches();
+    let Serialised_ParentTest_7 = class Serialised_ParentTest_7 {
+        constructor() {
+            this.propOne = "Hello";
+        }
+    };
+    __decorate([
+        Property(version, String)
+    ], Serialised_ParentTest_7.prototype, "propOne", void 0);
+    Serialised_ParentTest_7 = __decorate([
+        Struct(version)
+    ], Serialised_ParentTest_7);
+    let Serialise_ChildTest_7 = class Serialise_ChildTest_7 extends MixableClass(Serialised_ParentTest_7) {
+        constructor() {
+            super(...arguments);
+            this.propTwo = "World";
+        }
+    };
+    __decorate([
+        Property(version, String)
+    ], Serialise_ChildTest_7.prototype, "propTwo", void 0);
+    Serialise_ChildTest_7 = __decorate([
+        Struct(version)
+    ], Serialise_ChildTest_7);
+    const mixedClass = makeMixer(Serialise_ChildTest_7, Serialised_ParentTest_7)(Serialised_ParentTest_7);
+    let Serialise_FinalTest_7 = class Serialise_FinalTest_7 extends mixedClass {
+        constructor() {
+            super(...arguments);
+            this.propThree = "!";
+        }
+    };
+    __decorate([
+        Property(version, String)
+    ], Serialise_FinalTest_7.prototype, "propThree", void 0);
+    Serialise_FinalTest_7 = __decorate([
+        Struct(version)
+    ], Serialise_FinalTest_7);
+    Progress.FinishedAllLoading();
+    let testObject = new Serialise_FinalTest_7();
+    let serObject = Replicable.Serialise(testObject);
+    expect(serObject).toStrictEqual([
+        Serialise_FinalTest_7.name,
+        {
+            propOne: ["Primitive", "Hello"],
+            propTwo: ["Primitive", "World"],
+            propThree: ["Primitive", "!"],
+            version
+        },
+    ]);
+});

package/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "@bikky/replication",
+  "version": "1.0.1",
+  "description": "A library for handling loading, saving, loading human readable content and transferring information over the network (from server to clients).",
+  "main": "Main.js",
+  "scripts": {
+    "test": "vitest"
+  },
+  "author": "Griffork",
+  "license": "SEE LICENSE IN license.txt",
+  "devDependencies": {
+    "typescript": "^5.8.2"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+    "compileOnSave": true,
+    "compilerOptions": {
+        "module": "esnext",
+        "target": "es2017",
+        "lib": [ "ES2020", "ES2016.Array.Include", "dom" ],
+        "sourceMap": false,
+        "strict": true,
+        "declaration": true,
+        "experimentalDecorators": true,
+        "esModuleInterop": true,
+        "skipDefaultLibCheck": true,
+        "moduleResolution": "Node",
+        "baseUrl": "./"
+    },
+    "exclude": [
+        "**/node_modules"
+    ]
+}