@directivegames/genesys.js 3.1.24

package/dist/test/serialization-v1.test.js

@@ -0,0 +1,1057 @@
+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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+var _a;
+import * as esbuild from 'esbuild-wasm';
+import * as ENGINE from 'genesys.js';
+import { property } from 'genesys.js';
+import { JSDOM } from 'jsdom';
+import * as THREE from 'three';
+import { mockBrowserEnvironment } from '../src/utils/NodeJs.js';
+import { NodeStorageProvider } from './nodeStorage.js';
+const version = {
+    $version: ENGINE.SerializationVersion.V1,
+};
+// a data class with some @property decorated properties
+// meaning it can be serialized automatically with only those properties marked @property
+class TestData {
+    constructor(a, b) {
+        Object.defineProperty(this, "a", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "b", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "c", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        this.a = a;
+        this.b = b;
+    }
+}
+__decorate([
+    property(),
+    __metadata("design:type", Number)
+], TestData.prototype, "a", void 0);
+__decorate([
+    property(),
+    __metadata("design:type", String)
+], TestData.prototype, "b", void 0);
+// a base class with some @property decorated properties
+class Base {
+    constructor(num, str, bool) {
+        Object.defineProperty(this, "num", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "str", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "complex", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "bool", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.num = num;
+        this.str = str;
+        this.bool = bool;
+    }
+}
+__decorate([
+    property({ default: 0 }),
+    __metadata("design:type", Number)
+], Base.prototype, "num", void 0);
+__decorate([
+    property(),
+    __metadata("design:type", String)
+], Base.prototype, "str", void 0);
+__decorate([
+    property(),
+    __metadata("design:type", Object)
+], Base.prototype, "complex", void 0);
+// a child class extending the base class, with more @property decorated properties
+class Child extends Base {
+    constructor(num, str, bool) {
+        super(num, str, bool);
+        Object.defineProperty(this, _a, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "num2", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "str2", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "data", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new TestData(1, 'default')
+        });
+        Object.defineProperty(this, "extra", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        this.num2 = num;
+        this.str2 = str;
+    }
+    serialize(dumper) {
+        dumper.dumpValue('extraProperty', this.extra);
+        dumper.dumpProperties(this);
+    }
+    deserialize(loader) {
+        loader.loadProperties(this);
+        this.extra = loader.loadValue('extraProperty');
+    }
+}
+_a = ENGINE.ISerializableObjectTag;
+__decorate([
+    property(),
+    __metadata("design:type", String)
+], Child.prototype, "str2", void 0);
+__decorate([
+    property(),
+    __metadata("design:type", TestData)
+], Child.prototype, "data", void 0);
+let SimpleClass2 = class SimpleClass2 {
+    constructor() {
+        Object.defineProperty(this, "a", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "b", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.a = { x: 1 };
+        this.b = { y: 2 };
+    }
+};
+__decorate([
+    property(),
+    __metadata("design:type", Object)
+], SimpleClass2.prototype, "a", void 0);
+__decorate([
+    property(),
+    __metadata("design:type", Object)
+], SimpleClass2.prototype, "b", void 0);
+SimpleClass2 = __decorate([
+    ENGINE.GameClass(),
+    __metadata("design:paramtypes", [])
+], SimpleClass2);
+export { SimpleClass2 };
+let MyTestActor = class MyTestActor extends ENGINE.Actor {
+    constructor(options = {}) {
+        super(options);
+        Object.defineProperty(this, "customData", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "testSceneComponent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        this.customData = options.customData ?? 0;
+        this.testSceneComponent = options.testSceneComponent ?? new ENGINE.SceneComponent({});
+        this.addComponent(this.testSceneComponent);
+    }
+};
+__decorate([
+    property(),
+    __metadata("design:type", Number)
+], MyTestActor.prototype, "customData", void 0);
+__decorate([
+    property(),
+    __metadata("design:type", Object)
+], MyTestActor.prototype, "testSceneComponent", void 0);
+MyTestActor = __decorate([
+    ENGINE.GameClass(),
+    __metadata("design:paramtypes", [Object])
+], MyTestActor);
+export { MyTestActor };
+// The actual tests
+QUnit.module('SerializationV1', hooks => {
+    hooks.before(() => {
+    });
+    QUnit.test('serialize basic typed value', assert => {
+        {
+            const test = (value) => {
+                const exported = new ENGINE.Dumper().dump(value);
+                assert.deepEqual(exported, { ...version, $root: value });
+                const imported = new ENGINE.Loader().load(exported);
+                assert.equal(imported, value);
+            };
+            test(3);
+            test('hello');
+            test(true);
+            test(null);
+        }
+    });
+    QUnit.test('dump basic object', assert => {
+        {
+            const obj = { a: 1, b: 'hello', c: true };
+            {
+                const dumper = new ENGINE.Dumper();
+                const exported = dumper.dump(obj);
+                assert.deepEqual(exported, { ...version, $root: obj });
+                const imported = (new ENGINE.Loader()).load(exported);
+                assert.deepEqual(imported, obj);
+                const target = { dummy: 123 }; // target object to load into
+                (new ENGINE.Loader()).loadToInstance(exported, target);
+                assert.deepEqual({ dummy: 123, ...imported }, target);
+            }
+            const obj2 = { x: 'foo' };
+            const array = [obj, obj2, 123, 'hello'];
+            {
+                const exported = (new ENGINE.Dumper()).dump(array);
+                assert.deepEqual(exported, { ...version, $root: array });
+                const imported = (new ENGINE.Loader()).load(exported);
+                assert.deepEqual(imported, array);
+                const target = [123];
+                const imported2 = (new ENGINE.Loader()).loadToInstance(exported, target);
+                assert.deepEqual(new Set(array), new Set(target));
+            }
+        }
+    });
+    QUnit.test('dump object with shared references', assert => {
+        {
+            const sharedObj = { a: 1 };
+            const obj = { b: sharedObj, c: sharedObj, d: { x: 'foo' } };
+            const exported = (new ENGINE.Dumper()).dump(obj);
+            assert.deepEqual(exported, {
+                ...version,
+                $root: {
+                    b: { $ref: 1 },
+                    c: { $ref: 1 },
+                    d: { x: 'foo' },
+                },
+                $objects: [
+                    { $id: 1, $value: { a: 1 } },
+                ]
+            });
+            const imported = (new ENGINE.Loader()).load(exported);
+            assert.deepEqual(imported, obj);
+            assert.equal(imported.b, imported.c); // should be the same reference
+        }
+    });
+    QUnit.test('dump object with circular references', assert => {
+        {
+            const obj1 = { a: 1 };
+            const obj2 = { b: 2, ref: obj1 };
+            obj1.ref = obj2; // create circular reference
+            const exported = (new ENGINE.Dumper()).dump([obj1, obj2]);
+            const [imported1, imported2] = (new ENGINE.Loader()).load(exported);
+            assert.deepEqual(Object.keys(imported1), ['a', 'ref']);
+            assert.deepEqual(Object.keys(imported2), ['b', 'ref']);
+            assert.equal(imported1.a, 1);
+            assert.equal(imported2.b, 2);
+            assert.equal(imported1.ref, imported2);
+            assert.equal(imported2.ref, imported1);
+        }
+    });
+    QUnit.test('dump simple class instance with @property decorator', assert => {
+        {
+            const base = new Base(0, 'hello', false);
+            base.complex = { f1: 123, f2: ['hello', 'world!'] };
+            const exported = (new ENGINE.Dumper()).dump(base);
+            // all objects are referenced only once, so inlined
+            assert.deepEqual(exported, {
+                ...version,
+                $root: {
+                    $bc: 'UNREGISTERED.Base',
+                    str: 'hello',
+                    complex: {
+                        f1: 123,
+                        f2: ['hello', 'world!']
+                    }
+                },
+            });
+            const imported = (new ENGINE.Loader()).loadToInstance(exported, new Base(100, 'world', true));
+            assert.equal(imported.num, 100);
+            assert.equal(imported.str, 'hello');
+            assert.deepEqual(imported.complex, {
+                f1: 123,
+                f2: ['hello', 'world!']
+            });
+            assert.equal(imported.bool, true); // non-decorated property remains unchanged
+        }
+    });
+    QUnit.test('test array', assert => {
+        const base = { x: [1, 2, 3, 4] };
+        const prefabData = (new ENGINE.Dumper()).dump(base);
+        const prefabName = 'base';
+        const instance = ENGINE.instantiatePrefab(prefabName, { [prefabName]: prefabData });
+        assert.deepEqual(instance.x, base.x);
+        instance.x[2] = 999;
+        const exported = (new ENGINE.Dumper()).dump(instance);
+        const imported = (new ENGINE.Loader()).load(exported);
+        assert.deepEqual(imported.x, [1, 2, 999, 4]);
+    });
+    QUnit.test('dump simple class child instance', assert => {
+        {
+            const child = new Child(123, 'hello', false);
+            child.complex = { f1: 123, f2: ['hello', 'world!'] };
+            child.extra = 999;
+            const exported = (new ENGINE.Dumper()).dump(child);
+            const imported = (new ENGINE.Loader()).loadToInstance(exported, new Child(0, '', true));
+            assert.equal(imported.num, 123);
+            assert.equal(imported.str, 'hello');
+            assert.deepEqual(imported.complex, {
+                f1: 123,
+                f2: ['hello', 'world!']
+            });
+            assert.equal(imported.extra, 999, 'extra property from serialize/deserialize methods');
+            assert.equal(imported.bool, true, 'non-decorated property remains unchanged');
+            assert.equal(imported.str2, 'hello', 'decorated property str2');
+            assert.equal(imported.num2, 0, 'non-decorated property remains unchanged');
+            assert.equal(imported.data.a, 1, 'nested decorated property a');
+            assert.equal(imported.data.b, 'default', 'nested decorated property b');
+        }
+    });
+    QUnit.test('dump built-in classes with specialization', assert => {
+        const intArray = new Int32Array([1, 2, 3, 4, 5, 6]);
+        const exported = (new ENGINE.Dumper()).dump(intArray);
+        assert.deepEqual(exported, {
+            ...version,
+            $root: { $bc: 'ia', _: [1, 2, 3, 4, 5, 6] }
+        });
+        const imported = (new ENGINE.Loader()).load(exported);
+        assert.ok(imported instanceof Int32Array);
+        assert.deepEqual(imported, intArray);
+    });
+    QUnit.test('dump THREE values', assert => {
+        {
+            const zeroVec = new THREE.Vector3(0, 0, 0);
+            const exported = (new ENGINE.Dumper()).dump(zeroVec);
+            assert.deepEqual(exported, {
+                ...version,
+                $root: { $bc: 'v3' }
+            });
+            const imported = (new ENGINE.Loader()).load(exported);
+            assert.deepEqual(imported, zeroVec);
+        }
+        const position = new THREE.Vector3(1, 2, 3);
+        {
+            const exported = (new ENGINE.Dumper()).dump(position);
+            assert.deepEqual(exported, {
+                ...version,
+                $root: { $bc: 'v3', _: [1, 2, 3] }
+            });
+            const imported = (new ENGINE.Loader()).load(exported);
+            assert.ok(imported instanceof THREE.Vector3);
+            assert.deepEqual(imported, position);
+        }
+        const color = new THREE.Color('#ff00f0');
+        const data = { pos: position, color: color };
+        {
+            const exported = (new ENGINE.Dumper()).dump(data);
+            const imported = (new ENGINE.Loader()).load(exported);
+            assert.ok(imported.pos instanceof THREE.Vector3);
+            assert.deepEqual(imported.pos, position);
+            assert.ok(imported.color instanceof THREE.Color);
+            assert.equal(imported.color.r, color.r);
+            assert.equal(imported.color.g, color.g);
+            assert.equal(imported.color.b.toFixed(5), color.b.toFixed(5));
+        }
+        const normal = new THREE.Vector3(0, 1, 0);
+        const plane = new THREE.Plane(normal, 5);
+        {
+            const exported = (new ENGINE.Dumper()).dump(plane);
+            assert.deepEqual(exported, {
+                ...version,
+                $root: { $bc: 'THREE.Plane', _: [{ $bc: 'v3', _: [0, 1, 0] }, 5] }
+            });
+            const imported = (new ENGINE.Loader()).load(exported);
+            assert.ok(imported instanceof THREE.Plane);
+            assert.ok(imported.normal instanceof THREE.Vector3);
+            assert.deepEqual(imported.normal, plane.normal);
+            assert.equal(imported.constant, plane.constant);
+        }
+        const plane2 = new THREE.Plane(normal, 10);
+        {
+            // TODO: It's not bad that this passes test, should we even allow it?
+            // see Loader._load, and look for `staticDeserializeFn`
+            // shared normal is serialized with THREE.Plane specialization here
+            const exported = (new ENGINE.Dumper()).dump({ p1: plane, p2: plane2 });
+            const imported = (new ENGINE.Loader()).load(exported);
+            assert.ok(imported.p1 instanceof THREE.Plane);
+            assert.ok(imported.p2 instanceof THREE.Plane);
+            assert.deepEqual(imported.p1.normal, plane.normal);
+            assert.equal(imported.p1.constant, plane.constant);
+            assert.deepEqual(imported.p2.normal, plane2.normal);
+            assert.equal(imported.p2.constant, plane2.constant);
+            assert.equal(imported.p1.normal, imported.p2.normal); // shared reference
+        }
+    });
+    QUnit.test('dump SimpleClass', assert => {
+        var _b;
+        let SimpleClass = class SimpleClass {
+            constructor(options) {
+                Object.defineProperty(this, _b, {
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                    value: true
+                });
+                Object.defineProperty(this, "data", {
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                    value: void 0
+                });
+                this.data = options;
+            }
+            serialize(dumper) {
+                dumper.dumpValue('data', this.data);
+            }
+            deserialize(loader) {
+                this.data = loader.loadValue('data');
+            }
+        };
+        _b = ENGINE.ISerializableObjectTag;
+        SimpleClass = __decorate([
+            ENGINE.GameClass(),
+            __metadata("design:paramtypes", [Object])
+        ], SimpleClass);
+        const actor = new SimpleClass({ a: 42 });
+        const exported = (new ENGINE.Dumper()).dump(actor);
+        const imported = (new ENGINE.Loader()).load(exported);
+        assert.ok(imported instanceof SimpleClass);
+        assert.equal(imported.data.a, 42);
+    });
+    QUnit.test('load a modified field', assert => {
+        {
+            const actor = new SimpleClass2();
+            actor.a = { foo: 'bar' };
+            const exported = (new ENGINE.Dumper()).dump(actor);
+            assert.deepEqual(exported, {
+                ...version,
+                $root: {
+                    $bc: 'GAME.SimpleClass2',
+                    a: { foo: 'bar' }
+                }
+            });
+            const imported = (new ENGINE.Loader()).load(exported);
+            assert.ok(imported instanceof SimpleClass2);
+            // TODO: this is not working properly, as the imported value should be {foo: 'bar'}
+            // There is no way to differentiate the following two changes on default:
+            // actor.a = { foo: 'bar' };  // totally replace the object
+            // actor.a.foo = 'bar';  // add a field, so a changes from {x: 1} to {x: 1, foo: 'bar'}
+            assert.deepEqual(imported.a, { foo: 'bar', x: 1 });
+        }
+        {
+            const actor = new SimpleClass2();
+            actor.b = { foo: 'bar' };
+            actor.a = actor.b; // shared reference
+            const exported = (new ENGINE.Dumper()).dump(actor);
+            const imported = (new ENGINE.Loader()).load(exported);
+            assert.ok(imported instanceof SimpleClass2);
+            assert.deepEqual(imported.a, { foo: 'bar', x: 1 }); // same as above TODO
+            assert.deepEqual(imported.b, { foo: 'bar', x: 1 });
+            // assert.strictEqual(imported.b, imported.a);
+        }
+    });
+    QUnit.test('dump Actor to test default values', assert => {
+        const actor = new MyTestActor({ customData: 123, position: new THREE.Vector3(1, 2, 3) });
+        {
+            const exported = (new ENGINE.Dumper()).dump(actor);
+            assert.equal(exported.$root.customData, 123, 'Non default value should be dumped');
+        }
+        {
+            actor.customData = 0; // default value
+            const exported = (new ENGINE.Dumper()).dump(actor);
+            assert.strictEqual(exported.$root.customData, undefined, 'Default value should not be dumped');
+        }
+    });
+    QUnit.test('dump Actor to test components', assert => {
+        const options = { customData: 123, position: new THREE.Vector3(1, 2, 3) };
+        const actor = new MyTestActor(options);
+        actor.testSceneComponent.editorData.displayName = 'Test Component';
+        assert.equal(actor.testSceneComponent, actor.rootComponent.children[0], 'testSceneComponent should be added as child of rootComponent');
+        assert.ok(actor.getWorldPosition().equals(new THREE.Vector3(1, 2, 3)));
+        const exported = (new ENGINE.Dumper()).dump(actor);
+        const imported = (new ENGINE.Loader()).load(exported);
+        assert.equal(imported.customData, options.customData);
+        assert.deepEqual(imported.getWorldPosition(), options.position);
+        assert.ok(imported.testSceneComponent instanceof ENGINE.SceneComponent);
+        assert.equal(imported.testSceneComponent, imported.rootComponent.children[0], 'testSceneComponent should remain the child of rootComponent after loading');
+        assert.deepEqual(imported.getWorldPosition(), new THREE.Vector3(1, 2, 3), 'position should be preserved');
+        assert.equal(imported.testSceneComponent.editorData.displayName, 'Test Component', 'editorData should be preserved');
+    });
+    QUnit.test('dump Actor with SceneComponent in ctor options', assert => {
+        const options = {
+            customData: 123,
+            position: new THREE.Vector3(1, 2, 3),
+            testSceneComponent: new ENGINE.SceneComponent({ position: new THREE.Vector3(4, 5, 6) })
+        };
+        const actor = new MyTestActor(options);
+        const childComponent = new ENGINE.SceneComponent({ position: new THREE.Vector3(1, 1, 1) });
+        actor.addComponent(childComponent);
+        assert.equal(actor.testSceneComponent, actor.rootComponent.children[0]);
+        assert.equal(actor.testSceneComponent, options.testSceneComponent);
+        assert.ok(actor.getWorldPosition().equals(new THREE.Vector3(1, 2, 3)));
+        assert.ok(actor.testSceneComponent.getWorldPosition().equals(new THREE.Vector3(5, 7, 9)));
+        assert.equal(actor.rootComponent.children.length, 2, '1 test component, and 1 added childComponent');
+        const exported = (new ENGINE.Dumper()).dump(actor);
+        const imported = (new ENGINE.Loader()).load(exported);
+        assert.equal(imported.customData, options.customData);
+        assert.deepEqual(imported.getWorldPosition(), options.position);
+        assert.ok(imported.testSceneComponent instanceof ENGINE.SceneComponent);
+        assert.ok(imported.getWorldPosition().equals(new THREE.Vector3(1, 2, 3)), 'position should be preserved');
+        assert.equal(imported.testSceneComponent, imported.rootComponent.children[0], 'testSceneComponent should remain the child of rootComponent after loading');
+        assert.ok(imported.testSceneComponent.getWorldPosition().equals(new THREE.Vector3(5, 7, 9)));
+        assert.equal(imported.rootComponent.children.length, 2, 'added child component should be preserved');
+    });
+    QUnit.test('dump Actor with dynamically added scene component', assert => {
+        const actor = new ENGINE.Actor({});
+        const dynamicComponent = new ENGINE.SceneComponent({ position: new THREE.Vector3(10, 20, 30) });
+        ;
+        actor.addComponent(dynamicComponent);
+        assert.equal(actor.rootComponent.children.length, 1);
+        assert.equal(actor.rootComponent.children[0], dynamicComponent);
+        const exported = (new ENGINE.Dumper()).dump(actor);
+        const imported = (new ENGINE.Loader()).load(structuredClone(exported));
+        assert.equal(imported.rootComponent.children.length, 1);
+        // make sure dumping the loaded instance gives the same result
+        const exportedAgain = (new ENGINE.Dumper()).dump(imported);
+        const ignoreCtorArgs = (data) => {
+            if (typeof data !== 'object' || data === null)
+                return data;
+            const result = Array.isArray(data) ? [] : {};
+            for (const [k, v] of Object.entries(data)) {
+                result[k] = k === '$ctorArgs' ? [{}] : ignoreCtorArgs(v);
+            }
+            return result;
+        };
+        assert.deepEqual(ignoreCtorArgs(exported), ignoreCtorArgs(exportedAgain));
+    });
+    QUnit.test('dump Actor with mesh component', assert => {
+        const actor = new ENGINE.Actor({ position: new THREE.Vector3(1, 2, 3) });
+        actor.setWorldPosition(new THREE.Vector3(5, 10, 15));
+        const meshComponent = new ENGINE.MeshComponent({
+            geometry: new THREE.BoxGeometry(2.5, 3.6, 4.7),
+            material: new THREE.MeshStandardMaterial({ color: 0xff0000 })
+        });
+        actor.addComponent(meshComponent);
+        assert.equal(actor.rootComponent.children.length, 1);
+        assert.equal(actor.rootComponent.children[0], meshComponent);
+        const exported = (new ENGINE.Dumper()).dump(actor);
+        const imported = (new ENGINE.Loader()).load(exported);
+        assert.ok(imported instanceof ENGINE.Actor);
+        assert.ok(imported.getWorldPosition().equals(new THREE.Vector3(5, 10, 15)));
+        // const oldExported = ENGINE.WorldSerializer.exportObject(actor, false);
+        // console.log('export length comparison:', JSON.stringify(exported).length, JSON.stringify(oldExported).length);
+    });
+    QUnit.test('Dump moved actor', assert => {
+        const meshComponent = new ENGINE.MeshComponent({
+            geometry: new THREE.BoxGeometry(2.5, 3.6, 4.7),
+            material: new THREE.MeshStandardMaterial({ color: 0xff0000 })
+        });
+        const actor = new ENGINE.Actor({ position: new THREE.Vector3(1, 2, 3) });
+        actor.setRootComponent(meshComponent, false);
+        actor.setWorldPosition(new THREE.Vector3(5, 10, 15));
+        assert.deepEqual(actor.getWorldPosition(), new THREE.Vector3(5, 10, 15));
+        const exported = (new ENGINE.Dumper()).dump(actor);
+        // console.log('xxxxxxxxxx', JSON.stringify(exported, null, 2));
+        const imported = (new ENGINE.Loader()).load(exported);
+        assert.ok(imported instanceof ENGINE.Actor);
+        assert.deepEqual(imported.getWorldPosition(), new THREE.Vector3(5, 10, 15));
+    });
+    QUnit.test('dump empty world', assert => {
+        mockBrowserEnvironment(JSDOM);
+        const defaultWorldOptions = {
+            rendererDomElement: document.createElement('div'),
+            gameContainer: document.createElement('div'),
+            backgroundColor: 0x2E2E2E,
+            physicsOptions: {
+                engine: ENGINE.PhysicsEngine.Rapier,
+                gravity: ENGINE.MathHelpers.makeVector({ up: -9.81 }),
+            },
+            navigationOptions: {
+                engine: ENGINE.NavigationEngine.RecastNavigation,
+            },
+            useManifold: true
+        };
+        const world = new ENGINE.World(defaultWorldOptions);
+        const exported = (new ENGINE.Dumper()).dump(world);
+        esbuild.stop();
+        assert.ok(exported.$root);
+    });
+    QUnit.test('dump world', assert => {
+        mockBrowserEnvironment(JSDOM);
+        const defaultWorldOptions = {
+            rendererDomElement: document.createElement('div'),
+            gameContainer: document.createElement('div'),
+            backgroundColor: 0x2E2E2E,
+            physicsOptions: {
+                engine: ENGINE.PhysicsEngine.Rapier,
+                gravity: ENGINE.MathHelpers.makeVector({ up: -9.81 }),
+            },
+            navigationOptions: {
+                engine: ENGINE.NavigationEngine.RecastNavigation,
+            },
+            useManifold: true
+        };
+        const world = new ENGINE.World(defaultWorldOptions);
+        const actor0 = new MyTestActor({ customData: 1, position: new THREE.Vector3(1, 0, 0) });
+        const actor1 = new MyTestActor({ customData: 2, position: new THREE.Vector3(0, 2, 0) });
+        // mock some runtime data
+        actor1.setWorldPosition(new THREE.Vector3(50, 60, 70));
+        const component = new ENGINE.SceneComponent({
+            position: new THREE.Vector3(5, 5, 5),
+            scale: new THREE.Vector3(2, 2, 2),
+        });
+        component.editorData = { displayName: 'testComponent' };
+        actor1.addComponent(component);
+        assert.deepEqual(component.getWorldPosition(), new THREE.Vector3(55, 65, 75));
+        world.addActors(actor0, actor1);
+        world.editorData = {
+            name: 'Test World',
+            description: 'A world for testing'
+        };
+        world.postProcessConfiguration = {
+            effects: []
+        };
+        const actorsCount = world.getActors().length; // not 2, because world ctor may add some default actors
+        // MyTestActor ctor may add some default components
+        const actor0ChildrenCount = actor0.rootComponent.children.length;
+        const actor1ChildrenCount = actor1.rootComponent.children.length;
+        const componentWorldPos = component.getWorldPosition();
+        assert.equal(component, actor1.rootComponent.children[actor1ChildrenCount - 1]);
+        assert.deepEqual(componentWorldPos, new THREE.Vector3(55, 65, 75));
+        esbuild.stop();
+        // ------ export the world ------
+        const exported = (new ENGINE.Dumper()).dump(world);
+        const exportedWithOldSerializer = ENGINE.WorldSerializer.exportObject(world, true);
+        const oldLength = JSON.stringify(exportedWithOldSerializer).length;
+        const newLength = JSON.stringify(exported).length;
+        const scale = 2; // should change to 1.5 or 1.2 later
+        assert.ok(newLength < oldLength * scale, `new serializer should not take too much more space (old ${oldLength} vs new ${newLength})`);
+        const loadedWorld = new ENGINE.World(defaultWorldOptions);
+        (new ENGINE.Loader()).loadToInstance(exported, loadedWorld);
+        assert.deepEqual(loadedWorld.sceneResources, world.sceneResources);
+        assert.deepEqual(loadedWorld.editorData, world.editorData);
+        assert.deepEqual(loadedWorld.postProcessConfiguration, world.postProcessConfiguration);
+        assert.equal(loadedWorld.getActors().length, actorsCount);
+        const testActors = loadedWorld.getActors().filter(actor => actor instanceof MyTestActor);
+        assert.equal(testActors.length, 2);
+        assert.equal(testActors[0].uuid, actor0.uuid);
+        assert.equal(testActors[1].uuid, actor1.uuid);
+        assert.equal(testActors[0].customData, 1);
+        assert.equal(testActors[1].customData, 2);
+        assert.deepEqual(testActors[0].getWorldPosition(), actor0.getWorldPosition(), 'updated world position is preserved after loading');
+        assert.deepEqual(testActors[1].getWorldPosition(), actor1.getWorldPosition(), 'updated world position is preserved after loading');
+        assert.equal(testActors[0].rootComponent.children.length, actor0ChildrenCount);
+        assert.equal(testActors[1].rootComponent.children.length, actor1ChildrenCount);
+        const loadedComp = testActors[1].rootComponent.children[actor1ChildrenCount - 1];
+        assert.ok(loadedComp instanceof ENGINE.SceneComponent);
+        assert.deepEqual(loadedComp.getWorldPosition(), new THREE.Vector3(55, 65, 75));
+        assert.deepEqual(loadedComp.getWorldScale(), new THREE.Vector3(2, 2, 2));
+        assert.deepEqual(loadedComp.editorData, { displayName: 'testComponent' });
+    });
+    QUnit.test('test simple prefab', assert => {
+        // ---- create a template ----
+        const template = {
+            a: 1, b: 2, c: 'hello'
+        };
+        const templateData = new ENGINE.Dumper({ flags: ENGINE.DumperFlags.AsPrefab }).dump(template);
+        assert.ok(!JSON.stringify(templateData).includes('uuid'), 'uuid should not be in prefab data');
+        const mockTemplatePath = 'template.json';
+        // ---- create an instance of the prefab ----
+        const templateInstance = ENGINE.instantiatePrefab(mockTemplatePath, { [mockTemplatePath]: templateData });
+        const templateInstance2 = ENGINE.instantiatePrefab(mockTemplatePath, { [mockTemplatePath]: templateData });
+        assert.notEqual(templateInstance, templateInstance2, 'each instantiation should create a new instance');
+        assert.equal(ENGINE.PrefabManager.getPrefabData(templateInstance.$prefab.$path), templateData);
+        assert.deepEqual(templateInstance, { ...template, $prefab: { $path: mockTemplatePath } });
+        templateInstance.a = 42;
+        templateInstance.d = 'new property';
+        // dump the instance
+        const templateInstanceData = new ENGINE.Dumper({ flags: ENGINE.DumperFlags.AsPrefab }).dump(templateInstance);
+        assert.deepEqual(templateInstanceData, {
+            ...version,
+            $root: {
+                $base: {
+                    $path: mockTemplatePath
+                },
+                a: 42,
+                d: 'new property'
+            }
+        });
+        // reload the instance from dumped data
+        const reloadedTemplateInstanceData = new ENGINE.Loader().load(templateInstanceData);
+        assert.deepEqual(reloadedTemplateInstanceData, templateInstance);
+        // ---- dump the instance in an array ----
+        const arrayInstance = [templateInstance];
+        const arrayInstanceData = new ENGINE.Dumper({}).dump(arrayInstance);
+        assert.deepEqual(arrayInstanceData, {
+            ...version,
+            $root: [{
+                    $base: {
+                        $path: mockTemplatePath
+                    },
+                    a: 42,
+                    d: 'new property'
+                }]
+        });
+        // ---- make the instance another prefab, that's based on the first prefab, `template` ----
+        const newTemplate = templateInstanceData;
+        const mockNewTemplatePath = 'newTemplate.json';
+        // all fields should be identical to `templateInstance`
+        const newTemplateInstance = ENGINE.instantiatePrefab(mockNewTemplatePath, { [mockNewTemplatePath]: newTemplate });
+        assert.deepEqual(newTemplateInstance, { ...templateInstance, $prefab: { $path: mockNewTemplatePath } });
+        newTemplateInstance.b = 999;
+        newTemplateInstance.array = [1, 2, 3];
+        newTemplateInstance.array2 = newTemplateInstance.array; // shared reference
+        // dump the new instance
+        const newTemplateInstanceData = new ENGINE.Dumper({ flags: ENGINE.DumperFlags.AsPrefab }).dump(newTemplateInstance);
+        assert.deepEqual(newTemplateInstanceData, {
+            ...version,
+            $root: {
+                $base: {
+                    $path: mockNewTemplatePath
+                },
+                b: 999,
+                array: { $ref: 1 },
+                array2: { $ref: 1 },
+            },
+            $objects: [
+                { $id: 1, $value: [1, 2, 3] }
+            ]
+        });
+    });
+    QUnit.test('test simple actor prefab', assert => {
+        // ---- create a prefab actor ----
+        const prefabActor = new ENGINE.Actor({});
+        // now dump it as a prefab
+        const prefabData = new ENGINE.Dumper({ flags: ENGINE.DumperFlags.AsPrefab }).dump(prefabActor);
+        const mockPrefabPath = 'prefabActor.json';
+        assert.ok(!JSON.stringify(prefabData).includes('uuid'), 'uuid should not be in prefab data');
+        // ---- instantiate the prefab ----
+        const prefabInstance = ENGINE.instantiatePrefab(mockPrefabPath, { [mockPrefabPath]: prefabData });
+        prefabInstance.rootComponent.visible = false;
+        const exportedData = new ENGINE.Dumper().dump(prefabInstance);
+        assert.equal(exportedData.$root.rootComponent.visible, false, 'modified visible state should be in root');
+        // ---- make it another prefab ----
+        const prefabData2 = new ENGINE.Dumper({ flags: ENGINE.DumperFlags.AsPrefab }).dump(prefabInstance);
+        const mockPrefabPath2 = 'prefabActor2.json';
+        // ---- instantiate the new prefab ----
+        const prefabInstance2 = ENGINE.instantiatePrefab(mockPrefabPath2, { [mockPrefabPath2]: prefabData2 });
+        prefabInstance2.rootComponent.visible = true;
+        // check the states
+        assert.equal(prefabInstance.rootComponent.visible, false, 'first instance should have modified visible state');
+        assert.equal(prefabInstance2.rootComponent.visible, true, 'second instance should have its own modified visible state');
+        const exportedData2 = new ENGINE.Dumper().dump(prefabInstance2);
+        assert.equal(exportedData2.$root.rootComponent.visible, true, 'modified visible state should be in root');
+    });
+    QUnit.test('test actor prefab', assert => {
+        // ---- create a prefab actor ----
+        const prefabActor = new MyTestActor({
+            customData: 123,
+            position: new THREE.Vector3(1, 2, 3)
+        });
+        prefabActor.testSceneComponent.editorData.displayName = 'Prefab Component';
+        // add another component to make it more like a real life example
+        prefabActor.addComponent(new ENGINE.MeshComponent({
+            geometry: new THREE.BoxGeometry(2.5, 3.6, 4.7),
+            material: new THREE.MeshStandardMaterial({ color: 0xff0000 })
+        }));
+        // now dump it as a prefab
+        const prefabData = new ENGINE.Dumper({ flags: ENGINE.DumperFlags.AsPrefab }).dump(prefabActor);
+        const mockPrefabPath = 'prefabActor.json';
+        assert.ok(!JSON.stringify(prefabData).includes('uuid'), 'uuid should not be in prefab data');
+        // ---- instantiate the prefab ----
+        const prefabInstance = ENGINE.instantiatePrefab(mockPrefabPath, { [mockPrefabPath]: prefabData }, { ctorArgsOverrides: { position: new THREE.Vector3(6, 8, 10) } });
+        assert.equal(ENGINE.PrefabManager.getPrefabData(prefabInstance.$prefab.$path), prefabData);
+        assert.deepEqual(prefabInstance.getWorldPosition(), new THREE.Vector3(6, 8, 10), 'position from instantiation options should be applied');
+        const anotherPrefabInstance = ENGINE.instantiatePrefab(mockPrefabPath, { [mockPrefabPath]: prefabData });
+        assert.equal(ENGINE.PrefabManager.getPrefabData(anotherPrefabInstance.$prefab.$path), prefabData);
+        assert.notEqual(prefabInstance, anotherPrefabInstance, 'each instantiation should create a new instance');
+        assert.notEqual(prefabInstance.uuid, anotherPrefabInstance.uuid, 'each instantiation should have a different uuid');
+    });
+    QUnit.test('test actor dumping prefab inline', assert => {
+        const prefabActor = new MyTestActor({
+            customData: 123,
+            position: new THREE.Vector3(1, 2, 3)
+        });
+        const prefabData = new ENGINE.Dumper({ flags: ENGINE.DumperFlags.AsPrefab }).dump(prefabActor);
+        const mockPrefabPath = 'prefabActor.json';
+        const prefabInstance = ENGINE.instantiatePrefab(mockPrefabPath, { [mockPrefabPath]: prefabData });
+        prefabInstance.customData = 456; // modify a property
+        const newPrefabData = new ENGINE.Dumper({ flags: ENGINE.DumperFlags.Inline }).dump(prefabInstance);
+        assert.deepEqual(newPrefabData.$root.$base.$class, 'GAME.MyTestActor', 'inline dumped data should not reference prefab path');
+        const childPrefabData = new ENGINE.Dumper({ flags: ENGINE.DumperFlags.AsPrefab }).dump(prefabInstance);
+        assert.deepEqual(childPrefabData.$root.$base.$path, mockPrefabPath, 'dumped prefab data should reference prefab path');
+        const mockChildPrefabPath = 'childPrefab.json';
+        const childPrefabInstance = ENGINE.instantiatePrefab(mockChildPrefabPath, { [mockChildPrefabPath]: childPrefabData });
+        const newChildPrefabData = new ENGINE.Dumper({ flags: ENGINE.DumperFlags.Inline }).dump(childPrefabInstance);
+        assert.deepEqual(newChildPrefabData.$root.$base.$path, mockPrefabPath, 'inline dumped data should reference parent prefab path');
+    });
+    QUnit.test('dump world with prefab actor', assert => {
+        mockBrowserEnvironment(JSDOM);
+        const defaultWorldOptions = {
+            rendererDomElement: document.createElement('div'),
+            gameContainer: document.createElement('div'),
+            backgroundColor: 0x2E2E2E,
+            physicsOptions: {
+                engine: ENGINE.PhysicsEngine.Rapier,
+                gravity: ENGINE.MathHelpers.makeVector({ up: -9.81 }),
+            },
+            navigationOptions: {
+                engine: ENGINE.NavigationEngine.RecastNavigation,
+            },
+            useManifold: true
+        };
+        const world = new ENGINE.World(defaultWorldOptions);
+        const prefabActor = new MyTestActor({
+            customData: 123,
+            position: new THREE.Vector3(1, 2, 3)
+        });
+        const prefabData = new ENGINE.Dumper({ flags: ENGINE.DumperFlags.AsPrefab }).dump(prefabActor);
+        const mockPrefabPath = 'prefabActor.json';
+        const prefabInstance = ENGINE.instantiatePrefab(mockPrefabPath, { [mockPrefabPath]: prefabData }, { ctorArgsOverrides: { position: new THREE.Vector3(6, 8, 10) } });
+        world.addActor(prefabInstance);
+        const exported = (new ENGINE.Dumper()).dump(world);
+        esbuild.stop();
+        assert.ok(exported.$root.actors[0].$base.$path === mockPrefabPath, 'prefab actor should be referenced by its prefab path in exported world data');
+    });
+    QUnit.test('dump with custom serializer', assert => {
+        let Foo = class Foo {
+            constructor(a) {
+                Object.defineProperty(this, "a", {
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                    value: void 0
+                });
+                Object.defineProperty(this, "data", {
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                    value: void 0
+                });
+                this.a = a;
+                this.data = { x: 1, y: 2, z: 'hello' };
+            }
+            static serializeData(value, dumper) {
+                const { x, ...rest } = value;
+                for (const [k, v] of Object.entries(rest)) {
+                    dumper.dumpValue(k, v);
+                }
+            }
+            static deserializeData(target, loader) {
+                target.x = 0;
+                target.y = loader.loadValue('y');
+                target.z = loader.loadValue('z');
+            }
+        };
+        __decorate([
+            property(),
+            __metadata("design:type", Number)
+        ], Foo.prototype, "a", void 0);
+        __decorate([
+            property({ serialize: Foo.serializeData, deserialize: Foo.deserializeData }),
+            __metadata("design:type", Object)
+        ], Foo.prototype, "data", void 0);
+        Foo = __decorate([
+            ENGINE.GameClass(),
+            __metadata("design:paramtypes", [Number])
+        ], Foo);
+        const foo = new Foo(42);
+        const exported = (new ENGINE.Dumper()).dump(foo);
+        assert.deepEqual(exported, {
+            ...version,
+            $root: {
+                $bc: 'GAME.Foo',
+                a: 42,
+                data: { y: 2, z: 'hello' } // x should be omitted
+            }
+        });
+        const imported = (new ENGINE.Loader()).load(exported);
+        assert.ok(imported instanceof Foo);
+        assert.equal(imported.a, 42);
+        assert.equal(imported.data.x, 0); // from custom deserializer
+        assert.equal(imported.data.y, 2);
+        assert.equal(imported.data.z, 'hello');
+    });
+    QUnit.test('dump ctor args', assert => {
+        let Foo2 = class Foo2 {
+            constructor(options = { a: 1, b: 'default' }) {
+                Object.defineProperty(this, "ctorArgs", {
+                    enumerable: true,
+                    configurable: true,
+                    writable: true,
+                    value: void 0
+                });
+                this.ctorArgs = options;
+            }
+        };
+        __decorate([
+            property({ ctorArg: 'ctorArgOnly' }),
+            __metadata("design:type", Object)
+        ], Foo2.prototype, "ctorArgs", void 0);
+        Foo2 = __decorate([
+            ENGINE.GameClass(),
+            __metadata("design:paramtypes", [Object])
+        ], Foo2);
+        const foo = new Foo2();
+        const exported = (new ENGINE.Dumper()).dump(foo);
+        // TODO: expect no dumping of ctor args, but for now it's disabled
+        // See "TODO: cannot skip dumping ctor args" in Dumper
+        // assert.deepEqual(exported, {
+        //   ...version,
+        //   $root: {
+        //     $base: { $class: 'GAME.Foo2', $ctorArgs: [{}] },
+        //   }
+        // });
+        const imported = (new ENGINE.Loader()).load(exported);
+        assert.ok(imported instanceof Foo2);
+        assert.deepEqual(imported.ctorArgs, { a: 1, b: 'default' }, 'ctor args should be preserved');
+    });
+    QUnit.test('test loading vector', assert => {
+        const vectorData = [];
+        for (let i = 0; i < 10000; i++) {
+            vectorData.push(new THREE.Vector3(i, i * 2, i * 3));
+        }
+        const dumpedData = (new ENGINE.Dumper()).dump(vectorData);
+        const loadedData = (new ENGINE.Loader()).load(dumpedData);
+        assert.equal(loadedData.length, vectorData.length);
+    });
+    QUnit.test('test legacy prefab loading', async (assert) => {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            const storageProvider = new NodeStorageProvider();
+            const context = __addDisposableResource(env_1, ENGINE.scopedProjectContext({ project: 'test', storageProvider }), false);
+            mockBrowserEnvironment(JSDOM);
+            const defaultWorldOptions = {
+                rendererDomElement: document.createElement('div'),
+                gameContainer: document.createElement('div'),
+                backgroundColor: 0x2E2E2E,
+                physicsOptions: {
+                    engine: ENGINE.PhysicsEngine.Rapier,
+                    gravity: ENGINE.MathHelpers.makeVector({ up: -9.81 }),
+                },
+                navigationOptions: {
+                    engine: ENGINE.NavigationEngine.RecastNavigation,
+                },
+                useManifold: true
+            };
+            const world = new ENGINE.World(defaultWorldOptions);
+            const actors = await ENGINE.WorldCommands.placePrefabs({
+                world,
+                prefabs: [{ path: '@engine/assets/prefabs/actors/test.prefab.json' }]
+            });
+            assert.equal(actors.length, 1);
+            const exported = (new ENGINE.Dumper()).dump(world);
+            esbuild.stop();
+            const loadedWorld = new ENGINE.World(defaultWorldOptions);
+            (new ENGINE.Loader()).loadToInstance(exported, loadedWorld);
+            assert.equal(loadedWorld.getActors().length, 2, 'particle manager and a loaded actor');
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            __disposeResources(env_1);
+        }
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"serialization-v1.test.js","sourceRoot":"","sources":["../../test/serialization-v1.test.ts"],"names":[],"mappings":"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"}