@bikky/replication 1.0.1

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

@@ -0,0 +1,339 @@
+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 { afterAll, beforeAll, describe, expect, test } from "vitest";
+import { Expression, Property, Struct, Versions } from "../../Main.js";
+import { ReplicableRegistry } from "../../Constants/ReplicableRegistry.js";
+import { Loader } from "../Loader.js";
+import { BikPath } from "@bikky/path";
+import { TestPropertyDecorators } from "./Examples.js";
+import { Pointer } from "../Reference.js";
+import { Constructor } from "../Constructor.js";
+import { fn } from "@vitest/spy";
+var TransformersBasicClass = TestPropertyDecorators.TransformersBasicClass;
+var TransformersBasicStruct = TestPropertyDecorators.TransformersBasicStruct;
+import { ExpressionScopes } from "../../Expressions/TypeRegistry/Registry.js";
+var TransformersTheLotClass = TestPropertyDecorators.TransformersTheLotClass;
+import { Definitions } from "../Definitions.js";
+import { Progress } from "../Progress.js";
+import { ErrorStack } from "../../Constants/Errors.js";
+//TODO: Test that ErrorStack is being built the correct direction.
+//TODO: Test that computed defaults are instantiated to the default value.
+//TODO: Test that class' DataIsType is honoured for creation.
+//TODO: Test that class' DataIsType is used as appropriate.
+//TODO: Check that Create function is used as appropriate.
+//TODO: Test that primitive types and custom objects and arrays can be used to instantiate (custom) classes.
+//TODO: Test that instantiating a class with some already loaded properties works fine.
+//TODO: Test that incoming data is valid before loading.
+//TODO: Test expressions as map keys.
+describe.sequential("Loader", 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 objData = { root: example, source: Source, rootRepl: TestRepl };
+    let def = TestRepl.getPropDefinition(Versions.v1_0_0, "val");
+    let propData = { name: "val", dataName: "Val", conf: def };
+    let evalChain = Expression.Parse("@{thisEntity.Val}", BikPath.getCurrentFilepath(), def.expressionForProperty[Source.Version]);
+    let expr = new Expression(evalChain);
+    let def2 = TestRepl.getPropDefinition(Versions.v1_0_0, "val2");
+    let prop2Data = { name: "val2", dataName: "Val2", conf: def2 };
+    let def3 = TestRepl.getPropDefinition(Versions.v1_0_0, "val3");
+    let prop3Data = { name: "val3", dataName: "Val3", conf: def3 };
+    let def4 = TestRepl.getPropDefinition(Versions.v1_0_0, "val4");
+    let prop4Data = { name: "val4", dataName: "Val4", conf: def4 };
+    let def5 = TestRepl.getPropDefinition(Versions.v1_0_0, "val5");
+    let prop5Data = { name: "val5", dataName: "Val5", conf: def5 };
+    let def6 = TestRepl.getPropDefinition(Versions.v1_0_0, "val6");
+    let prop6Data = { name: "val6", dataName: "Val6", conf: def6 };
+    let def7 = TestRepl.getPropDefinition(Versions.v1_0_0, "val7");
+    let prop7Data = { name: "val7", dataName: "Val7", conf: def7 };
+    let def8 = TestRepl.getPropDefinition(Versions.v1_0_0, "val8");
+    let prop8Data = { name: "val8", dataName: "Val8", conf: def8 };
+    let def9 = TestRepl.getPropDefinition(Versions.v1_0_0, "val9");
+    let prop9Data = { name: "val9", dataName: "Val9", conf: def9 };
+    let def10 = TestRepl.getPropDefinition(Versions.v1_0_0, "val10");
+    let prop10Data = { name: "val10", dataName: "Val10", conf: def10 };
+    let def11 = TestRepl.getPropDefinition(Versions.v1_0_0, "val11");
+    let prop11Data = { name: "val11", dataName: "Val11", conf: def11 };
+    let def13 = TestRepl.getPropDefinition(Versions.v1_0_0, "val13");
+    let prop13Data = { name: "val13", dataName: "Val13", conf: def13 };
+    let structObj = new TestPropertyDecorators.TransformersBasicStruct();
+    structObj.val = "test";
+    const StructRepl = ReplicableRegistry.__GetReplicableForDataName(TestPropertyDecorators.TransformersBasicStruct.name);
+    let classObj = new TestPropertyDecorators.TransformersBasicClass();
+    classObj.val = "test";
+    const ClassRepl = ReplicableRegistry.__GetReplicableForDataName(TestPropertyDecorators.TransformersBasicClass.name);
+    let ptr = new Pointer(classObj);
+    let errors = new ErrorStack(Source);
+    describe.sequential("1. LoadSingleValueAsType", () => {
+        let original = Constructor.Construct;
+        let constructResult = null;
+        let constructFoo = fn(() => constructResult);
+        beforeAll(() => {
+            Constructor.Construct = constructFoo;
+        });
+        test(" 1. Load a string property.", () => {
+            let typeDef = propData.conf.load.types[0];
+            expect(Loader.LoadSingleValueAsType(errors, objData, propData, typeDef, typeDef.types[0], JSON.parse(JSON.stringify(TestPropertyDecorators.TransformersTheLotData.Val))))
+                .toBe(TestPropertyDecorators.TransformersTheLotData.Val);
+        });
+        test(" 2. Load a number property.", () => {
+            let typeDef = prop2Data.conf.load.types[0];
+            expect(Loader.LoadSingleValueAsType(errors, objData, prop2Data, typeDef, typeDef.types[0], JSON.parse(JSON.stringify(TestPropertyDecorators.TransformersTheLotData.Val2))))
+                .toBe(TestPropertyDecorators.TransformersTheLotData.Val2);
+        });
+        //Expressions get aliased down to values in this function.
+        test(" 3. Load an expression chain.", () => {
+            let typeDef = propData.conf.load.types[0];
+            expect(Loader.LoadSingleValueAsType(errors, objData, propData, typeDef, typeDef.types[0], evalChain)).toBe("hello");
+        });
+        test(" 4. Load an expression.", () => {
+            let typeDef = propData.conf.load.types[0];
+            expect(Loader.LoadSingleValueAsType(errors, objData, propData, typeDef, typeDef.types[0], expr)).toBe("hello");
+        });
+        test(" 5. Load a struct property.", () => {
+            let typeDef = prop7Data.conf.load.types[0];
+            expect(Loader.LoadSingleValueAsType(errors, objData, prop7Data, typeDef, typeDef.types[0], structObj)).toStrictEqual(structObj);
+        });
+        test(" 6. Load a struct from data", () => {
+            constructFoo.mockClear();
+            constructResult = structObj;
+            let typeDef = prop7Data.conf.load.types[0];
+            expect(Loader.LoadSingleValueAsType(errors, objData, prop7Data, typeDef, typeDef.types[0], { Class: TransformersBasicStruct.name, Val: "test" }))
+                .toBe(structObj);
+            expect(constructFoo).toBeCalledTimes(1);
+            expect(constructFoo).toBeCalledWith(StructRepl, objData.source, objData.root, { Class: TransformersBasicStruct.name, Val: "test" });
+            constructFoo.mockClear();
+        });
+        test(" 7. Load a class property.", () => {
+            let typeDef = prop9Data.conf.load.types[0];
+            expect(Loader.LoadSingleValueAsType(errors, objData, prop9Data, typeDef, typeDef.types[0], classObj)).toStrictEqual(ptr);
+        });
+        test(" 8. Load a class from data", () => {
+            constructFoo.mockClear();
+            constructResult = classObj;
+            let typeDef = prop9Data.conf.load.types[0];
+            let val = { Class: TransformersBasicClass.name, Val: "test" };
+            expect(Loader.LoadSingleValueAsType(errors, objData, prop9Data, typeDef, typeDef.types[0], val)).toStrictEqual(ptr);
+            expect(constructFoo).toBeCalledTimes(1);
+            expect(constructFoo).toBeCalledWith(ClassRepl, objData.source, objData.root, val);
+            constructFoo.mockClear();
+        });
+        test(" 9. Load a pointer property.", () => {
+            let typeDef = prop10Data.conf.load.types[0];
+            expect(Loader.LoadSingleValueAsType(errors, objData, prop10Data, typeDef, typeDef.types[0], ptr)).toStrictEqual(ptr);
+        });
+        test("10. Load an inlined class property.", () => {
+            let typeDef = prop9Data.conf.load.types[0];
+            expect(Loader.LoadSingleValueAsType(errors, objData, prop9Data, typeDef, typeDef.types[0], classObj)).toStrictEqual(ptr);
+        });
+        test("11. Load an inlined class from data", () => {
+            constructFoo.mockClear();
+            constructResult = classObj;
+            let typeDef = prop9Data.conf.load.types[0];
+            expect(Loader.LoadSingleValueAsType(errors, objData, prop9Data, typeDef, typeDef.types[0], { Class: TransformersBasicClass.name, Val: "test" })).toStrictEqual(ptr);
+            expect(constructFoo).toBeCalledTimes(1);
+            expect(constructFoo).toBeCalledWith(ClassRepl, objData.source, objData.root, { Class: TransformersBasicClass.name, Val: "test" });
+            constructFoo.mockClear();
+        });
+        test("12. Load an inlined pointer property.", () => {
+            let typeDef = prop9Data.conf.load.types[0];
+            expect(Loader.LoadSingleValueAsType(errors, objData, prop9Data, typeDef, typeDef.types[0], ptr)).toStrictEqual(ptr);
+        });
+        afterAll(() => {
+            Constructor.Construct = original;
+        });
+    });
+    describe.sequential("2. LoadPropValuesFromData", async () => {
+        let errors = new ErrorStack(Source);
+        let comparison = null;
+        let old = Loader.PerValueCallback;
+        Loader.PerValueCallback = (val, id) => {
+            expect(val).toStrictEqual(comparison);
+            return [val, id];
+        };
+        afterAll(() => {
+            Loader.PerValueCallback = old;
+        });
+        test(" 1. Should return primitive value as-is", async () => {
+            comparison = "value";
+            expect(Loader.LoadPropValuesFromData("value", errors, objData, propData)).toBe("value");
+            comparison = 1;
+            expect(Loader.LoadPropValuesFromData(1, errors, objData, prop2Data)).toBe(1);
+        });
+        test(" 2. Load a map property.", () => {
+            let val3 = JSON.parse(JSON.stringify(TestPropertyDecorators.TransformersTheLotData.Val3));
+            comparison = 1;
+            expect(Loader.LoadPropValuesFromData(val3, errors, objData, prop3Data))
+                .toStrictEqual(new Map([["hello", 1]]));
+            expect(Loader.LoadPropValuesFromData(new Map([["hello", 1]]), errors, objData, prop3Data))
+                .toStrictEqual(new Map([["hello", 1]]));
+        });
+        test(" 3. Load a dict property with a number key type.", () => {
+            let val4 = JSON.parse(JSON.stringify(TestPropertyDecorators.TransformersTheLotData.Val4));
+            comparison = "world";
+            expect(Loader.LoadPropValuesFromData(val4, errors, objData, prop4Data))
+                .toStrictEqual({ 1: "world" });
+        });
+        test(" 4. Load an array property.", () => {
+            let val5 = JSON.parse(JSON.stringify(TestPropertyDecorators.TransformersTheLotData.Val5));
+            comparison = "hello";
+            expect(Loader.LoadPropValuesFromData(val5, errors, objData, prop5Data))
+                .toStrictEqual(["hello"]);
+        });
+        test(" 5. Load a 2D array property.", () => {
+            let val6 = JSON.parse(JSON.stringify(TestPropertyDecorators.TransformersTheLotData.Val6));
+            comparison = 1;
+            expect(Loader.LoadPropValuesFromData(val6, errors, objData, prop6Data))
+                .toStrictEqual([[1, 2]]);
+        });
+    });
+    describe.sequential("3. Combined LoadSingleValueAsType and LoadPropValuesFromData", async () => {
+        let errors = new ErrorStack(Source);
+        test("Load a primitive property.", () => {
+            expect(Loader.LoadPropValuesFromData("value", errors, objData, propData)).toBe("value");
+        });
+        test("Load a map property.", () => {
+            expect(Loader.LoadPropValuesFromData(new Map([["hello", 1]]), errors, objData, prop3Data)).toStrictEqual(new Map([["hello", 1]]));
+        });
+        test("Load a dict into a map property.", () => {
+            expect(Loader.LoadPropValuesFromData({ hello: 1 }, errors, objData, prop3Data)).toStrictEqual(new Map([["hello", 1]]));
+        });
+        test("Load a dict property.", () => {
+            expect(Loader.LoadPropValuesFromData({ 1: "world" }, errors, objData, prop4Data)).toStrictEqual({ 1: "world" });
+        });
+        test("Load an array property.", () => {
+            expect(Loader.LoadPropValuesFromData(["hello"], errors, objData, prop5Data)).toStrictEqual(["hello"]);
+        });
+        test("Load a 2D array property.", () => {
+            expect(Loader.LoadPropValuesFromData([[1, 2]], errors, objData, prop6Data)).toStrictEqual([[1, 2]]);
+        });
+        test("Load a struct property.", () => {
+            expect(Loader.LoadPropValuesFromData(structObj, errors, objData, prop7Data)).toStrictEqual(structObj);
+        });
+        test("Load a class property.", () => {
+            expect(Loader.LoadPropValuesFromData(classObj, errors, objData, prop10Data)).toStrictEqual(ptr);
+        });
+        test("Load a pointer property.", () => {
+            expect(Loader.LoadPropValuesFromData(ptr, errors, objData, prop10Data)).toStrictEqual(ptr);
+        });
+        test("Load an inlined class property.", () => {
+            expect(Loader.LoadPropValuesFromData(classObj, errors, objData, prop9Data)).toStrictEqual(ptr);
+        });
+    });
+    describe.sequential("4. CalcPropInitialValue", async () => {
+        let populatedClass = TransformersTheLotClass.MakeExampleObj();
+        let clearClass = new TransformersTheLotClass();
+        test("Expressions should be evaluated", async () => {
+            expect(Loader.CalcPropInitialValue(objData, "val", evalChain, populatedClass)).toStrictEqual(expr);
+            expect(Loader.CalcPropInitialValue(objData, "val", expr, populatedClass)).toBe(expr);
+            expect(() => Loader.CalcPropInitialValue(objData, "val13", expr, populatedClass)).toThrowError(`${TransformersTheLotClass.name}.val13 does not accept expressions.`);
+        });
+        test("Optional properties should be honoured", () => {
+            expect(Loader.CalcPropInitialValue(objData, "val3", undefined, clearClass)).toStrictEqual(undefined);
+            expect(() => Loader.CalcPropInitialValue(objData, "val", undefined, clearClass)).toThrowError("Object undefined is not a valid value for property TransformersTheLotClass.Val,");
+        });
+        test("Primitives should be returned as-is", async () => {
+            expect(Loader.CalcPropInitialValue(objData, "val", "value", populatedClass)).toBe("value");
+            expect(Loader.CalcPropInitialValue(objData, "val2", 1, populatedClass)).toBe(1);
+        });
+        test("Default assignments should be honoured", () => {
+            expect(Loader.CalcPropInitialValue(objData, "val3", undefined, populatedClass)).toStrictEqual(new Map([["hello", 1]]));
+            expect(Loader.CalcPropInitialValue(objData, "val4", undefined, populatedClass)).toStrictEqual({ 1: "world" });
+            expect(Loader.CalcPropInitialValue(objData, "val5", undefined, populatedClass)).toStrictEqual(["hello"]);
+            expect(Loader.CalcPropInitialValue(objData, "val6", undefined, populatedClass)).toStrictEqual([[1, 2]]);
+        });
+        Progress.ClearCaches();
+        let TransformerDefaults = class TransformerDefaults {
+        };
+        __decorate([
+            Property(Versions.v1_0_0, String, { default: "hello" })
+        ], TransformerDefaults.prototype, "val", void 0);
+        __decorate([
+            Property(Versions.v1_0_0, Number, { default: 1 })
+        ], TransformerDefaults.prototype, "val2", void 0);
+        __decorate([
+            Property(Versions.v1_0_0, { type: Number, mapKey: String }, { default: { hello: 1 } })
+        ], TransformerDefaults.prototype, "val3", void 0);
+        __decorate([
+            Property(Versions.v1_0_0, { type: String, dictKey: Number, restrictedTo: [1, 2, 3] }, { default: { 1: "world" } })
+        ], TransformerDefaults.prototype, "val4", void 0);
+        __decorate([
+            Property(Versions.v1_0_0, { type: String, array: true }, { default: ["hello"] })
+        ], TransformerDefaults.prototype, "val5", void 0);
+        __decorate([
+            Property(Versions.v1_0_0, { type: Number, array: 2 }, { default: [[1, 2]] })
+        ], TransformerDefaults.prototype, "val6", void 0);
+        TransformerDefaults = __decorate([
+            Struct(Versions.v1_0_0)
+        ], TransformerDefaults);
+        Progress.FinishedAllLoading();
+        const DefaultRepl = ReplicableRegistry.__GetReplicableForDataName(TransformerDefaults.name);
+        test("Default property decorators values should be honoured", () => {
+            expect(Loader.CalcPropInitialValue(objData, "val", undefined, populatedClass)).toStrictEqual("hello");
+            expect(Loader.CalcPropInitialValue(objData, "val2", undefined, populatedClass)).toStrictEqual(5);
+            expect(Loader.CalcPropInitialValue(objData, "val3", undefined, populatedClass)).toStrictEqual(new Map([["hello", 1]]));
+            expect(Loader.CalcPropInitialValue(objData, "val4", undefined, populatedClass)).toStrictEqual({ 1: "world" });
+            expect(Loader.CalcPropInitialValue(objData, "val5", undefined, populatedClass)).toStrictEqual(["hello"]);
+            expect(Loader.CalcPropInitialValue(objData, "val6", undefined, populatedClass)).toStrictEqual([[1, 2]]);
+        });
+    });
+    describe.sequential("5. InitFromData", async () => {
+        let populatedClass = TransformersTheLotClass.MakeExampleObj();
+        let clearClass = new TransformersTheLotClass();
+        test("Should init data correctly", () => {
+            expect(Loader.InitFromData(TestRepl, Source, clearClass, JSON.parse(JSON.stringify(TestPropertyDecorators.TransformersTheLotData))))
+                .toStrictEqual(populatedClass);
+        });
+        ExpressionScopes.addLocalVariable("TransformersTheLotClass", "thisEntity", [TransformersTheLotClass]);
+        Expression.setCurrentStartScopeType("TransformersTheLotClass");
+        let example;
+        test.sequential("Should allow for init with live data", () => {
+            let liveData = Object.fromEntries(Object.entries(TestPropertyDecorators.TransformersTheLotData)
+                .map(([key, val]) => [key[0].toUpperCase() + key.slice(1), val]));
+            example = Loader.InitFromData(TestRepl, Source, new TransformersTheLotClass(), liveData);
+            expect(example).toStrictEqual(populatedClass);
+        });
+        test.sequential("Should init expressions correctly", () => {
+            ExpressionScopes.setLocalScope("TransformersTheLotClass", { thisEntity: example });
+            let def = JSON.parse(JSON.stringify(TestPropertyDecorators.TransformersTheLotExpression));
+            def = Definitions.PrePrepareData(TestRepl, def, Source);
+            let result;
+            expect(() => result = Loader.InitFromData(TestRepl, Source, new TransformersTheLotClass(), def)).not.toThrowError();
+            ExpressionScopes.setLocalScope("TransformersTheLotClass", { thisEntity: example });
+            expect(Object.getOwnPropertyDescriptor(result, "val")).not.toBeUndefined();
+            expect(result.val).toBe(example.val);
+            expect(Object.getOwnPropertyDescriptor(result, "val2")).not.toBeUndefined();
+            expect(result.val2).toBe(example.val2);
+            expect(Object.getOwnPropertyDescriptor(result, "val3")).not.toBeUndefined();
+            expect(result.val3).toStrictEqual(example.val3);
+            expect(Object.getOwnPropertyDescriptor(result, "val4")).not.toBeUndefined();
+            expect(result.val4).toStrictEqual(example.val4);
+            expect(Object.getOwnPropertyDescriptor(result, "val5")).not.toBeUndefined();
+            expect(result.val5).toStrictEqual(example.val5);
+            expect(Object.getOwnPropertyDescriptor(result, "val6")).not.toBeUndefined();
+            expect(result.val6).toStrictEqual(example.val6);
+            expect(Object.getOwnPropertyDescriptor(result, "val7")).not.toBeUndefined();
+            expect(result.val7).toBe(example.val7);
+            expect(Object.getOwnPropertyDescriptor(result, "val8")).not.toBeUndefined();
+            expect(result.val8).toBe(example.val8);
+            expect(Object.getOwnPropertyDescriptor(result, "val9")).not.toBeUndefined();
+            expect(result.val9).toBe(example.val9);
+            expect(Object.getOwnPropertyDescriptor(result, "val10")).not.toBeUndefined();
+            expect(result.val10).toBe(example.val10);
+            expect(Object.getOwnPropertyDescriptor(result, "val11")).not.toBeUndefined();
+            expect(result.val11).toBe(example.val11);
+            expect(Object.getOwnPropertyDescriptor(result, "val13")).not.toBeUndefined();
+            expect(result.val13).toStrictEqual(example.val13);
+        });
+    });
+});

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

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

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

