@bikky/replication 1.0.1

package/Transformers/__tests__/Replicable.Transformers.Reference.test.js

@@ -0,0 +1,167 @@
+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 { describe, expect, test } from "vitest";
+import { Property, Referencer, Struct, Type, Versions } from "../../Main.js";
+import { Pointer } from "../Reference.js";
+import { Progress } from "../Progress.js";
+//TODO: Test referencing & dereferencing custom types that are represented by strings in code (e.g. UUID).
+// 		And have custom reference/dereference functions.
+describe.sequential("Referencer", () => {
+    Progress.ClearCaches();
+    class TestRefClass {
+    }
+    __decorate([
+        Property(Versions.v1_0_0, String)
+    ], TestRefClass.prototype, "val", void 0);
+    let classDef = TestRefClass;
+    classDef.Reference = (obj) => {
+        return [obj.val];
+    };
+    classDef.Dereference = (data) => {
+        let obj = new TestRefClass();
+        obj.val = data[0];
+        return obj;
+    };
+    Type(Versions.v1_0_0)(classDef);
+    let TestRefStructClass = class TestRefStructClass {
+    };
+    __decorate([
+        Property(Versions.v1_0_0, String)
+    ], TestRefStructClass.prototype, "val2", void 0);
+    TestRefStructClass = __decorate([
+        Struct(Versions.v1_0_0)
+    ], TestRefStructClass);
+    Progress.FinishedAllLoading();
+    let validVal = new TestRefClass();
+    validVal.val = "test";
+    let invalidVal = new TestRefStructClass();
+    invalidVal.val2 = "test";
+    test.sequential("Get valid reference for TestRefClass", () => {
+        let ref = Referencer.Reference(validVal);
+        expect(ref).toContainAtLeast([TestRefClass.name, "test"]);
+    });
+    test.sequential("Try get invalid reference for TestRefStructClass", () => {
+        expect(() => Referencer.Reference(invalidVal))
+            .toThrowError(`Tried to create a reference for a TestRefStructClass which doesn't support references.`);
+    });
+    test.sequential("Can reference TestRefClass", () => {
+        expect(Referencer.CanReference(validVal)).toBe(true);
+    });
+    test.sequential("Cannot reference TestRefStructClass", () => {
+        expect(Referencer.CanReference(invalidVal)).toBe(false);
+    });
+    test.sequential("Is not reference for unknown class", () => {
+        expect(Referencer.CanReference({ debugName: "UnknownClass" }))
+            .toBe(false);
+    });
+    test.sequential("Non-arrays are not references", () => {
+        expect(Referencer.IsReference("test")).toBe(false);
+    });
+    test.sequential("Is reference for TestRefClass", () => {
+        expect(Referencer.IsReference([TestRefClass.name, "test"])).toBe(true);
+    });
+    test.sequential("Is not reference for TestRefStructClass", () => {
+        expect(Referencer.IsReference([TestRefStructClass.name, "test"])).toBe(false);
+    });
+    test.sequential("Is not reference for unknown class", () => {
+        expect(Referencer.IsReference(["UnknownClass", "test"]))
+            .toBe(false);
+    });
+    test.sequential("Dereference TestRefClass", () => {
+        let obj = Referencer.Dereference([TestRefClass.name, "test"]);
+        expect(obj).toBeDefined();
+        expect(obj.val).toBe("test");
+    });
+    test.sequential("Dereference an invalid reference", () => {
+        expect(() => Referencer.Dereference(["UnknownClass", "test"]))
+            .toThrowError("Tried to dereference UnknownClass which is an unregistered/non-replicable type.");
+    });
+});
+describe.sequential("Pointer", () => {
+    Progress.ClearCaches();
+    let validVal;
+    let invalidVal;
+    class TestPointerClass {
+    }
+    __decorate([
+        Property(Versions.v1_0_0, String)
+    ], TestPointerClass.prototype, "val", void 0);
+    let classDef = TestPointerClass;
+    classDef.Reference = (obj) => {
+        return [obj.val];
+    };
+    classDef.Dereference = (data) => {
+        if (data[0] == validVal.val) {
+            return validVal;
+        }
+        return null;
+        // let obj = new TestPointerClass();
+        // obj.val = data[0];
+        // return obj;
+    };
+    Type(Versions.v1_0_0)(classDef);
+    let TestStructClass = class TestStructClass {
+    };
+    __decorate([
+        Property(Versions.v1_0_0, String)
+    ], TestStructClass.prototype, "val2", void 0);
+    TestStructClass = __decorate([
+        Struct(Versions.v1_0_0)
+    ], TestStructClass);
+    Progress.FinishedAllLoading();
+    validVal = new TestPointerClass();
+    validVal.val = "test";
+    invalidVal = new TestStructClass();
+    invalidVal.val2 = "test2";
+    let secondaryVal = new TestPointerClass();
+    secondaryVal.val = "test3";
+    test.sequential("Create empty Pointer", () => {
+        let ptr = new Pointer();
+        expect(ptr).toBeDefined();
+        expect(() => ptr.val).toThrowError(`Cannot get value before value is set!`);
+        expect(ptr.ref).toBe(null);
+        expect(ptr.valOrNull).toBeNull();
+    });
+    test.sequential("Create new Pointer", () => {
+        let ptr = new Pointer(validVal);
+        expect(ptr).toBeDefined();
+        expect(ptr.val).toBe(validVal);
+        expect(ptr.val.val).toBe("test");
+        expect(ptr.ref).toContainAtLeast([TestPointerClass.name, "test"]);
+        expect(ptr.valOrNull).toBe(validVal);
+    });
+    test.sequential("Create new Pointer from Reference", () => {
+        let ptr = new Pointer();
+        ptr.ref = [TestPointerClass.name, "test"];
+        expect(ptr).toBeDefined();
+        expect(ptr.val).toBe(validVal);
+        expect(ptr.ref).toContainAtLeast([TestPointerClass.name, "test"]);
+        expect(ptr.valOrNull).toBe(validVal);
+    });
+    test.sequential("Create new Pointer from Reference in valOrNull", () => {
+        let ptr = new Pointer();
+        ptr.ref = [TestPointerClass.name, "test"];
+        expect(ptr).toBeDefined();
+        //Call valOrNull first so it's forced to do the lookup instead of .val
+        expect(ptr.valOrNull).toBe(validVal);
+    });
+    test.sequential("Create new Pointer from Reference that doesn't exist", () => {
+        let ptr = new Pointer();
+        ptr.ref = [TestPointerClass.name, "test2"];
+        expect(ptr).toBeDefined();
+        expect(() => ptr.val).toThrowError(`Attempt to access invalid value.`);
+        expect(ptr.ref).toContainAtLeast([TestPointerClass.name, "test2"]);
+        expect(ptr.valOrNull).toBeNull();
+    });
+    test.sequential("Change ptr from A to B", () => {
+        let ptr = new Pointer(secondaryVal);
+        Referencer.UpdateReferences(ptr.ref, [TestPointerClass.name, "test"]);
+        expect(ptr.val).toBe(validVal);
+        expect(ptr.ref).toContainAtLeast([TestPointerClass.name, "test"]);
+        expect(ptr.valOrNull).toBe(validVal);
+    });
+});

