@bikky/replication 1.0.1

package/Tracking/__tests__/Replicable.Tracking.Decorator.test.js

@@ -0,0 +1,151 @@
+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;
+};
+//<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 { Replicable } from "../../Replicatable.js";
+import { Property } from "../Property.js";
+import { Type, Struct, ReplicableClass } from "../Class.js";
+import { Progress } from "../../Transformers/Progress.js";
+let version = "version";
+beforeAll(() => {
+    AddVersion(version, Versions.v1_0_0);
+});
+test("@Struct registers itself in the registry with all aliases.", async () => {
+    Progress.ClearCaches();
+    let TestStruct = class TestStruct {
+    };
+    TestStruct = __decorate([
+        Struct(version, { dataTypeName: "Test_Struct" })
+    ], TestStruct);
+    Progress.FinishedAllLoading();
+    let def = ReplicableRegistry.__GetReplicablesFor(TestStruct)[0];
+    expect(def, "Get replicable from class.").not.toBeUndefined();
+    expect(def).toBeInstanceOf(ReplicableClass);
+    let result = ReplicableRegistry.__GetReplicableForDataName("Test_Struct");
+    expect(result, "Get replicable from data name.").toBe(def);
+    result = ReplicableRegistry.__GetReplicablesFor("TestStruct")[0];
+    expect(result, "Get replicable from class name.").toBe(def);
+    result = (await Progress.AwaitReplicableFor(TestStruct))[0];
+    expect(result, "Get replicable from class async.").toBe(def);
+    // result = await ReplicableRegistry.__awaitReplicableFor("Test_Struct");
+    // expect(result, "Get replicable from data name async.").toBe(def);
+    // result = await ReplicableRegistry.__awaitReplicableFor("TestStruct");
+    // expect(result, "Get replicable from class name async.").toBe(def);
+});
+test("Manually add property to @Struct.", async () => {
+    Progress.ClearCaches();
+    let TestStruct = class TestStruct {
+    };
+    TestStruct = __decorate([
+        Struct(version)
+    ], TestStruct);
+    setTimeout(Progress.FinishedAllLoading, 1);
+    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("@Struct with @Property.", async () => {
+    Progress.ClearCaches();
+    let TestStruct = class TestStruct {
+    };
+    __decorate([
+        Property(version, String)
+    ], TestStruct.prototype, "prop", void 0);
+    TestStruct = __decorate([
+        Struct(version)
+    ], TestStruct);
+    setTimeout(Progress.FinishedAllLoading, 1);
+    let def = (await Progress.AwaitReplicableFor(TestStruct))[0];
+    await new Promise((res) => setTimeout(res, 10));
+    expect([...Object.values(def.finalised_properties.get(version))]).toHaveLength(1);
+});
+let Type_Decorator_Untyped = Type;
+test("@Type.", async () => {
+    Progress.ClearCaches();
+    let TestClass = class TestClass {
+    };
+    TestClass = __decorate([
+        Type_Decorator_Untyped(version)
+    ], TestClass);
+    let TestType = 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;
+    // }
+    setTimeout(Progress.FinishedAllLoading, 1);
+    let def = (await Progress.AwaitReplicableFor(TestType))[0];
+    expect(def).not.toBeUndefined();
+    expect(def.opts.dataTypeName).toBe("TestClass");
+    expect(def.classConstructor).toBe(TestType);
+});
+test("@Type with @Property.", async () => {
+    Progress.ClearCaches();
+    let TestClass = class TestClass {
+    };
+    __decorate([
+        Property(version, String)
+    ], TestClass.prototype, "prop", void 0);
+    TestClass = __decorate([
+        Type_Decorator_Untyped(version)
+    ], TestClass);
+    let TestType = TestClass;
+    TestType.Reference = function (value) {
+        return ["First"];
+    };
+    TestType.Dereference = function (value) {
+        return {};
+    };
+    // TestType.IsType = function(value: any): value is TestObject {
+    //     return value instanceof TestType;
+    // }
+    setTimeout(Progress.FinishedAllLoading, 1);
+    let def = (await Progress.AwaitReplicableFor(TestType))[0];
+    expect([...Object.values(def.finalised_properties.get(version))]).toHaveLength(1);
+});
+test("waitmap resolves correctly", async () => {
+    let map = new WaitableMap();
+    let promise = map.get("test");
+    setTimeout(() => {
+        map.resolve("test", "Hello World!");
+    }, 10);
+    let result = await promise;
+    expect(result).toBe("Hello World!");
+});
+test("waitmap resolves correctly with object keys", async () => {
+    let map = new WaitableMap();
+    let promise = map.get(String);
+    setTimeout(() => {
+        map.resolve(String, "Hello World!");
+    }, 10);
+    let result = await promise;
+    expect(result).toBe("Hello World!");
+});
+test("@Struct with @Property initialisation.", () => {
+    Progress.ClearCaches();
+    let TestClass = class TestClass {
+    };
+    __decorate([
+        Property(version, String)
+    ], TestClass.prototype, "prop", void 0);
+    TestClass = __decorate([
+        Struct(version)
+    ], TestClass);
+    Progress.FinishedAllLoading();
+    let result = Replicable.Create(TestClass, { data: { Class: TestClass.name, Prop: "Hello World!" } });
+    expect(result).not.toBeUndefined();
+    expect(result).instanceOf(TestClass);
+    expect(result.prop).toBe("Hello World!");
+});

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

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

package/Tracking/__tests__/Replicable.Tracking.Deserialisation.test.js

@@ -0,0 +1,253 @@
+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 "../Class.js";
+import { Property } from "../Property.js";
+import { Progress } from "../../Transformers/Progress.js";
+let version = "version";
+beforeAll(() => {
+    AddVersion(version, Versions.v1_0_0);
+});
+test("Deserialise Class", () => {
+    Progress.ClearCaches();
+    let Deserialise_Test_1 = class Deserialise_Test_1 {
+    };
+    Deserialise_Test_1 = __decorate([
+        Struct(version)
+    ], Deserialise_Test_1);
+    Progress.FinishedAllLoading();
+    let testObject = new Deserialise_Test_1();
+    testObject = Replicable.Deserialise(testObject, [Deserialise_Test_1.name, { version }]);
+    expect(testObject).not.toBeUndefined();
+});
+test("Deserialise Class with String prop", () => {
+    Progress.ClearCaches();
+    let Deserialise_Test_2 = class Deserialise_Test_2 {
+    };
+    __decorate([
+        Property(version, String)
+    ], Deserialise_Test_2.prototype, "prop", void 0);
+    Deserialise_Test_2 = __decorate([
+        Struct(version)
+    ], Deserialise_Test_2);
+    Progress.FinishedAllLoading();
+    let testObject = new Deserialise_Test_2();
+    testObject = Replicable.Deserialise(testObject, [Deserialise_Test_2.name, { prop: ["Primitive", "Hello"], version }]);
+    expect(testObject).not.toBeUndefined();
+    expect(testObject.prop).toBe("Hello");
+});
+test("Deserialise Class with String | Number prop", () => {
+    Progress.ClearCaches();
+    let Deserialise_Test_3 = class Deserialise_Test_3 {
+    };
+    __decorate([
+        Property(version, [String, Number])
+    ], Deserialise_Test_3.prototype, "prop", void 0);
+    Deserialise_Test_3 = __decorate([
+        Struct(version)
+    ], Deserialise_Test_3);
+    Progress.FinishedAllLoading();
+    let testObject = new Deserialise_Test_3();
+    testObject = Replicable.Deserialise(testObject, [Deserialise_Test_3.name, { prop: ["Primitive", "Hello"], version }]);
+    expect(testObject).not.toBeUndefined();
+    expect(testObject.prop).toBe("Hello");
+});
+test("Deserialise Class with Dict prop", () => {
+    Progress.ClearCaches();
+    let Deserialise_Test_3b = class Deserialise_Test_3b {
+    };
+    __decorate([
+        Property(version, { type: String, dictKey: String })
+    ], Deserialise_Test_3b.prototype, "prop", void 0);
+    Deserialise_Test_3b = __decorate([
+        Struct(version)
+    ], Deserialise_Test_3b);
+    Progress.FinishedAllLoading();
+    let testObject = new Deserialise_Test_3b();
+    testObject = Replicable.Deserialise(testObject, [Deserialise_Test_3b.name, { prop: ["Dict", { hello: ["Primitive", "world"] }], version }]);
+    expect(testObject).not.toBeUndefined();
+    expect(testObject.prop).toHaveProperty("hello", "world");
+});
+test("Deserialise Class with Map prop", () => {
+    Progress.ClearCaches();
+    let Deserialise_Test_4 = class Deserialise_Test_4 {
+    };
+    __decorate([
+        Property(version, { type: String, mapKey: String })
+    ], Deserialise_Test_4.prototype, "prop", void 0);
+    Deserialise_Test_4 = __decorate([
+        Struct(version)
+    ], Deserialise_Test_4);
+    Progress.FinishedAllLoading();
+    let testObject = new Deserialise_Test_4();
+    testObject = Replicable.Deserialise(testObject, [Deserialise_Test_4.name, { prop: ["Map", { hello: ["Primitive", "world"] }], version }]);
+    expect(testObject).not.toBeUndefined();
+    expect(testObject.prop).toStrictEqual(new Map([["hello", "world"]]));
+});
+test("Deserialise Class with Array prop", () => {
+    Progress.ClearCaches();
+    let Deserialise_Test_4 = class Deserialise_Test_4 {
+    };
+    __decorate([
+        Property(version, { type: String, array: true })
+    ], Deserialise_Test_4.prototype, "prop", void 0);
+    Deserialise_Test_4 = __decorate([
+        Struct(version)
+    ], Deserialise_Test_4);
+    Progress.FinishedAllLoading();
+    let testObject = new Deserialise_Test_4();
+    testObject = Replicable.Deserialise(testObject, [Deserialise_Test_4.name, { prop: ["Array", [["Primitive", "hello"], ["Primitive", "world"]]], version }]);
+    expect(testObject).not.toBeUndefined();
+    expect(testObject).toHaveProperty("prop");
+    expect(testObject.prop).toHaveLength(2);
+    expect(testObject.prop[0]).toBe("hello");
+    expect(testObject.prop[1]).toBe("world");
+});
+test("Deserialise Class with two props", () => {
+    Progress.ClearCaches();
+    let Deserialise_Test_2 = class Deserialise_Test_2 {
+    };
+    __decorate([
+        Property(version, String)
+    ], Deserialise_Test_2.prototype, "propOne", void 0);
+    __decorate([
+        Property(version, String)
+    ], Deserialise_Test_2.prototype, "propTwo", void 0);
+    Deserialise_Test_2 = __decorate([
+        Struct(version)
+    ], Deserialise_Test_2);
+    Progress.FinishedAllLoading();
+    let testObject = new Deserialise_Test_2();
+    testObject = Replicable.Deserialise(testObject, [Deserialise_Test_2.name, { propOne: ["Primitive", "hello"], propTwo: ["Primitive", "world"], version }]);
+    expect(testObject).not.toBeUndefined();
+    expect(testObject).toHaveProperty("propOne");
+    expect(testObject).toHaveProperty("propTwo");
+    expect(testObject.propOne).toBe("hello");
+    expect(testObject.propTwo).toBe("world");
+});
+test("Deserialise Class with class prop", () => {
+    Progress.ClearCaches();
+    let Deserialised_Subtest_6 = class Deserialised_Subtest_6 {
+    };
+    __decorate([
+        Property(version, String)
+    ], Deserialised_Subtest_6.prototype, "propOne", void 0);
+    __decorate([
+        Property(version, String)
+    ], Deserialised_Subtest_6.prototype, "propTwo", void 0);
+    Deserialised_Subtest_6 = __decorate([
+        Struct(version)
+    ], Deserialised_Subtest_6);
+    let Deserialise_Test_6 = class Deserialise_Test_6 {
+        constructor() {
+            this.prop = new Deserialised_Subtest_6();
+        }
+    };
+    __decorate([
+        Property(version, Deserialised_Subtest_6)
+    ], Deserialise_Test_6.prototype, "prop", void 0);
+    Deserialise_Test_6 = __decorate([
+        Struct(version)
+    ], Deserialise_Test_6);
+    Progress.FinishedAllLoading();
+    let testObject = new Deserialise_Test_6();
+    testObject = Replicable.Deserialise(testObject, [Deserialise_Test_6.name,
+        {
+            prop: [Deserialised_Subtest_6.name, {
+                    propOne: ["Primitive", "Hello"],
+                    propTwo: ["Primitive", "World"],
+                    version
+                }],
+            version
+        }]);
+    expect(testObject).not.toBeUndefined();
+    expect(testObject).toHaveProperty("prop");
+    expect(testObject.prop).not.toBeUndefined();
+    expect(testObject.prop).toHaveProperty("propOne");
+    expect(testObject.prop).toHaveProperty("propTwo");
+    expect(testObject.prop.propOne).toBe("Hello");
+    expect(testObject.prop.propTwo).toBe("World");
+});
+test("Deserialise Child class with parent and child props", () => {
+    Progress.ClearCaches();
+    let Deserialised_ParentTest_7 = class Deserialised_ParentTest_7 {
+    };
+    __decorate([
+        Property(version, String)
+    ], Deserialised_ParentTest_7.prototype, "propOne", void 0);
+    Deserialised_ParentTest_7 = __decorate([
+        Struct(version)
+    ], Deserialised_ParentTest_7);
+    let Deserialise_ChildTest_7 = class Deserialise_ChildTest_7 extends Deserialised_ParentTest_7 {
+    };
+    __decorate([
+        Property(version, String)
+    ], Deserialise_ChildTest_7.prototype, "propTwo", void 0);
+    Deserialise_ChildTest_7 = __decorate([
+        Struct(version)
+    ], Deserialise_ChildTest_7);
+    Progress.FinishedAllLoading();
+    let testObject = new Deserialise_ChildTest_7();
+    testObject = Replicable.Deserialise(testObject, [Deserialise_ChildTest_7.name,
+        {
+            propOne: ["Primitive", "Hello"],
+            propTwo: ["Primitive", "World"],
+            version
+        }]);
+    expect(testObject).not.toBeUndefined();
+    expect(testObject).toHaveProperty("propOne");
+    expect(testObject).toHaveProperty("propTwo");
+    expect(testObject.propOne).toBe("Hello");
+    expect(testObject.propTwo).toBe("World");
+});
+test("Deserialise Child mixin with parent and child prop", () => {
+    Progress.ClearCaches();
+    let Deserialised_ParentTest_7 = class Deserialised_ParentTest_7 {
+    };
+    __decorate([
+        Property(version, String)
+    ], Deserialised_ParentTest_7.prototype, "propOne", void 0);
+    Deserialised_ParentTest_7 = __decorate([
+        Struct(version)
+    ], Deserialised_ParentTest_7);
+    let Deserialise_ChildTest_7 = class Deserialise_ChildTest_7 extends MixableClass(Deserialised_ParentTest_7) {
+    };
+    __decorate([
+        Property(version, String)
+    ], Deserialise_ChildTest_7.prototype, "propTwo", void 0);
+    Deserialise_ChildTest_7 = __decorate([
+        Struct(version)
+    ], Deserialise_ChildTest_7);
+    const mixedClass = makeMixer(Deserialise_ChildTest_7, Deserialised_ParentTest_7)(Deserialised_ParentTest_7);
+    let Deserialise_FinalTest_7 = class Deserialise_FinalTest_7 extends mixedClass {
+    };
+    __decorate([
+        Property(version, String)
+    ], Deserialise_FinalTest_7.prototype, "propThree", void 0);
+    Deserialise_FinalTest_7 = __decorate([
+        Struct(version)
+    ], Deserialise_FinalTest_7);
+    Progress.FinishedAllLoading();
+    let testObject = new Deserialise_FinalTest_7();
+    testObject = Replicable.Deserialise(testObject, [Deserialise_FinalTest_7.name,
+        {
+            propOne: ["Primitive", "Hello"],
+            propTwo: ["Primitive", "World"],
+            propThree: ["Primitive", "!"],
+            version
+        }]);
+    expect(testObject).not.toBeUndefined();
+    expect(testObject).toHaveProperty("propOne");
+    expect(testObject).toHaveProperty("propTwo");
+    expect(testObject).toHaveProperty("propThree");
+    expect(testObject.propOne).toBe("Hello");
+    expect(testObject.propTwo).toBe("World");
+    expect(testObject.propThree).toBe("!");
+});

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

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

package/Tracking/__tests__/Replicable.Tracking.MixinSchemaGeneration.test.js

@@ -0,0 +1,135 @@
+import { BikPath } from "@bikky/path";
+import { fn } from "@vitest/spy";
+import { fileURLToPath } from "url";
+import { expect, test } from "vitest";
+import { ReplicableRegistry } from "../../Constants/ReplicableRegistry.js";
+import { SchemaGenerator, Struct, Versions } from "../../Main.js";
+import { Progress } from "../../Transformers/Progress.js";
+let thisFile = BikPath.normalise(fileURLToPath(import.meta.url).replace(".test.ts", ".gen.js"));
+Progress.ClearCaches();
+//Load some precompiled javascript with mixins.
+let [A, B, C, D, E, Final] = new Function("Struct", "Versions", `
+"use strict";
+
+class A {
+    method(input) {
+        input.splice(input.indexOf(0), 1);
+        return input;
+    }
+    method2(input) {
+        input.splice(input.indexOf(0), 1);
+        return input;
+    }
+    method3(input) {
+        input.splice(input.indexOf(0), 1);
+        return input;
+    }
+}
+Struct(Versions.v1_0_0)(A);
+
+
+var Super_0 = Symbol("super_B");
+class B extends Mixable((A)) {
+    method(input) {
+        input.splice(input.indexOf(1), 1);
+        return this[Super_0].method ? (this[Super_0].method.call(this, input)) : (input);
+    }
+}
+B.Super = Super_0;
+Struct(Versions.v1_0_0)(B);
+(function (B) {
+    B.mix = makeMixer(B, A);
+})(B || (B = {}));
+
+
+var Super_1 = Symbol("super_C");
+class C extends Mixable((A)) {
+    method(input) {
+        input.splice(input.indexOf(2), 1);
+        return this[Super_1].method ? (this[Super_1].method.call(this, input)) : (input);
+    }
+    method2(input) {
+        input.splice(input.indexOf(2), 1);
+        return this[Super_1].method2 ? (this[Super_1].method2.call(this, input)) : (input);
+    }
+    method3(input) {
+        input.splice(input.indexOf(2), 1);
+        return this[Super_1].method3 ? (this[Super_1].method3.call(this, input)) : (input);
+    }
+}
+C.Super = Super_1;
+Struct(Versions.v1_0_0)(C);
+(function (C) {
+    C.mix = makeMixer(C, A);
+})(C || (C = {}));
+
+
+var Super_2 = Symbol("super_D");
+class D extends Mixable((A)) {
+    method(input) {
+        input.splice(input.indexOf(3), 1);
+        return this[Super_2].method ? (this[Super_2].method.call(this, input)) : (input);
+    }
+}
+D.Super = Super_2;
+Struct(Versions.v1_0_0)(D);
+(function (D) {
+    D.mix = makeMixer(D, A);
+})(D || (D = {}));
+
+
+var Super_3 = Symbol("super_E");
+class E extends Mixable((A)) {
+    method(input) {
+        input.splice(input.indexOf(4), 1);
+        return this[Super_3].method ? (this[Super_3].method.call(this, input)) : (input);
+    }
+}
+Struct(Versions.v1_0_0)(E);
+E.Super = Super_3;
+(function (E) {
+    E.mix = makeMixer(E, A);
+})(E || (E = {}));
+
+
+class Final extends E.mix(D.mix(C.mix(B.mix(A)))) {
+    method(input) {
+        input.push(6);
+        return super.method(input);
+    }
+    method2(input) {
+        input.push(6);
+        return super.method2(input);
+    }
+}
+Struct(Versions.v1_0_0)(Final);
+
+return [A, B, C, D, E, Final];
+//# sourceMappingURL=${thisFile}
+//# sourceURL=${thisFile}
+`)(Struct, Versions);
+Progress.FinishedAllLoading();
+test("Test that a class that inherits from multiple mixins will initialise correctly.", async () => {
+    console.log(thisFile);
+    let details = ReplicableRegistry.__GetReplicablesFor(Final)[0];
+    expect([B, C, D, E]
+        .every((e) => details.parents
+        .some((f) => f.classConstructor == e))).toBe(true);
+    expect(details.parents.some((e) => e.classConstructor == A)).toBe(false);
+    await ReplicableRegistry.Initialise();
+    let options = {
+        open: fn((file) => {
+            expect(file).toBe(thisFile.replace(".gen.js", ".gen.data.d.ts"));
+            return true;
+        }),
+        write: fn((file, text) => {
+            expect(text).toContain(`
+export interface FinalDefinition extends Omit<BDefinition, "Class">, Omit<CDefinition, "Class">, Omit<DDefinition, "Class">, Omit<EDefinition, "Class"> {
+            `.trim());
+            return true;
+        })
+    };
+    SchemaGenerator.GenerateAllInterfaceTypes(Versions.v1_0_0, options);
+    expect(options.open).toBeCalledTimes(1);
+    expect(options.write).toBeCalledTimes(1);
+});

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

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

package/Tracking/__tests__/Replicable.Tracking.Struct.test.js

@@ -0,0 +1,66 @@
+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;
+};
+//<reference path="@bikky/compiler/Libraries/GlobalTypes.d.ts">
+import { beforeEach, expect, test } from "vitest";
+import { ReplicableRegistry } from "../../Constants/ReplicableRegistry.js";
+import { AddVersion, ClearVersions, Versions } from "../../Constants/Versions.js";
+import { Replicable } from "../../Replicatable.js";
+import { Struct } from "../Class.js";
+import { Property } from "../Property.js";
+import { Progress } from "../../Transformers/Progress.js";
+let version = "version";
+beforeEach(() => {
+    ClearVersions();
+    AddVersion(version, Versions.v1_0_0);
+});
+test("@Struct with @Property.", async () => {
+    Progress.ClearCaches();
+    let TestStruct = class TestStruct {
+    };
+    __decorate([
+        Property(version, String)
+    ], TestStruct.prototype, "prop", void 0);
+    TestStruct = __decorate([
+        Struct(version)
+    ], TestStruct);
+    Progress.FinishedAllLoading();
+    let def = await Progress.AwaitReplicableFor(TestStruct);
+    await new Promise((res) => setTimeout(res, 10));
+    expect([...Object.values(def[0].finalised_properties.get(version))]).toHaveLength(1);
+});
+test("Create @Struct with @Property.", async () => {
+    Progress.ClearCaches();
+    let TestStruct = class TestStruct {
+    };
+    __decorate([
+        Property(version, String)
+    ], TestStruct.prototype, "prop", void 0);
+    TestStruct = __decorate([
+        Struct(version)
+    ], TestStruct);
+    Progress.FinishedAllLoading();
+    await ReplicableRegistry.Initialise();
+    let val = Replicable.Create(TestStruct, { data: { Class: TestStruct.name, Prop: "Test" } });
+    expect(val.prop).toBe("Test");
+});
+test("Create @Struct with @Property with constructor.", async () => {
+    Progress.ClearCaches();
+    let TestStruct = class TestStruct {
+        constructor() {
+        }
+    };
+    __decorate([
+        Property(version, String)
+    ], TestStruct.prototype, "prop", void 0);
+    TestStruct = __decorate([
+        Struct(version)
+    ], TestStruct);
+    Progress.FinishedAllLoading();
+    await ReplicableRegistry.Initialise();
+    let val = Replicable.Create(TestStruct, { data: { Class: TestStruct.name, Prop: "Test" } });
+    expect(val.prop).toBe("Test");
+});

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

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

package/Tracking/__tests__/Replicable.Tracking.Type.test.js

@@ -0,0 +1,67 @@
+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;
+};
+//<reference path="@bikky/compiler/Libraries/GlobalTypes.d.ts">
+import { beforeEach, expect, test } from "vitest";
+import { AddVersion, ClearVersions, Versions } from "../../Constants/Versions.js";
+import { Type } from "../Class.js";
+import { Property } from "../Property.js";
+import { Progress } from "../../Transformers/Progress.js";
+//TODO: Test isChildTypeOfThisType works with mixins properly.
+//TODO: Test getOriginalValue works. Atm it's just a reference to the value - should it be a deep copy?
+let version = "version";
+let Type_Decorator_Untyped = Type;
+beforeEach(() => {
+    ClearVersions();
+    AddVersion(version, Versions.v1_0_0);
+});
+test("@Type.", async () => {
+    Progress.ClearCaches();
+    let TestClass = class TestClass {
+    };
+    TestClass = __decorate([
+        Type_Decorator_Untyped(version)
+    ], TestClass);
+    let TestType = 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;
+    // }
+    Progress.FinishedAllLoading();
+    let def = (await Progress.AwaitReplicableFor(TestType))[0];
+    expect(def).not.toBeUndefined();
+    expect(def.opts.dataTypeName).toBe("TestClass");
+    expect(def.classConstructor).toBe(TestType);
+});
+test("@Type with @Property.", async () => {
+    Progress.ClearCaches();
+    let TestClass = class TestClass {
+    };
+    __decorate([
+        Property(version, String)
+    ], TestClass.prototype, "prop", void 0);
+    TestClass = __decorate([
+        Type_Decorator_Untyped(version)
+    ], TestClass);
+    let TestType = TestClass;
+    TestType.Reference = function (value) {
+        return ["First"];
+    };
+    TestType.Dereference = function (value) {
+        return {};
+    };
+    // TestType.IsType = function(value: any): value is TestObject {
+    //     return value instanceof TestType;
+    // }
+    setTimeout(Progress.FinishedAllLoading, 1);
+    let def = (await Progress.AwaitReplicableFor(TestType))[0];
+    expect([...Object.values(def.finalised_properties.get(version))]).toHaveLength(1);
+});