@@ -0,0 +1,256 @@
+import { afterAll, afterEach, describe, expect, test } from "vitest";
+import { Progress } from "../Progress.js";
+import { fn } from "@vitest/spy";
+import { Versions } from "../../Constants/Versions.js";
+import { FormatPropInput } from "../../Tracking/Property.js";
+import { SmartArray } from "@bikky/smart-collections";
+import { Configurer } from "../Configurer.js";
+//TODO: Test registering a @DelayUntil class.
+//TODO: Test registering a class that uses a @DelayUntil value.
+//TODO: Test registering a class that uses an alias for a @DelayUntil value.
+//TODO: Test a @DelayUntil class being registered as an alias before and after promise completion.
+//TODO: Test an alias resolving to a @DelayUntil class.
+//TODO: Test an expression using a @DelayUntil type (both navigating to and beyond a property with that type).
+describe.sequential("Progress", () => {
+    let old = Configurer.CacheClassProperties;
+    let watch = Configurer.CacheClassProperties = fn();
+    afterAll(() => {
+        Configurer.CacheClassProperties = old;
+    });
+    afterEach(() => {
+        watch.mockClear();
+    });
+    class FakeReplicableType {
+        constructor(base) {
+            this.opts = { dataTypeName: base.constructor.name };
+            this.addProperty = fn();
+            this.removeProperty = fn();
+            this.addFunction = fn();
+            this.onComplete = fn();
+            this.classConstructor = base;
+        }
+    }
+    function SetupClasses() {
+        class TestStruct {
+        }
+        class Test2Struct {
+        }
+        let repl = new FakeReplicableType(TestStruct);
+        let repl2 = new FakeReplicableType(Test2Struct);
+        return [TestStruct, Test2Struct, repl, repl2];
+    }
+    describe.sequential("1. FinishReplicableType", () => {
+        test.sequential("Register a type with no properties.", () => {
+            Progress.ClearCaches();
+            const [TestStruct, Test2Struct, repl, repl2] = SetupClasses();
+            Progress.FinishReplicableType(repl);
+            Progress.FinishedAllLoading();
+            expect(Configurer.CacheClassProperties).toBeCalledTimes(1);
+        });
+    });
+    describe.sequential("2. RegisterPropertyLoad", () => {
+        test.sequential("1. Register a property on an existing type.", () => {
+            Progress.ClearCaches();
+            const [TestStruct, Test2Struct, repl, repl2] = SetupClasses();
+            Progress.FinishReplicableType(repl);
+            let compType = FormatPropInput(String);
+            Progress.RegisterPropertyLoad(TestStruct, [Versions.v1_0_0, "prop", { type: compType }]);
+            Progress.FinishedAllLoading();
+            expect(repl.addProperty).toBeCalledTimes(1);
+            expect(repl.removeProperty).toBeCalledTimes(0);
+            expect(repl.addFunction).toBeCalledTimes(0);
+            expect(repl.addProperty).toBeCalledWith(Versions.v1_0_0, "prop", { type: compType });
+        });
+        test.sequential("2. Register a property on a new type.", () => {
+            Progress.ClearCaches();
+            const [TestStruct, Test2Struct, repl, repl2] = SetupClasses();
+            Progress.FinishReplicableType(repl);
+            let compType = FormatPropInput(String);
+            Progress.RegisterPropertyLoad(Test2Struct, [Versions.v1_0_0, "prop2", { type: compType }]);
+            Progress.FinishReplicableType(repl2);
+            Progress.FinishedAllLoading();
+            expect(repl2.addProperty).toBeCalledTimes(1);
+            expect(repl2.removeProperty).toBeCalledTimes(0);
+            expect(repl2.addFunction).toBeCalledTimes(0);
+        });
+        test.sequential("3. Register a second property on an existing type.", () => {
+            Progress.ClearCaches();
+            const [TestStruct, Test2Struct, repl, repl2] = SetupClasses();
+            Progress.FinishReplicableType(repl);
+            let compType = FormatPropInput(Number);
+            Progress.RegisterPropertyLoad(TestStruct, [Versions.v1_0_0, "val", { type: compType }]);
+            Progress.FinishedAllLoading();
+            expect(repl.addProperty).toBeCalledTimes(1);
+            expect(repl.removeProperty).toBeCalledTimes(0);
+            expect(repl.addFunction).toBeCalledTimes(0);
+            expect(repl.addProperty).nthCalledWith(1, Versions.v1_0_0, "val", { type: compType });
+        });
+        test.sequential("4. Register a second property on a new type.", () => {
+            Progress.ClearCaches();
+            const [TestStruct, Test2Struct, repl, repl2] = SetupClasses();
+            Progress.FinishReplicableType(repl);
+            let compType = FormatPropInput(Number);
+            Progress.RegisterPropertyLoad(Test2Struct, [Versions.v1_0_0, "prop2", { type: compType }]);
+            Progress.RegisterPropertyLoad(Test2Struct, [Versions.v1_0_0, "val2", { type: compType }]);
+            Progress.FinishReplicableType(repl2);
+            Progress.FinishedAllLoading();
+            expect(repl2.addProperty).toBeCalledTimes(2);
+            expect(repl2.removeProperty).toBeCalledTimes(0);
+            expect(repl2.addFunction).toBeCalledTimes(0);
+        });
+        test.sequential("5. Register a class lookup property on an existing type.", () => {
+            Progress.ClearCaches();
+            const [TestStruct, Test2Struct, repl, repl2] = SetupClasses();
+            Progress.FinishReplicableType(repl);
+            let compType = FormatPropInput(Test2Struct);
+            Progress.RegisterPropertyLoad(TestStruct, [Versions.v1_0_0, "another", { type: compType }]);
+            Progress.FinishedAllLoading();
+            //Add was not called because Test2Struct is not finished.
+            expect(repl.addProperty).toBeCalledTimes(0);
+            expect(repl.removeProperty).toBeCalledTimes(0);
+            expect(repl.addFunction).toBeCalledTimes(0);
+        });
+        test.sequential("6. Register a self lookup property on an existing type.", () => {
+            Progress.ClearCaches();
+            const [TestStruct, Test2Struct, repl, repl2] = SetupClasses();
+            Progress.FinishReplicableType(repl);
+            let compType = FormatPropInput(TestStruct);
+            Progress.RegisterPropertyLoad(TestStruct, [Versions.v1_0_0, "self", { type: compType }]);
+            Progress.FinishedAllLoading();
+            expect(repl.addProperty).toBeCalledTimes(1);
+            expect(repl.removeProperty).toBeCalledTimes(0);
+            expect(repl.addFunction).toBeCalledTimes(0);
+            expect(repl.addProperty).nthCalledWith(1, Versions.v1_0_0, "self", { type: compType });
+        });
+        test.sequential("7. Register a class lookup property on a new type.", () => {
+            Progress.ClearCaches();
+            const [TestStruct, Test2Struct, repl, repl2] = SetupClasses();
+            Progress.FinishReplicableType(repl);
+            let compType = FormatPropInput(TestStruct);
+            Progress.RegisterPropertyLoad(Test2Struct, [Versions.v1_0_0, "prop2", { type: compType }]);
+            Progress.RegisterPropertyLoad(Test2Struct, [Versions.v1_0_0, "val2", { type: compType }]);
+            Progress.RegisterPropertyLoad(Test2Struct, [Versions.v1_0_0, "another2", { type: compType }]);
+            Progress.FinishReplicableType(repl2);
+            Progress.FinishedAllLoading();
+            expect(repl2.addProperty).toBeCalledTimes(3);
+            expect(repl2.removeProperty).toBeCalledTimes(0);
+            expect(repl2.addFunction).toBeCalledTimes(0);
+        });
+    });
+    describe.sequential("3. RegisterFunctionAdd", () => {
+        test.sequential("1. Register a function on an existing type", () => {
+            Progress.ClearCaches();
+            const [TestStruct, Test2Struct, repl, repl2] = SetupClasses();
+            Progress.FinishReplicableType(repl);
+            let returnType = FormatPropInput(String);
+            let params = [FormatPropInput(String)];
+            Progress.RegisterFunctionAdd(TestStruct, [Versions.v1_0_0, "foo", returnType, params, {}]);
+            Progress.FinishedAllLoading();
+            expect(repl.addProperty).toBeCalledTimes(0);
+            expect(repl.removeProperty).toBeCalledTimes(0);
+            expect(repl.addFunction).toBeCalledTimes(1);
+            expect(repl.addFunction).toBeCalledWith(Versions.v1_0_0, "foo", returnType, params, {});
+        });
+        test.sequential("2. Register a function on a new type", () => {
+            Progress.ClearCaches();
+            const [TestStruct, Test2Struct, repl, repl2] = SetupClasses();
+            Progress.FinishReplicableType(repl);
+            let returnType = FormatPropInput(String);
+            let params = [FormatPropInput(String)];
+            Progress.RegisterFunctionAdd(Test2Struct, [Versions.v1_0_0, "foo2", returnType, params, {}]);
+            Progress.FinishReplicableType(repl2);
+            Progress.FinishedAllLoading();
+            expect(repl2.addProperty).toBeCalledTimes(0);
+            expect(repl2.removeProperty).toBeCalledTimes(0);
+            expect(repl2.addFunction).toBeCalledTimes(1);
+        });
+    });
+    test.sequential("4. FinishReplicableType a type with properties pre-registered.", () => {
+        Progress.ClearCaches();
+        const [TestStruct, Test2Struct, repl, repl2] = SetupClasses();
+        Progress.FinishReplicableType(repl);
+        expect(repl2.addProperty).toBeCalledTimes(0);
+        expect(repl2.removeProperty).toBeCalledTimes(0);
+        expect(repl2.addFunction).toBeCalledTimes(0);
+        expect(Configurer.CacheClassProperties).toBeCalledTimes(0);
+        {
+            let compType = FormatPropInput(String);
+            Progress.RegisterPropertyLoad(Test2Struct, [Versions.v1_0_0, "prop2", { type: compType }]);
+        }
+        {
+            let compType = FormatPropInput(Number);
+            Progress.RegisterPropertyLoad(Test2Struct, [Versions.v1_0_0, "val2", { type: compType }]);
+        }
+        {
+            let compType = FormatPropInput(TestStruct);
+            Progress.RegisterPropertyLoad(Test2Struct, [Versions.v1_0_0, "another2", { type: compType }]);
+        }
+        {
+            let returnType = FormatPropInput(String);
+            let params = [FormatPropInput(String)];
+            Progress.RegisterFunctionAdd(Test2Struct, [Versions.v1_0_0, "foo2", returnType, params, {}]);
+        }
+        Progress.FinishReplicableType(repl2);
+        Progress.FinishedAllLoading();
+        expect(repl2.addProperty).toBeCalledTimes(3);
+        expect(repl2.removeProperty).toBeCalledTimes(0);
+        expect(repl2.addFunction).toBeCalledTimes(1);
+        expect(Configurer.CacheClassProperties).toBeCalledTimes(2);
+        let compType = FormatPropInput(String);
+        let numType = FormatPropInput(Number);
+        expect(repl2.addProperty).nthCalledWith(1, Versions.v1_0_0, "prop2", { type: compType });
+        expect(repl2.addProperty).nthCalledWith(2, Versions.v1_0_0, "val2", { type: numType });
+        let returnType = FormatPropInput(String);
+        let params = [FormatPropInput(String)];
+        expect(repl2.addFunction).toBeCalledWith(Versions.v1_0_0, "foo2", returnType, params, {});
+    });
+    test.sequential("5. Make a class that uses an alias", () => {
+        Progress.ClearCaches();
+        class TestStruct {
+        }
+        class TestStruct2 {
+        }
+        class TestStruct3 {
+        }
+        Progress.RegisterPropertyLoad(TestStruct, [Versions.v1_0_0, "test", { type: [{ type: ["MyAlias"] }] }]);
+        Progress.RegisterPropertyLoad(TestStruct2, [Versions.v1_0_0, "bleh", { type: [{ type: [String] }] }]);
+        Progress.RegisterPropertyLoad(TestStruct3, [Versions.v1_0_0, "world", { type: [{ type: [Number] }] }]);
+        let repl = new FakeReplicableType(TestStruct);
+        let repl2 = new FakeReplicableType(TestStruct2);
+        let repl3 = new FakeReplicableType(TestStruct3);
+        Progress.FinishReplicableType(repl);
+        Progress.FinishReplicableType(repl2);
+        Progress.FinishReplicableType(repl3);
+        Progress.RegisterAlias("MyAlias", TestStruct3);
+        Progress.RegisterAlias("MyAlias", TestStruct2);
+        Progress.FinishedAllLoading();
+        Progress.ClearCaches();
+        expect(repl.addProperty).toBeCalledTimes(1);
+        expect(repl.removeProperty).toBeCalledTimes(0);
+        expect(repl.addFunction).toBeCalledTimes(0);
+        expect(repl2.addProperty).toBeCalledTimes(1);
+        expect(repl2.removeProperty).toBeCalledTimes(0);
+        expect(repl2.addFunction).toBeCalledTimes(0);
+        expect(repl3.addProperty).toBeCalledTimes(1);
+        expect(repl3.removeProperty).toBeCalledTimes(0);
+        expect(repl3.addFunction).toBeCalledTimes(0);
+    });
+    test.sequential("6. Await a class' completion", async () => {
+        Progress.ClearCaches();
+        const [TestStruct, Test2Struct, repl, repl2] = SetupClasses();
+        Progress.RegisterPropertyLoad(Test2Struct, [Versions.v1_0_0, "bleh", { type: [{ type: [String] }] }]);
+        Progress.FinishReplicableType(repl);
+        Progress.FinishReplicableType(repl2);
+        let promise1 = Progress.AwaitReplicableFor(TestStruct);
+        let promise2 = Progress.AwaitReplicableFor(Test2Struct);
+        Progress.FinishedAllLoading();
+        expect(promise1.result).toStrictEqual(new SmartArray(repl));
+        expect(promise2.result).toStrictEqual(new SmartArray(repl2));
+        let foo = fn();
+        promise1.then(foo);
+        expect(foo).toBeCalledWith(new SmartArray(repl));
+        let foo2 = fn();
+        promise2.then(foo2);
+        expect(foo2).toBeCalledWith(new SmartArray(repl2));
+    });
+});

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

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