@directivegames/genesys.js 3.1.24

package/dist/src/utils/serialization/serializer.js

@@ -0,0 +1,1032 @@
+import * as THREE from 'three';
+import { SerializationVersion } from '../../const.js';
+import { ClassRegistry } from '../../systems/ClassRegistry.js';
+import { getAllPropertiesFromProto, getDefaultObject } from './cdo.js';
+import { getClassForDeserialization, getClassSerializeName, } from './clsAlias.js';
+import { instantiatePrefab } from './prefab.js';
+import { PrefabManager } from './prefabManager.js';
+import { ISerializableObjectTag } from './serializable.js';
+import { getDeserializeFn, getSerializeFn, getStaticDeserializeFn } from './specializationUtils.js';
+import './specialization.js'; // make sure specializations are registered
+const VERSION = SerializationVersion.V1;
+const UNREGISTERED_CLASS_PREFIX = 'UNREGISTERED.';
+function isClassInfo(baseInfo) {
+    return '$class' in baseInfo;
+}
+function isPrefabInfo(baseInfo) {
+    return '$path' in baseInfo;
+}
+function isSerializableObject(obj) {
+    return obj && typeof obj === 'object' && obj[ISerializableObjectTag] === true;
+}
+const DumpValueResult = {
+    Dumped: 0,
+    SkippedTransient: 1,
+    SkippedEqualToDefaultValue: 2,
+    SkippedOtherwise: 3,
+};
+/**
+ * The serialized data will either be $root + $objects, or $prefab + $diff
+ * if it's $prefab + $diff, the prefab data can be another prefab, forming a chain of prefabs
+ *
+ * A typical result of serialized (SerializedData) would look something like this:
+ * {
+ *   $prefab: {
+ *    $path: '@engine/prefabs/Prefab1.prefab.json'
+ *   },
+ *   $diff: {
+ *     // only the differences from the prefab1
+ *   }
+ * }
+ * Once all prefabs with paths are resolved, the final expanded data would look like this:
+ * {
+ *   $prefab: {
+ *    $path: '@engine/prefabs/Prefab1.prefab.json',
+ *    $data: {
+ *      // yet another prefab data here
+ *     $prefab: {
+ *       $path: '@engine/prefabs/Prefab2.prefab.json',
+ *       $data: {
+ *         // a prefab that's based on Actor instead of another prefab
+ *         $root: {
+ *           $class: 'ENGINE.Actor', ...
+ *         },
+ *         $objects: [
+ *           // serialized objects here
+ *         ]
+ *       }
+ *     },
+ *     $diff: {
+ *       // only the differences from the prefab2
+ *     }
+ *    }
+ *   },
+ *   $diff: {
+ *     // only the differences from the prefab1
+ *   }
+ * }
+ */
+// make sure it's kept in sync with RefType
+function _isRef(v) {
+    return v && typeof v === 'object' && typeof v.$ref === 'number';
+}
+function getAllProperties(obj) {
+    let proto = Object.getPrototypeOf(obj);
+    return getAllPropertiesFromProto(proto);
+}
+function shouldSerializeRespectingMetadata(obj) {
+    const properties = getAllProperties(obj);
+    const hasDecoratedProperties = properties.size > 0;
+    if (hasDecoratedProperties) {
+        return true;
+    }
+    const className = ClassRegistry.getClassName(obj);
+    const isClassRegistered = !!className;
+    return isClassRegistered;
+}
+class Serializer {
+    get isDumping() { return false; }
+}
+/**
+ * Dumper serializes objects into a structured format, handling references and class instances.
+ * If an object is referenced more than once, it will be assigned an ID and stored in the $objects array as SerializedObject[].
+ * If an object is a class instance, it will be stored with its class name, constructor arguments, and properties, basically an inlined `SerializedObject`
+ * otherwise, it will be inlined directly.
+ * The output format is `SerializedData`, with always a $root field, and optionally a $objects array.
+ * The following are possible outputs:
+ * plain objects: {a: 1, b: {x: 2, y: 3}} -> {$root: {a: 1, b: {x: 2, y:3}}}
+ * with shared/circular references: {a: obj1, b: obj1, c: {x: 1}} -> {$root: {a: {$ref: 1}, b: {$ref: 1}, c: {x: 1}}, $objects: [{ $id: 1, $value: {fields of obj1...} }]}
+ * with class: THREE.Vector3(1,2,3) -> {$root: { $class: 'THREE.Vector3', x:1, y:2, z:3 }}
+ * ENGINE.Actor({data: 3, position: new THREE.Vector3(1, 2, 3)}) -> {
+ *  $root: {
+ *    $class: 'ENGINE.Actor',
+ *    $ctorArgs: [ {data: 3, position: {$class: 'THREE.Vector3', x:1, y:2, z:3}} ],
+ *    actor properties...
+ * }
+ */
+export const DumperFlags = {
+    None: 0,
+    AsPrefab: 1 << 0,
+    Inline: 2 << 0 // work with AsPrefab, if exists, object will be dumped to modify its prefab, instead of a new prefab based on its prefab.
+};
+export const LoaderFlags = {
+    None: 0,
+    WithoutEditor: 1 << 0,
+};
+export class Dumper extends Serializer {
+    constructor(options) {
+        super();
+        Object.defineProperty(this, "seen", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new WeakMap()
+        });
+        Object.defineProperty(this, "objects", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "idCounter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 1
+        });
+        Object.defineProperty(this, "currentRecord", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "defaultValues", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "refCount", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "pathStack", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "flags", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.flags = options?.flags ?? DumperFlags.None;
+        if (this.hasFlags(DumperFlags.Inline)) {
+            // make sure AsPrefab is also set
+            this.flags |= DumperFlags.AsPrefab;
+        }
+    }
+    get isDumping() { return true; }
+    hasFlags(flags) {
+        return (this.flags & flags) === flags;
+    }
+    get dumpingAsPrefab() {
+        return this.hasFlags(DumperFlags.AsPrefab);
+    }
+    dump(obj) {
+        if (this.idCounter > 1 || this.objects.length > 0 || this.currentRecord) {
+            throw new Error('Dumper instances cannot be reused.');
+        }
+        let realPrefabPath;
+        if (this.hasFlags(DumperFlags.Inline) && obj.$prefab) {
+            // modify existing prefab to its parent
+            realPrefabPath = obj.$prefab;
+            const baseInfo = PrefabManager.getPrefabBaseInfo(realPrefabPath.$path);
+            if (baseInfo && isPrefabInfo(baseInfo)) {
+                obj.$prefab = baseInfo;
+            }
+            else if (baseInfo && isClassInfo(baseInfo)) {
+                delete obj.$prefab;
+            }
+        }
+        try {
+            const exported = this._dump(obj);
+            const objects = this.objects;
+            // result with all data fields serialized
+            const rootData = {
+                $root: exported,
+            };
+            if (objects.length > 0) {
+                rootData.$objects = objects;
+            }
+            // optimize to make objects that are only referenced once inlined
+            const optimizedExpandedResult = this._optimize(rootData);
+            // generate diff against base data if applicable
+            // const diff = deepDiff(expandedBaseData, optimizedExpandedResult);
+            const result = {
+                $version: VERSION,
+                ...optimizedExpandedResult
+            };
+            return result;
+        }
+        finally {
+            if (realPrefabPath) {
+                obj.$prefab = realPrefabPath;
+            }
+        }
+    }
+    _optimize(serializedData) {
+        // flatten the objects that are only referenced once
+        const objectsMap = new Map();
+        if (serializedData.$objects) {
+            for (const record of serializedData.$objects) {
+                objectsMap.set(record.$id, record);
+            }
+        }
+        // step 1: inline objects that are only referenced once
+        const inlineObject = (obj) => {
+            if (typeof obj !== 'object' || obj === null) {
+                return;
+            }
+            for (const [k, v] of Object.entries(obj)) {
+                if (_isRef(v)) {
+                    const refId = v.$ref;
+                    const refCount = this.refCount.get(refId);
+                    if (refCount === 1) {
+                        const record = objectsMap.get(refId);
+                        if (record.$value && typeof record.$value === 'object' && !Array.isArray(record.$value)) {
+                            const { $value = {}, $id, ...rest } = record;
+                            obj[k] = {
+                                ...rest,
+                                ...$value,
+                            };
+                        }
+                        else {
+                            obj[k] = record.$value;
+                        }
+                    }
+                }
+                inlineObject(obj[k]);
+            }
+        };
+        // start inlining from the root
+        inlineObject(serializedData);
+        // step 2: rebuild the $objects array
+        if (serializedData.$objects) {
+            serializedData.$objects = serializedData.$objects?.filter(record => {
+                const refCount = this.refCount.get(record.$id);
+                return refCount > 1;
+            });
+            if (serializedData.$objects.length === 0) {
+                delete serializedData.$objects;
+            }
+        }
+        // step 3: optional, reassign IDs to be sequential, this is mainly to make tests easier compose expected output
+        const idMap = new Map();
+        let newIdCounter = 1;
+        if (serializedData.$objects) {
+            for (const record of serializedData.$objects) {
+                const oldId = record.$id;
+                const newId = newIdCounter++;
+                idMap.set(oldId, newId);
+                record.$id = newId;
+            }
+        }
+        const remapRefs = (obj) => {
+            if (typeof obj !== 'object' || obj === null) {
+                return;
+            }
+            for (const [k, v] of Object.entries(obj)) {
+                if (_isRef(v)) {
+                    v.$ref = idMap.get(v.$ref);
+                    if (!v.$ref) {
+                        throw new Error(`Dumper: remapRefs failed to find new ID for ref ${v.$ref}`);
+                    }
+                }
+                remapRefs(obj[k]);
+            }
+        };
+        // remap refs in the root object
+        remapRefs(serializedData);
+        // step 4: replace { $base: {$class: '...' } } with just {$bc: '...'} for smaller size
+        const shortenClassBaseInfoWithoutCtorArgs = (obj) => {
+            if (typeof obj !== 'object' || obj === null) {
+                return;
+            }
+            for (const [k, v] of Object.entries(obj)) {
+                if (v && typeof v === 'object' && '$base' in v) {
+                    const baseInfo = v.$base;
+                    if (isClassInfo(baseInfo) && !('$ctorArgs' in baseInfo)) {
+                        v.$bc = baseInfo.$class;
+                        delete v.$base;
+                    }
+                }
+                shortenClassBaseInfoWithoutCtorArgs(v);
+            }
+        };
+        shortenClassBaseInfoWithoutCtorArgs(serializedData);
+        // step 5: handle float numbers to reduce size
+        const processNumbers = (obj) => {
+            if (typeof obj !== 'object' || obj === null) {
+                return;
+            }
+            for (const [k, v] of Object.entries(obj)) {
+                if (typeof v === 'number') {
+                    if (Number.isInteger(v)) {
+                        obj[k] = v;
+                    }
+                    else {
+                        obj[k] = Math.round(v * 1000000) / 1000000;
+                    }
+                }
+                else {
+                    processNumbers(obj[k]);
+                }
+            }
+        };
+        processNumbers(serializedData);
+        return serializedData;
+    }
+    // instanceKey is the key in the parent object, used for getting the value on prefab
+    // return true if anything is dumped
+    dumpValue(key, value, instanceKey, metadata) {
+        if (metadata?.transient) {
+            // skip transient properties
+            return DumpValueResult.SkippedTransient;
+        }
+        if (metadata?.transientOnPrefab && this.dumpingAsPrefab) {
+            // skip transientOnPrefab properties when dumping as prefab
+            return DumpValueResult.SkippedTransient;
+        }
+        if (value
+            && typeof value === 'object'
+            && (value[ISerializableObjectTag] === true || value instanceof THREE.Object3D)
+            && value.isTransient
+            && value.isTransient()) {
+            // transient object, skip it
+            return DumpValueResult.SkippedTransient;
+        }
+        const isCtorArgs = (metadata) => {
+            return !!metadata?.ctorArg || metadata?.ctorArgIndex !== undefined;
+        };
+        if (metadata && isCtorArgs(metadata) && metadata.ctorArg !== 'ctorArgAndProperty') {
+            // already dumped as ctorArgs
+            return DumpValueResult.SkippedOtherwise;
+        }
+        if (this.defaultValues) {
+            const defaultValue = this.defaultValues[key];
+            if (value === null || typeof value !== 'object') {
+                if (value === defaultValue) {
+                    // skip if values strictly equals to base instance value
+                    return DumpValueResult.SkippedEqualToDefaultValue;
+                }
+            }
+            else {
+                // object type, do a deep comparison
+                if (defaultValue
+                    && Object.getPrototypeOf(value) === Object.getPrototypeOf(defaultValue)
+                    && JSON.stringify(value) === JSON.stringify(defaultValue)) {
+                    return DumpValueResult.SkippedEqualToDefaultValue;
+                }
+            }
+        }
+        return this._dumpTo(key, value, this.currentRecord.$value, instanceKey, metadata) ? DumpValueResult.Dumped : DumpValueResult.SkippedOtherwise;
+    }
+    // [value, propertyName, propertyMetadata]
+    dumpCtorArgs(args) {
+        const baseInfo = this.currentRecord.$base;
+        if (!baseInfo || !baseInfo.$class) {
+            // only dump ctor args if $class is present
+            // So this would skip
+            // - an instance whose base is a prefab
+            // - an instance whose base is a class that's not registered,
+            return;
+        }
+        const classInfo = this.currentRecord.$base;
+        classInfo.$ctorArgs = [];
+        for (let i = 0; i < args.length; i++) {
+            // TODO: cannot skip dumping ctor args (`args[i].name ?? null` for base's corresponding filed) for now,
+            // as it will dump a `{}` if the ctor args are same as base, but it would cause big issue when loading
+            // should the base (cdo)'s corresponding ctor args be passed into instances? or do a deep copy? what if there are complex object in ctor args?
+            this._dumpTo(String(i), args[i].value, classInfo.$ctorArgs, /*args[i].name ??*/ null, args[i].metadata);
+        }
+    }
+    removeDumpedValue(key) {
+        if (key in this.currentRecord.$value) {
+            delete this.currentRecord.$value[key];
+        }
+    }
+    _dumpTo(key, value, target, instanceKey, metadata) {
+        let dumped = false;
+        this.pathStack.push(key);
+        // const fullPath = this.pathStack.join('.');
+        // console.log('dumping key:', fullPath);
+        if (value !== undefined) {
+            // NOTE: if instanceKey is undefined, use `key`; but if `instanceKey` is null, don't use any key to get default values
+            const propertyName = instanceKey !== null ? (instanceKey ?? key) : null;
+            const defaultValues = propertyName ? this.defaultValues?.[propertyName] : undefined;
+            target[key] = this._dump(value, defaultValues, metadata?.serialize);
+            dumped = true;
+        }
+        this.pathStack.pop();
+        return dumped;
+    }
+    dumpProperties(obj) {
+        if (!shouldSerializeRespectingMetadata(obj)) {
+            const isArray = Array.isArray(obj);
+            // no decorated properties, do a deep dump
+            let outputIndex = 0;
+            const entries = isArray
+                ? obj.map((val, i) => [i, val])
+                : Object.entries(obj);
+            for (const [key, val] of entries) {
+                if (!isArray && key.startsWith('$'))
+                    continue; // skip special properties, such as $prefab
+                // this has no problem with object, but with array, it can result in `undefined` entries, due to either skipping transient properties or default values
+                const dumpKey = isArray ? String(outputIndex) : key;
+                const dumpResult = this.dumpValue(dumpKey, val);
+                if (isArray && dumpResult !== DumpValueResult.SkippedTransient) {
+                    // don't increase index if skipped due to transient
+                    outputIndex += 1;
+                }
+                // TODO: should always dump for array, otherwise [1,2,3,4] changed to [1,2,999,4] will dump only [999], making loader yield incorrect result ([1,2,3,4,999])
+                // Should simply do the following
+                // `const dumped = this.dumpValue(key as string, val);`
+                // however we have an issue here `dumpValue` skips dumping and return undefined for
+                // both a value that equals default value, or a value that doesn't need to dump at all (i.e. transient object)
+                // [1, 2, 3, 4] -> [1, 2, 999, 4] dumps [undefined, undefined, 999, undefined]
+                // [GlobalParticleManager, Actor, Actor] dumps [undefined, {...}, {...}]
+                // and further more, `undefined` becomes `null` once stringified. we need to fix this
+            }
+            // if obj is an array, and it has default values, let's only record the "diff" here
+            if (isArray && Object.keys(this.defaultValues).length > 0) {
+                const dumpedArray = this.currentRecord.$value;
+                this.currentRecord.$value = {};
+                for (const [key, val] of Object.entries(dumpedArray)) {
+                    if (val !== undefined) {
+                        this.currentRecord.$value[key] = val;
+                    }
+                }
+            }
+            return;
+        }
+        const properties = getAllProperties(obj);
+        const isCtorArgs = (metadata) => {
+            return !!metadata?.ctorArg || metadata?.ctorArgIndex !== undefined;
+        };
+        // first dump ctorArgs if exist
+        const ctorArgsMeta = new Map([...properties].filter(([key, metadata]) => isCtorArgs(metadata)));
+        // warning if multiple properties have same ctorArgIndex, the order is not guaranteed
+        if (ctorArgsMeta.size > 1) {
+            const indexSet = new Set([...ctorArgsMeta.values()].map(meta => meta.ctorArgIndex ?? 0));
+            if (indexSet.size < ctorArgsMeta.size) {
+                console.warn('Dumper: Multiple properties have the same ctorArgIndex, the order is not guaranteed.');
+            }
+        }
+        if (ctorArgsMeta.size > 0) {
+            const ctorArgsArray = [];
+            const sortedCtorArgs = [...ctorArgsMeta].sort((a, b) => {
+                const indexA = a[1].ctorArgIndex ?? 0;
+                const indexB = b[1].ctorArgIndex ?? 0;
+                return indexA - indexB;
+            });
+            for (const [key, metadata] of sortedCtorArgs) {
+                ctorArgsArray.push({ name: key, value: obj[key], metadata });
+            }
+            this.dumpCtorArgs(ctorArgsArray);
+        }
+        // then dump other properties
+        for (const [key, metadata] of properties) {
+            this.dumpValue(key, obj[key], key, metadata);
+        }
+    }
+    markEditorOnly() {
+        if (!this.currentRecord?.$meta) {
+            this.currentRecord.$meta = {};
+        }
+        this.currentRecord.$meta.editorOnly = true;
+    }
+    getId(obj) {
+        if (!this.seen.has(obj)) {
+            const newId = this.idCounter++;
+            this.seen.set(obj, newId);
+            this.refCount.set(newId, 0);
+        }
+        return this.seen.get(obj);
+    }
+    // valuesOverriddenByPrefab comes from the outer prefab, i.e. from the component data in an actor prefab
+    _dump(obj, valuesOverriddenByPrefab, customSerialize) {
+        if (typeof obj !== 'object' || obj === null) {
+            return obj;
+        }
+        // Already serialized → return a reference
+        if (this.seen.has(obj)) {
+            const refId = this.getId(obj);
+            if (this.refCount.get(refId) === undefined || this.refCount.get(refId) === 0) {
+                throw new Error('Dumper: refCount for object does not exist at this point, this should not happen.');
+            }
+            this.refCount.set(refId, this.refCount.get(refId) + 1);
+            return { $ref: refId };
+        }
+        const defaultValues = {};
+        Object.assign(defaultValues, getDefaultObject(obj));
+        Object.assign(defaultValues, valuesOverriddenByPrefab);
+        const refId = this.getId(obj);
+        const record = { $id: refId, $value: Array.isArray(obj) ? [] : {} };
+        let baseInfo = null;
+        const prefabPath = obj.$prefab?.$path;
+        if (prefabPath) {
+            baseInfo = { $path: prefabPath };
+        }
+        else {
+            const clsName = getClassSerializeName(obj);
+            if (clsName) {
+                baseInfo = { $class: clsName }; // placeholder for ctorArgs
+            }
+            else {
+                // if it's an unregistered class
+                if (typeof obj === 'object' && obj !== null && !Array.isArray(obj)) {
+                    const proto = Object.getPrototypeOf(obj);
+                    if (proto !== Object.prototype && proto !== String.prototype && proto !== Number.prototype && proto !== Boolean.prototype) {
+                        baseInfo = { $class: `${UNREGISTERED_CLASS_PREFIX}${obj.constructor.name}` };
+                    }
+                }
+            }
+        }
+        if (baseInfo) {
+            record.$base = baseInfo;
+        }
+        // actual dumping
+        const prevRecord = this.currentRecord;
+        this.currentRecord = record;
+        const prevBaseInstance = this.defaultValues;
+        this.defaultValues = defaultValues;
+        // push the record first to handle circular references
+        this.objects.push(record);
+        this.refCount.set(refId, this.refCount.get(refId) + 1);
+        if (customSerialize) {
+            customSerialize(obj, this);
+        }
+        else if (isSerializableObject(obj) && obj.serialize) {
+            obj.serialize(this);
+        }
+        else {
+            const serializeFn = getSerializeFn(obj);
+            if (serializeFn) {
+                serializeFn(obj, this);
+            }
+            else {
+                this.dumpProperties(obj);
+            }
+        }
+        this.currentRecord = prevRecord;
+        this.defaultValues = prevBaseInstance;
+        return { $ref: refId };
+    }
+}
+export class Loader extends Serializer {
+    constructor(options) {
+        super();
+        Object.defineProperty(this, "objMap", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "currentObjectRecord", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "objectsData", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Map()
+        });
+        Object.defineProperty(this, "pathStack", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "flags", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ctorArgsOverrides", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.flags = options?.flags ?? LoaderFlags.None;
+        this.ctorArgsOverrides = Array.isArray(options?.ctorArgsOverrides) ? options.ctorArgsOverrides : (options?.ctorArgsOverrides ? [options?.ctorArgsOverrides] : []);
+    }
+    // public API
+    load(data) {
+        return this.loadToInstance(data);
+    }
+    async loadAsync(data) {
+        return this.loadToInstanceAsync(data);
+    }
+    loadToInstance(data, target) {
+        const startTime = performance.now();
+        this._prepareLoader(data);
+        const result = this._load(data.$root, '$root', target);
+        const endTime = performance.now();
+        console.log(`Loader.loadToInstance execution time: ${endTime - startTime}ms`);
+        return result;
+    }
+    async loadToInstanceAsync(data, target) {
+        const startTime = performance.now();
+        this._prepareLoader(data);
+        // collect and load all prefab data first
+        const traverseAndLoadPrefabs = async (data) => {
+            if (data && typeof data === 'object') {
+                if (data.$base && isPrefabInfo(data.$base)) {
+                    const prefabPath = data.$base.$path;
+                    const prefabData = await PrefabManager.getOrLoadPrefabData(prefabPath);
+                    // traverse the prefab data
+                    await traverseAndLoadPrefabs(prefabData);
+                }
+                for (const value of Object.values(data)) {
+                    await traverseAndLoadPrefabs(value);
+                }
+            }
+        };
+        await traverseAndLoadPrefabs(data);
+        const result = this._load(data.$root, '$root', target);
+        const endTime = performance.now();
+        console.log(`Loader.loadToInstanceAsync execution time: ${endTime - startTime}ms`);
+        return result;
+    }
+    hasFlags(flags) {
+        return (this.flags & flags) === flags;
+    }
+    // end public API
+    _prepareLoader(data) {
+        if (this.objMap.size > 0 || this.objectsData.size > 0 || this.currentObjectRecord || this.pathStack.length > 0) {
+            throw new Error('Loader instances cannot be reused.');
+        }
+        if (data.$objects) {
+            for (const record of data.$objects) {
+                this.objectsData.set(record.$id, record);
+            }
+        }
+        // convert $bc -> {$base: {$class: ...} }
+        const extractClassBaseInfoWithoutCtorArgs = (obj) => {
+            if (typeof obj !== 'object' || obj === null) {
+                return;
+            }
+            for (const [k, v] of Object.entries(obj)) {
+                if (v && typeof v === 'object' && '$bc' in v) {
+                    const className = v.$bc;
+                    v.$base = { $class: className };
+                    delete v.$bc;
+                }
+                extractClassBaseInfoWithoutCtorArgs(v);
+            }
+        };
+        extractClassBaseInfoWithoutCtorArgs(data);
+    }
+    findInstance(id) {
+        if (id !== null && this.objMap.has(id)) {
+            return this.objMap.get(id) ?? null;
+        }
+        return null;
+    }
+    containsReference(data, id) {
+        if (id === null)
+            return false;
+        if (typeof data !== 'object' || data === null) {
+            return false;
+        }
+        if (_isRef(data)) {
+            return data.$ref === id;
+        }
+        for (const value of Object.values(data)) {
+            if (this.containsReference(value, id)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    findOrCreateInstance(baseInfo, propertiesData, id) {
+        // Already created
+        const existingInstance = this.findInstance(id);
+        if (existingInstance) {
+            return existingInstance;
+        }
+        if (baseInfo && isPrefabInfo(baseInfo)) {
+            try {
+                return instantiatePrefab(baseInfo.$path);
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    // Could happen due to prefab renames, we don't want to crash the game/editor
+                    console.warn(`Loader: Failed to instantiate prefab at path ${baseInfo.$path}: ${error.message}. Creating plain object instead.`);
+                    return {};
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        // If it's a class instance
+        const clsName = baseInfo && isClassInfo(baseInfo) ? baseInfo.$class : undefined;
+        const ctorArgsData = baseInfo && isClassInfo(baseInfo) ? baseInfo.$ctorArgs : undefined;
+        const isIdValid = id !== null;
+        if (clsName) {
+            const cls = getClassForDeserialization(clsName);
+            if (!cls) {
+                // class not found, leave a warning here
+                console.warn(`Loader: Class not found for name ${clsName}, creating plain object instead.`);
+            }
+            else {
+                const makeCtorArgs = () => {
+                    const defaultCtorArgs = [];
+                    const ctorArgs = (this._load(ctorArgsData, '$ctorArgs', defaultCtorArgs) ?? []);
+                    if (this.pathStack.length === 1 && this.pathStack[0] === '$root') {
+                        // TODO: how do we know the root object's ctor args? what if a user makes an Actor, whose constructor takes 3 args, like `new Actor(a,options,b)`?
+                        // In that case a user when instantiating a prefab will never know what type they're actually dealing with
+                        // for now I just assume that each element in this.ctorArgsOverrides corresponds to each of the constructor args
+                        // one way to fix this is to make Dumper yell if Actor/Component contains more than one args
+                        const overrides = this.ctorArgsOverrides;
+                        for (let i = 0; i < overrides.length; i++) {
+                            const o = overrides[i];
+                            if (o === undefined)
+                                continue;
+                            if (o === null || Array.isArray(o) || typeof o !== 'object') {
+                                // override is a primitive, just replace the ctor arg directly
+                                ctorArgs[i] = o;
+                            }
+                            else {
+                                let target = ctorArgs[i];
+                                if (target === null || Array.isArray(target) || typeof target !== 'object') {
+                                    target = {};
+                                    ctorArgs[i] = target;
+                                }
+                                Object.assign(target, o);
+                            }
+                        }
+                    }
+                    return ctorArgs;
+                };
+                if (isIdValid) {
+                    // if ctorArgs data contains reference to itself,
+                    // must create a placeholder instance first to handle circular references (by ctorArgs)
+                    // this happens because we allow passing instances to ctor args, check the following example:
+                    // class A { constructor(public b: B) {} }
+                    // class B { constructor(public a: A) {} }
+                    // const a = new A();
+                    // const b = new B(a);
+                    // a.b = b;
+                    // When deserializing B, we need to create a placeholder for it first, so that A can be constructed and populated properly
+                    let placeholder = null;
+                    if (this.containsReference(ctorArgsData, id)) {
+                        placeholder = Object.create(cls.prototype);
+                        this.objMap.set(id, placeholder);
+                    }
+                    // recursively load ctor args
+                    const ctorArgs = makeCtorArgs();
+                    // Now construct the real instance
+                    const instance = new cls(...ctorArgs);
+                    if (placeholder) {
+                        // Replace the placeholder with the actual instance, but we have no idea if there is anything referencing the placeholder already
+                        // so it must be mutated in place
+                        Object.assign(placeholder, instance);
+                        return placeholder;
+                    }
+                    else {
+                        this.objMap.set(id, instance);
+                        return instance;
+                    }
+                }
+                else {
+                    // no $id, meaning it's not a referenced object, just create it directly
+                    const ctorArgs = makeCtorArgs();
+                    const instance = new cls(...ctorArgs);
+                    return instance;
+                }
+            }
+        }
+        const instance = Array.isArray(propertiesData) ? [] : {};
+        if (isIdValid) {
+            this.objMap.set(id, instance);
+        }
+        return instance;
+    }
+    _populate(value, key, target, baseInfo, metadata) {
+        const prevObjectRecord = this.currentObjectRecord;
+        this.currentObjectRecord = value;
+        // target ??= Array.isArray(value) ? [] : {};
+        if (metadata?.deserialize) {
+            // if metadata has custom deserialize function, use it
+            metadata.deserialize(target, this);
+        }
+        else if (isSerializableObject(target) && target.deserialize) {
+            // If it's a class instance and implements ISerializableObject, call its serialize method
+            target.deserialize(this);
+        }
+        else {
+            const deserializeFn = getDeserializeFn(target);
+            if (deserializeFn) {
+                deserializeFn(target, this);
+            }
+            else {
+                this.loadProperties(target);
+            }
+        }
+        if (baseInfo && isPrefabInfo(baseInfo) && baseInfo.$path) {
+            target.$prefab = { $path: baseInfo.$path };
+        }
+        this.currentObjectRecord = prevObjectRecord;
+    }
+    _matchesExisting(existing, refId, className, dataValue) {
+        if (refId !== undefined && this.objMap.has(refId)) {
+            // if it's a referenced object, must match by identity
+            return this.objMap.get(refId) === existing;
+        }
+        if (Array.isArray(existing) && Array.isArray(dataValue)) {
+            return true;
+        }
+        if (className) {
+            const cls = getClassForDeserialization(className);
+            if (cls) {
+                // registered class
+                if (!(existing instanceof cls))
+                    return false;
+                const existingInstanceClsName = getClassSerializeName(existing);
+                if (existingInstanceClsName !== className)
+                    return false;
+                // There should be an absolute truth here to tell if the serialized data matches the existing instance
+                // For now I can only guess
+                if (existing.name && dataValue?.name && existing.name !== dataValue.name) {
+                    return false;
+                }
+                // return true here for now
+                return true;
+            }
+            else {
+                if (className.startsWith(UNREGISTERED_CLASS_PREFIX)) {
+                    // unregistered class, just check the constructor name
+                    const expectedCtorName = className.substring(UNREGISTERED_CLASS_PREFIX.length);
+                    return existing.constructor.name === expectedCtorName;
+                }
+            }
+        }
+        else if (typeof existing === 'object' && existing !== null && !Array.isArray(existing)) {
+            // plain object, return true because we have no way to tell its default state, so basically treating the existing instance as "default"
+            return true;
+        }
+        return false;
+    }
+    // target is the existing object to resolve into if it's able to
+    // it is required so as to avoid re-creating objects that are already present
+    loadValue(key, target, metadata) {
+        return this._load(this.currentObjectRecord[key], key, target, metadata);
+    }
+    _findClass(baseInfo, seen) {
+        if (isClassInfo(baseInfo)) {
+            return baseInfo.$class;
+        }
+        seen ??= new Set();
+        const prefabPath = isPrefabInfo(baseInfo) ? baseInfo.$path : null;
+        if (prefabPath) {
+            if (seen.has(prefabPath)) {
+                throw new Error(`Loader: Circular prefab reference detected for prefab ${prefabPath}, aborting class lookup.`);
+            }
+            seen.add(prefabPath);
+            const baseInfo = PrefabManager.getPrefabBaseInfo(prefabPath);
+            if (baseInfo) {
+                return this._findClass(baseInfo, seen);
+            }
+        }
+        return null;
+    }
+    // key is only for path tracking, but it's required just to be clear
+    _load(serializedValue, key, target, metadata) {
+        const _internalLoad = (serializedValue, key, target, metadata) => {
+            if (Array.isArray(serializedValue) || Array.isArray(target)) {
+                // if `serializedValue` is array, `target` may or may not be an array. Usually it's not, but if calling `loadInstanceTo(data, [])`, then it can can be an array
+                if (Array.isArray(serializedValue)) {
+                    const result = serializedValue.map((v, index) => this._load(serializedValue[index], String(index), Array.isArray(target) ? target[index] : undefined));
+                    if (Array.isArray(target)) {
+                        // push into the items that's not already present
+                        const seen = new Set(target);
+                        target.push(...result.filter(item => !seen.has(item)));
+                        return target;
+                    }
+                    return result;
+                }
+                else if (serializedValue && typeof serializedValue === 'object') {
+                    // target is an array, but serializedValue is not. It means we have a default value being array,
+                    // and `serializedValue` is a delta, that contains { index -> overriddenValue }
+                    const result = target;
+                    for (const [k, v] of Object.entries(serializedValue)) {
+                        result[k] = this._load(serializedValue[k], String(k), result[k]);
+                    }
+                    return result;
+                }
+            }
+            else if (!serializedValue || typeof serializedValue !== 'object') {
+                return serializedValue;
+            }
+            else {
+                // handle object, two possible cases for `serializedValue`:
+                // a ref obj: { $ref: 1 }
+                // full serialized object: { $value: {...}, $class?: 'ClassName', $ctorArgs?: [...] }, note $class and $ctorArgs are optional
+                // it's always two steps: instantiate the object (findOrCreateInstance), then populate its properties (_populate)
+                let referencedObject = null;
+                if (_isRef(serializedValue)) {
+                    const refId = serializedValue.$ref;
+                    const record = this.objectsData.get(refId);
+                    if (!record)
+                        throw new Error(`Loader: No object record found for ref ${refId}`);
+                    referencedObject = record;
+                }
+                const existingInstance = this.findInstance(referencedObject?.$id ?? null);
+                if (existingInstance) {
+                    return existingInstance;
+                }
+                const data = referencedObject ? referencedObject.$value : serializedValue;
+                const meta = referencedObject ? referencedObject.$meta : serializedValue.$meta;
+                if (meta?.editorOnly && this.hasFlags(LoaderFlags.WithoutEditor)) {
+                    return null;
+                }
+                const baseInfo = referencedObject ? referencedObject.$base : serializedValue.$base;
+                // if the instance doesn't exist yet, and it's not required to populate value onto a given target
+                // we can give user a chance to construct and populate an instance using `data`, `cls` and `ctorArgsData`
+                // but for now let's only use it internally by specialization
+                if (!target) {
+                    const cls = baseInfo && isClassInfo(baseInfo) ? baseInfo.$class : undefined;
+                    const staticDeserializeFn = getStaticDeserializeFn(cls);
+                    if (staticDeserializeFn) {
+                        let instance;
+                        if (typeof data !== 'object' || data === null) {
+                            instance = staticDeserializeFn(data);
+                        }
+                        else {
+                            // extract data for user in case it contains complex type
+                            const extracted = Array.isArray(data) ? [] : {};
+                            for (const [k, v] of Object.entries(data)) {
+                                if (k.startsWith('$'))
+                                    continue;
+                                extracted[k] = this._load(v, k);
+                            }
+                            instance = staticDeserializeFn(extracted);
+                        }
+                        if (instance) {
+                            // it's important to always add to objMap to prevent circular reference issues
+                            if (referencedObject && !this.objMap.has(referencedObject.$id)) {
+                                this.objMap.set(referencedObject.$id, instance);
+                            }
+                            return instance;
+                        }
+                    }
+                }
+                // should we directly load into target, or should we create a new instance
+                // this is common case for loading into a component on actor, which is also created in the actor's ctor
+                const cls = baseInfo ? this._findClass(baseInfo) : null;
+                const result = target && this._matchesExisting(target, referencedObject?.$id, cls, serializedValue) ?
+                    target :
+                    // objMap is set in findOrCreateInstance
+                    this.findOrCreateInstance(baseInfo, serializedValue, // pass the whole object for properties, though we could remove $class and $ctorArgs for clarity
+                    referencedObject?.$id ?? null);
+                // must do it prior to _populate to avoid circular reference issues
+                if (referencedObject && !this.objMap.has(referencedObject.$id)) {
+                    this.objMap.set(referencedObject.$id, result);
+                }
+                this._populate(data, key, result, baseInfo ?? null, metadata);
+                return result;
+            }
+        };
+        this.pathStack.push(key);
+        // // skip the first $root
+        // const fullPath = this.pathStack.slice(1).join('.');
+        // console.log('loading key:', fullPath);
+        const loaded = _internalLoad(serializedValue, key, target, metadata ?? {});
+        this.pathStack.pop();
+        return loaded;
+    }
+    loadProperties(obj) {
+        if (!shouldSerializeRespectingMetadata(obj)) {
+            const modifiedKeys = new Set();
+            for (const [key, val] of Object.entries(this.currentObjectRecord)) {
+                if (key.startsWith('$'))
+                    continue; // skip the special fields
+                modifiedKeys.add(key);
+                const loaded = this._load(this.currentObjectRecord[key], key, obj[key]);
+                if (loaded === obj[key])
+                    continue; // skip assignment if same
+                obj[key] = loaded;
+            }
+            return;
+        }
+        const properties = getAllProperties(obj);
+        for (const [key, metadata] of properties) {
+            if (key in this.currentObjectRecord) {
+                if (metadata?.editorOnly && this.hasFlags(LoaderFlags.WithoutEditor)) {
+                    // skip editorOnly properties when not loading with editor
+                    // but should I mark the property as undefined on the object?
+                    continue;
+                }
+                // don't worry about transient properties here, they are already skipped when dumping
+                const val = this.currentObjectRecord[key];
+                const result = this._load(val, key, obj[key], metadata);
+                if (result !== obj[key]) {
+                    obj[key] = result;
+                }
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"serializer.js","sourceRoot":"","sources":["../../../../src/utils/serialization/serializer.ts"],"names":[],"mappings":"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"}