package/Transformers/__tests__/Replicable.Transformers.SchemaGenerator.test.d.ts

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

package/Transformers/__tests__/Replicable.Transformers.SchemaGenerator.test.js

@@ -0,0 +1,400 @@
+import { describe, expect, test } from "vitest";
+import { GeneratorUtilities } from "../SchemaGenerator.js";
+import { ReplicableRegistry } from "../../Constants/ReplicableRegistry.js";
+import { TestPropertyDecorators } from "./Examples.js";
+import { BikPath } from "@bikky/path";
+import { Expression, Versions } from "../../Main.js";
+import { ExpressionScopes } from "../../Expressions/TypeRegistry/Registry.js";
+var TransformersTheLotClass = TestPropertyDecorators.TransformersTheLotClass;
+import { SetMap } from "@bikky/smart-collections";
+var TransformersBasicStruct = TestPropertyDecorators.TransformersBasicStruct;
+var TransformersBasicClass = TestPropertyDecorators.TransformersBasicClass;
+var TransformersBasicChild = TestPropertyDecorators.TransformersBasicChild;
+//TODO: Test expressions as map keys.
+//TODO: Test serialised values allow null.
+//TODO: Test serialised values allow child class names.
+describe("SchemaGenerator", async () => {
+    const TestRepl = ReplicableRegistry.__GetReplicableForDataName(TestPropertyDecorators.TransformersTheLotClass.name);
+    const Source = {
+        SourceFile: BikPath.getCurrentFilepath(),
+        Version: Versions.v1_0_0
+    };
+    ExpressionScopes.addLocalVariable("TransformersTheLotClass", "thisEntity", [TransformersTheLotClass]);
+    Expression.setCurrentStartScopeType("TransformersTheLotClass");
+    let example = TransformersTheLotClass.MakeExampleObj();
+    ExpressionScopes.setLocalScope("TransformersTheLotClass", { thisEntity: example });
+    let def = TestRepl.getPropDefinition(Versions.v1_0_0, "val");
+    // let info = Utils.GetPropertyDecoratorTypesInfo(def, TestPropertyDecorators.TransformersTheLotClass.name)!;
+    let config = def.expressionForProperty[Versions.v1_0_0];
+    let evalChain = Expression.Parse("${thisEntity.Val}", BikPath.getCurrentFilepath(), config);
+    let expr = new Expression(evalChain);
+    let def2 = TestRepl.getPropDefinition(Versions.v1_0_0, "val2");
+    // let info2 = Utils.GetPropertyDecoratorTypesInfo(def2, TestPropertyDecorators.TransformersTheLotClass.name)!;
+    let def3 = TestRepl.getPropDefinition(Versions.v1_0_0, "val3");
+    // let info3 = Utils.GetPropertyDecoratorTypesInfo(def3, TestPropertyDecorators.TransformersTheLotClass.name)!;
+    let def4 = TestRepl.getPropDefinition(Versions.v1_0_0, "val4");
+    // let info4 = Utils.GetPropertyDecoratorTypesInfo(def4, TestPropertyDecorators.TransformersTheLotClass.name)!;
+    let def5 = TestRepl.getPropDefinition(Versions.v1_0_0, "val5");
+    // let info5 = Utils.GetPropertyDecoratorTypesInfo(def5, TestPropertyDecorators.TransformersTheLotClass.name)!;
+    let def6 = TestRepl.getPropDefinition(Versions.v1_0_0, "val6");
+    // let info6 = Utils.GetPropertyDecoratorTypesInfo(def6, TestPropertyDecorators.TransformersTheLotClass.name)!;
+    let def7 = TestRepl.getPropDefinition(Versions.v1_0_0, "val7");
+    // let info7 = Utils.GetPropertyDecoratorTypesInfo(def7, TestPropertyDecorators.TransformersTheLotClass.name)!;
+    let def8 = TestRepl.getPropDefinition(Versions.v1_0_0, "val8");
+    // let info8 = Utils.GetPropertyDecoratorTypesInfo(def8, TestPropertyDecorators.TransformersTheLotClass.name)!;
+    let def9 = TestRepl.getPropDefinition(Versions.v1_0_0, "val9");
+    // let info9 = Utils.GetPropertyDecoratorTypesInfo(def9, TestPropertyDecorators.TransformersTheLotClass.name)!;
+    let def10 = TestRepl.getPropDefinition(Versions.v1_0_0, "val10");
+    // let info10 = Utils.GetPropertyDecoratorTypesInfo(def10, TestPropertyDecorators.TransformersTheLotClass.name)!;
+    let def11 = TestRepl.getPropDefinition(Versions.v1_0_0, "val11");
+    // let info11 = Utils.GetPropertyDecoratorTypesInfo(def11, TestPropertyDecorators.TransformersTheLotClass.name)!;
+    let def13 = TestRepl.getPropDefinition(Versions.v1_0_0, "val13");
+    // let info13 = Utils.GetPropertyDecoratorTypesInfo(def13, TestPropertyDecorators.TransformersTheLotClass.name)!;
+    function getRepls(def) {
+        return def.types.flatMap((e) => e.types);
+    }
+    test("1. ExpressionString", () => {
+        expect(GeneratorUtilities.ExpressionString).toBe("`@{${string}}`");
+        expect(GeneratorUtilities.SerialisedExpressionString).toBe(`[ "Expression", string ]`);
+    });
+    describe("2. GenerateSingleValue", () => {
+        let gen = { blocks: [], includes: new SetMap() };
+        test(" 1. Plain values definition.", () => {
+            expect(GeneratorUtilities.GenerateValueGroup(TestRepl.opts.dataTypeName, getRepls(def.load), gen, false, "definition"))
+                .toBe(`string`);
+            expect(GeneratorUtilities.GenerateValueGroup(TestRepl.opts.dataTypeName, getRepls(def2.serialisation), gen, false, "definition"))
+                .toBe(`number | undefined`);
+        });
+        test(" 2. Plain values serialised.", () => {
+            expect(GeneratorUtilities.GenerateValueGroup(TestRepl.opts.dataTypeName, getRepls(def.load), gen, false, "serialised"))
+                .toBe(`[ "Primitive", string ]`);
+            expect(GeneratorUtilities.GenerateValueGroup(TestRepl.opts.dataTypeName, getRepls(def2.serialisation), gen, false, "serialised"))
+                .toBe(`[ "Primitive", number | undefined ]`);
+        });
+        test(" 3. Map values.", () => {
+            expect(GeneratorUtilities.GenerateValueGroup(TestRepl.opts.dataTypeName, getRepls(def3.load), gen, false, "definition"))
+                .toBe(`number`);
+            expect(GeneratorUtilities.GenerateValueGroup(TestRepl.opts.dataTypeName, getRepls(def3.serialisation), gen, false, "serialised"))
+                .toBe(`[ "Primitive", number | undefined ]`);
+        });
+        test(" 4. Dict values.", () => {
+            expect(GeneratorUtilities.GenerateValueGroup(TestRepl.opts.dataTypeName, getRepls(def4.load), gen, false, "definition"))
+                .toBe(`string`);
+            expect(GeneratorUtilities.GenerateValueGroup(TestRepl.opts.dataTypeName, getRepls(def4.serialisation), gen, false, "serialised"))
+                .toBe(`[ "Primitive", string | undefined ]`);
+        });
+        test(" 5. Array values.", () => {
+            expect(GeneratorUtilities.GenerateValueGroup(TestRepl.opts.dataTypeName, getRepls(def5.load), gen, false, "definition"))
+                .toBe(`string`);
+            expect(GeneratorUtilities.GenerateValueGroup(TestRepl.opts.dataTypeName, getRepls(def5.serialisation), gen, false, "serialised"))
+                .toBe(`[ "Primitive", string ]`);
+        });
+        test(" 6. Array2 values.", () => {
+            expect(GeneratorUtilities.GenerateValueGroup(TestRepl.opts.dataTypeName, getRepls(def6.load), gen, false, "definition"))
+                .toBe(`number`);
+            expect(GeneratorUtilities.GenerateValueGroup(TestRepl.opts.dataTypeName, getRepls(def6.serialisation), gen, false, "serialised"))
+                .toBe(`[ "Primitive", number ]`);
+        });
+        test(" 7. Struct values.", () => {
+            expect(GeneratorUtilities.GenerateValueGroup(TestRepl.opts.dataTypeName, getRepls(def7.load), gen, false, "definition"))
+                .toBe(`${TransformersBasicStruct.name}Definition`);
+            expect(GeneratorUtilities.GenerateValueGroup(TestRepl.opts.dataTypeName, getRepls(def7.serialisation), gen, false, "serialised"))
+                .toBe(`[ "${TransformersBasicStruct.name}" | string, ${TransformersBasicStruct.name}Serialised | null ]`);
+        });
+        test(" 8. Inline class values.", () => {
+            expect(GeneratorUtilities.GenerateValueGroup(TestRepl.opts.dataTypeName, getRepls(def9.load), gen, true, "definition"))
+                .toBe(`${TransformersBasicClass.name}Definition`);
+            expect(GeneratorUtilities.GenerateValueGroup(TestRepl.opts.dataTypeName, getRepls(def9.serialisation), gen, true, "serialised"))
+                .toBe(`[ "${TransformersBasicClass.name}" | string, ${TransformersBasicClass.name}Serialised | null ]`);
+        });
+        test(" 9. Class values.", () => {
+            expect(GeneratorUtilities.GenerateValueGroup(TestRepl.opts.dataTypeName, getRepls(def10.load), gen, false, "definition"))
+                .toBe(`${TransformersBasicClass.name}Definition`);
+            expect(GeneratorUtilities.GenerateValueGroup(TestRepl.opts.dataTypeName, getRepls(def10.serialisation), gen, false, "serialised"))
+                .toBe(`${TransformersBasicClass.name}SerialisedReference`);
+        });
+    });
+    describe("3. Generate Property", () => {
+        test(" 1. Plain value.", () => {
+            let gen = { blocks: [], includes: new SetMap() };
+            GeneratorUtilities.GenerateProperty(TestRepl.opts.dataTypeName, def, gen, "definition");
+            expect(gen.blocks[0])
+                .toBe(`\tVal: string | ${GeneratorUtilities.ExpressionString};`);
+            GeneratorUtilities.GenerateProperty(TestRepl.opts.dataTypeName, def, gen, "serialised");
+            expect(gen.blocks[1])
+                .toBe(`\tval: [ "Primitive", string ] | ${GeneratorUtilities.SerialisedExpressionString};`);
+        });
+        test(" 2. Optional value.", () => {
+            let gen = { blocks: [], includes: new SetMap() };
+            GeneratorUtilities.GenerateProperty(TestRepl.opts.dataTypeName, def2, gen, "definition");
+            expect(gen.blocks[0])
+                .toBe(`\tVal2?: number | ${GeneratorUtilities.ExpressionString};`);
+            GeneratorUtilities.GenerateProperty(TestRepl.opts.dataTypeName, def2, gen, "serialised");
+            expect(gen.blocks[1])
+                .toBe(`\tval2: [ "Primitive", number ] | [ "Primitive", undefined ] | ${GeneratorUtilities.SerialisedExpressionString};`);
+        });
+        test(" 3. Map values.", () => {
+            let gen = { blocks: [], includes: new SetMap() };
+            GeneratorUtilities.GenerateProperty(TestRepl.opts.dataTypeName, def3, gen, "definition");
+            expect(gen.blocks[0])
+                .toBe(`\tVal3?: {[key: string]: (number | ${GeneratorUtilities.ExpressionString})} | ` + GeneratorUtilities.ExpressionString + `;`);
+            GeneratorUtilities.GenerateProperty(TestRepl.opts.dataTypeName, def3, gen, "serialised");
+            expect(gen.blocks[1])
+                .toBe(`\tval3: [ "Map", {[key: string]: ([ "Primitive", number ] | ${GeneratorUtilities.SerialisedExpressionString})} ] | [ "Primitive", undefined ] | ${GeneratorUtilities.SerialisedExpressionString};`);
+        });
+        test(" 4. Dict values.", () => {
+            let gen = { blocks: [], includes: new SetMap() };
+            GeneratorUtilities.GenerateProperty(TestRepl.opts.dataTypeName, def4, gen, "definition");
+            expect(gen.blocks[0])
+                .toBe(`\tVal4?: {[key in 1 | 2 | 3]: (string | ${GeneratorUtilities.ExpressionString})} | ` + GeneratorUtilities.ExpressionString + `;`);
+            GeneratorUtilities.GenerateProperty(TestRepl.opts.dataTypeName, def4, gen, "serialised");
+            expect(gen.blocks[1])
+                .toBe(`\tval4: [ "Dict", {[key in 1 | 2 | 3]: ([ "Primitive", string ] | ${GeneratorUtilities.SerialisedExpressionString})} ] | [ "Primitive", undefined ] | ${GeneratorUtilities.SerialisedExpressionString};`);
+        });
+        test(" 5. Array values.", () => {
+            let gen = { blocks: [], includes: new SetMap() };
+            GeneratorUtilities.GenerateProperty(TestRepl.opts.dataTypeName, def5, gen, "definition");
+            expect(gen.blocks[0])
+                .toBe(`\tVal5: (string | ${GeneratorUtilities.ExpressionString})[] | ${GeneratorUtilities.ExpressionString};`);
+            GeneratorUtilities.GenerateProperty(TestRepl.opts.dataTypeName, def5, gen, "serialised");
+            expect(gen.blocks[1])
+                .toBe(`\tval5: [ "Array", ([ "Primitive", string ] | ${GeneratorUtilities.SerialisedExpressionString})[] ] | ${GeneratorUtilities.SerialisedExpressionString};`);
+        });
+        test(" 6. Array2 values.", () => {
+            let gen = { blocks: [], includes: new SetMap() };
+            GeneratorUtilities.GenerateProperty(TestRepl.opts.dataTypeName, def6, gen, "definition");
+            expect(gen.blocks[0])
+                .toBe(`\tVal6: (number | ${GeneratorUtilities.ExpressionString})[][] | ${GeneratorUtilities.ExpressionString};`);
+            GeneratorUtilities.GenerateProperty(TestRepl.opts.dataTypeName, def6, gen, "serialised");
+            expect(gen.blocks[1])
+                .toBe(`\tval6: [ "Array2", ([ "Primitive", number ] | ${GeneratorUtilities.SerialisedExpressionString})[][] ] | ${GeneratorUtilities.SerialisedExpressionString};`);
+        });
+        test(" 7. Struct values.", () => {
+            let gen = { blocks: [], includes: new SetMap() };
+            GeneratorUtilities.GenerateProperty(TestRepl.opts.dataTypeName, def7, gen, "definition");
+            expect(gen.blocks[0])
+                .toBe(`\tVal7: ${TransformersBasicStruct.name}Definition | ` + GeneratorUtilities.ExpressionString + `;`);
+            GeneratorUtilities.GenerateProperty(TestRepl.opts.dataTypeName, def7, gen, "serialised");
+            expect(gen.blocks[1])
+                .toBe(`\tval7: [ "${TransformersBasicStruct.name}" | string, ${TransformersBasicStruct.name}Serialised | null ] | ${GeneratorUtilities.SerialisedExpressionString};`);
+        });
+        test(" 8. Inline class values.", () => {
+            let gen = { blocks: [], includes: new SetMap() };
+            GeneratorUtilities.GenerateProperty(TestRepl.opts.dataTypeName, def9, gen, "definition");
+            expect(gen.blocks[0])
+                .toBe(`\tVal9: ${TransformersBasicClass.name}Definition | ` + GeneratorUtilities.ExpressionString + `;`);
+            GeneratorUtilities.GenerateProperty(TestRepl.opts.dataTypeName, def9, gen, "serialised");
+            expect(gen.blocks[1])
+                .toBe(`\tval9: [ "${TransformersBasicClass.name}" | string, ${TransformersBasicClass.name}Serialised | null ] | ${GeneratorUtilities.SerialisedExpressionString};`);
+        });
+        test(" 9. Class values.", () => {
+            let gen = { blocks: [], includes: new SetMap() };
+            GeneratorUtilities.GenerateProperty(TestRepl.opts.dataTypeName, def10, gen, "definition");
+            expect(gen.blocks[0])
+                .toBe(`\tVal10: ${TransformersBasicClass.name}Definition | ` + GeneratorUtilities.ExpressionString + `;`);
+            GeneratorUtilities.GenerateProperty(TestRepl.opts.dataTypeName, def10, gen, "serialised");
+            expect(gen.blocks[1])
+                .toBe(`\tval10: ${TransformersBasicClass.name}SerialisedReference | ${GeneratorUtilities.SerialisedExpressionString};`);
+        });
+        test("10. No expressions", () => {
+            let gen = { blocks: [], includes: new SetMap() };
+            GeneratorUtilities.GenerateProperty(TestRepl.opts.dataTypeName, def13, gen, "definition");
+            expect(gen.blocks[0])
+                .toBe(`\tVal13: number[][];`);
+            GeneratorUtilities.GenerateProperty(TestRepl.opts.dataTypeName, def13, gen, "serialised");
+            expect(gen.blocks[1])
+                .toBe(`\tval13: [ "Array2", [ "Primitive", number ][][] ];`);
+        });
+    });
+    describe("4. Generate Class", () => {
+        let includeDataFile = BikPath.join(BikPath.dir(BikPath.getCurrentFilepath()), "./Examples.data.d.ts").replace(/\//g, "\\");
+        let includeClassFile = BikPath.join(BikPath.dir(BikPath.getCurrentFilepath()), "./Examples.ts").replace(/\//g, "\\");
+        test("Class definition", () => {
+            let expr = GeneratorUtilities.ExpressionString;
+            let gen = { blocks: [], includes: new SetMap() };
+            GeneratorUtilities.GenerateClass(TestRepl, gen, "definition");
+            expect(gen.blocks[0])
+                .toBe(`export interface ${TestRepl.opts.dataTypeName}Definition {
+					Class: "${TransformersTheLotClass.name}";
+					Val: string | ${expr};
+					Val10: ${TransformersBasicClass.name}Definition | ${expr};
+					Val11: string | ${expr};
+					Val13: number[][];
+					Val2?: number | ${expr};
+					Val3?: {[key: string]: (number | ${expr})} | ${expr};
+					Val4?: {[key in 1 | 2 | 3]: (string | ${expr})} | ${expr};
+					Val5: (string | ${expr})[] | ${expr};
+					Val6: (number | ${expr})[][] | ${expr};
+					Val7: ${TransformersBasicStruct.name}Definition | ${expr};
+					Val8: null | number | string | ${expr};
+					Val9: ${TransformersBasicClass.name}Definition | ${expr};
+				}`.replace(/^\t{4}/gm, ""));
+            let imports = new SetMap();
+            imports.push(includeDataFile, TransformersBasicClass.name + "Definition");
+            imports.push(includeDataFile, TransformersBasicStruct.name + "Definition");
+            expect(gen.includes).toStrictEqual(imports);
+        });
+        test("Class serialised", () => {
+            let expr = GeneratorUtilities.SerialisedExpressionString;
+            let gen = { blocks: [], includes: new SetMap() };
+            GeneratorUtilities.GenerateClass(TestRepl, gen, "serialised");
+            expect(gen.blocks[0])
+                .toBe(`export interface ${TestRepl.opts.dataTypeName}Serialised {
+					version: string;
+					val: [ "Primitive", string ] | ${expr};
+					val10: ${TransformersBasicClass.name}SerialisedReference | ${expr};
+					val13: [ "Array2", [ "Primitive", number ][][] ];
+					val14: [ "Primitive", number ] | ${expr};
+					val2: [ "Primitive", number ] | [ "Primitive", undefined ] | ${expr};
+					val3: [ "Map", {[key: string]: ([ "Primitive", number ] | ${expr})} ] | [ "Primitive", undefined ] | ${expr};
+					val4: [ "Dict", {[key in 1 | 2 | 3]: ([ "Primitive", string ] | ${expr})} ] | [ "Primitive", undefined ] | ${expr};
+					val5: [ "Array", ([ "Primitive", string ] | ${expr})[] ] | ${expr};
+					val6: [ "Array2", ([ "Primitive", number ] | ${expr})[][] ] | ${expr};
+					val7: [ "${TransformersBasicStruct.name}" | string, ${TransformersBasicStruct.name}Serialised | null ] | ${expr};
+					val8: [ "Primitive", null ] | [ "Primitive", number ] | [ "Primitive", string ] | ${expr};
+					val9: [ "${TransformersBasicClass.name}" | string, ${TransformersBasicClass.name}Serialised | null ] | ${expr};
+				}`.replace(/^\t{4}/gm, ""));
+            let imports = new SetMap();
+            imports.push(includeDataFile, TransformersBasicClass.name + "Serialised");
+            imports.push(includeDataFile, TransformersBasicClass.name + "SerialisedReference");
+            imports.push(includeDataFile, TransformersBasicStruct.name + "Serialised");
+            expect(gen.includes).toStrictEqual(imports);
+        });
+        test("Class creation", () => {
+            let expr = GeneratorUtilities.ExpressionString;
+            let gen = { blocks: [], includes: new SetMap() };
+            GeneratorUtilities.GenerateClass(TestRepl, gen, "creation");
+            expect(gen.blocks[0])
+                .toBe(`export interface ${TestRepl.opts.dataTypeName}Creation {
+					Val: string | ${expr};
+					Val10: ${TransformersBasicClass.name} | ${TransformersBasicClass.name}Definition | ${expr};
+					Val11: string | ${expr};
+					Val13: number[][];
+					Val2?: number | ${expr};
+					Val3?: {[key: string]: (number | ${expr})} | Map<string, (number)> | ${expr};
+					Val4?: {[key in 1 | 2 | 3]: (string | ${expr})} | ${expr};
+					Val5: (string | ${expr})[] | ${expr};
+					Val6: (number | ${expr})[][] | ${expr};
+					Val7: ${TransformersBasicStruct.name} | ${TransformersBasicStruct.name}Definition | ${expr};
+					Val8: null | number | string | ${expr};
+					Val9: ${TransformersBasicClass.name} | ${TransformersBasicClass.name}Definition | ${expr};
+				}`.replace(/^\t{4}/gm, ""));
+            let imports = new SetMap();
+            imports.push(includeDataFile, TransformersBasicClass.name + "Definition");
+            imports.push(includeDataFile, TransformersBasicStruct.name + "Definition");
+            imports.push(includeClassFile, TransformersBasicClass.name);
+            imports.push(includeClassFile, TransformersBasicStruct.name);
+            expect(gen.includes).toStrictEqual(imports);
+        });
+    });
+    describe("5. GenerateClassExtends", () => {
+        const ChildRepl = ReplicableRegistry.__GetReplicableForDataName(TransformersBasicChild.name);
+        let importPath1 = BikPath.join(BikPath.dir(BikPath.getCurrentFilepath()), "./Examples.data.d.ts").replace(/\//g, "\\");
+        let importPath2 = BikPath.join(BikPath.dir(BikPath.getCurrentFilepath()), "./ExampleTerritories.ts").replace(/\//g, "\\");
+        test("Class extends for definition", () => {
+            let includes = new SetMap();
+            let extend = GeneratorUtilities.GenerateClassExtends(ChildRepl, includes, "definition");
+            expect(extend).toBe(`extends Omit<${TestRepl.opts.dataTypeName}Definition, "Class"> `);
+            let imports = new SetMap();
+            imports.push(importPath1, TestRepl.opts.dataTypeName + "Definition");
+            expect(includes).toStrictEqual(imports);
+        });
+        test("Class extends for serialised", () => {
+            let includes = new SetMap();
+            let extend = GeneratorUtilities.GenerateClassExtends(ChildRepl, includes, "serialised");
+            expect(extend).toBe(`extends ${TestRepl.opts.dataTypeName}Serialised `);
+            let imports = new SetMap();
+            imports.push(importPath1, TestRepl.opts.dataTypeName + "Serialised");
+            expect(includes).toStrictEqual(imports);
+        });
+        test("Class extends for creation", () => {
+            let includes = new SetMap();
+            let extend = GeneratorUtilities.GenerateClassExtends(ChildRepl, includes, "creation");
+            expect(extend).toBe(`extends ${TestRepl.opts.dataTypeName}Creation `);
+            let imports = new SetMap();
+            imports.push(importPath1, TestRepl.opts.dataTypeName + "Creation");
+            expect(includes).toStrictEqual(imports);
+        });
+    });
+    describe("6. GenerateDefinitionFile", () => {
+        let startPath = BikPath.join(BikPath.dir(BikPath.fsStyle(import.meta.url)), "./Examples.js").replace(/\//g, "\\");
+        let includeClassFile = "./Examples.js";
+        let expr = GeneratorUtilities.ExpressionString;
+        let sExpr = GeneratorUtilities.SerialisedExpressionString;
+        const MatchMultipleBlankLines = /(?:\n\t*)(?:\n\t*)+/g;
+        test("Definition file with the lot", () => {
+            let text = GeneratorUtilities.GenerateDefinitionFile(startPath, [TestRepl], undefined);
+            expect(text.trim().replace(MatchMultipleBlankLines, "\n")).toBe(`
+				import { ${TransformersBasicClass.name}, ${TransformersBasicStruct.name} } from "${includeClassFile}";
+				${GeneratorUtilities.DefinitionForward}
+				export interface ${TestRepl.opts.dataTypeName}Definition {
+					Class: "${TransformersTheLotClass.name}";
+					Val: string | ${expr};
+					Val10: ${TransformersBasicClass.name}Definition | ${expr};
+					Val11: string | ${expr};
+					Val13: number[][];
+					Val2?: number | ${expr};
+					Val3?: {[key: string]: (number | ${expr})} | ${expr};
+					Val4?: {[key in 1 | 2 | 3]: (string | ${expr})} | ${expr};
+					Val5: (string | ${expr})[] | ${expr};
+					Val6: (number | ${expr})[][] | ${expr};
+					Val7: ${TransformersBasicStruct.name}Definition | ${expr};
+					Val8: null | number | string | ${expr};
+					Val9: ${TransformersBasicClass.name}Definition | ${expr};
+				}
+				export interface ${TestRepl.opts.dataTypeName}Serialised {
+					version: string;
+					val: [ "Primitive", string ] | ${sExpr};
+					val10: ${TransformersBasicClass.name}SerialisedReference | ${sExpr};
+					val13: [ "Array2", [ "Primitive", number ][][] ];
+					val14: [ "Primitive", number ] | ${sExpr};
+					val2: [ "Primitive", number ] | [ "Primitive", undefined ] | ${sExpr};
+					val3: [ "Map", {[key: string]: ([ "Primitive", number ] | ${sExpr})} ] | [ "Primitive", undefined ] | ${sExpr};
+					val4: [ "Dict", {[key in 1 | 2 | 3]: ([ "Primitive", string ] | ${sExpr})} ] | [ "Primitive", undefined ] | ${sExpr};
+					val5: [ "Array", ([ "Primitive", string ] | ${sExpr})[] ] | ${sExpr};
+					val6: [ "Array2", ([ "Primitive", number ] | ${sExpr})[][] ] | ${sExpr};
+					val7: [ "${TransformersBasicStruct.name}" | string, ${TransformersBasicStruct.name}Serialised | null ] | ${sExpr};
+					val8: [ "Primitive", null ] | [ "Primitive", number ] | [ "Primitive", string ] | ${sExpr};
+					val9: [ "${TransformersBasicClass.name}" | string, ${TransformersBasicClass.name}Serialised | null ] | ${sExpr};
+				}
+				export type ${TestRepl.opts.dataTypeName}SerialisedReference = [ string, ...(string | number)[] ];
+				export interface ${TestRepl.opts.dataTypeName}Creation {
+					Val: string | ${expr};
+					Val10: ${TransformersBasicClass.name} | ${TransformersBasicClass.name}Definition | ${expr};
+					Val11: string | ${expr};
+					Val13: number[][];
+					Val2?: number | ${expr};
+					Val3?: {[key: string]: (number | ${expr})} | Map<string, (number)> | ${expr};
+					Val4?: {[key in 1 | 2 | 3]: (string | ${expr})} | ${expr};
+					Val5: (string | ${expr})[] | ${expr};
+					Val6: (number | ${expr})[][] | ${expr};
+					Val7: ${TransformersBasicStruct.name} | ${TransformersBasicStruct.name}Definition | ${expr};
+					Val8: null | number | string | ${expr};
+					Val9: ${TransformersBasicClass.name} | ${TransformersBasicClass.name}Definition | ${expr};
+				}
+				`.replace(/^\t{4}/gm, "").trim());
+        });
+        const ChildRepl = ReplicableRegistry.__GetReplicableForDataName(TransformersBasicChild.name);
+        let importPath1 = BikPath.join(BikPath.dir(BikPath.getCurrentFilepath()), "./Examples.data.d.ts").replace(/\//g, "\\");
+        let importPath2 = BikPath.join(BikPath.dir(BikPath.getCurrentFilepath()), "./Examples.ts").replace(/\//g, "\\");
+        test("Definition file with child", () => {
+            let text = GeneratorUtilities.GenerateDefinitionFile(startPath, [ChildRepl], undefined);
+            expect(text.trim().replace(MatchMultipleBlankLines, "\n")).toBe(`
+				// This file is automatically generated. Do not edit it, all edits will be overwritten on compile.// This file contains the typescript types for the data definitions for the corresponding 
+				// types in the .ts file this file is named after.
+				export interface ${TransformersBasicChild.name}Definition extends Omit<${TransformersTheLotClass.name}Definition, "Class"> {
+					Class: "${TransformersBasicChild.name}";
+					ValX: string | ${expr};
+				}
+				export interface ${TransformersBasicChild.name}Serialised extends ${TransformersTheLotClass.name}Serialised {
+					version: string;
+					valX: [ "Primitive", string ] | [ "Expression", string ];
+				}
+				export type ${TransformersBasicChild.name}SerialisedReference = [ string, ${TransformersBasicChild.name}Serialised ];
+				export interface ${TransformersBasicChild.name}Creation extends ${TransformersTheLotClass.name}Creation {
+					ValX: string | ${expr};
+				}
+				`.replace(/^\t{4}/gm, "").trim());
+        });
+    });
+});

package/Transformers/__tests__/Replicable.Transformers.SchemaGeneratorOutput.test.d.ts

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