@nice2dev/game-engine 1.0.5 → 1.0.10

package/dist/esm/editor/PrefabSystem.js

@@ -0,0 +1,858 @@
+/**
+ * @file PrefabSystem.ts
+ * @description Advanced Prefab System with nested prefabs, variants, override tracking
+ * PRO-1.4: Professional Editor Features
+ *
+ * Features:
+ * - Prefab definition and instantiation
+ * - Nested prefabs (prefabs containing other prefabs)
+ * - Prefab variants (inherited modifications)
+ * - Override tracking (property-level changes)
+ * - Apply/revert overrides
+ * - Prefab linking (maintain connection to source)
+ * - Unpack prefab (break connection)
+ * - Auto-update instances when prefab changes
+ * - Serialization/deserialization
+ * - Prefab comparison (diff)
+ */
+// ============================================================
+// Default Transform
+// ============================================================
+const DEFAULT_TRANSFORM = {
+    position: { x: 0, y: 0, z: 0 },
+    rotation: { x: 0, y: 0, z: 0, w: 1 },
+    scale: { x: 1, y: 1, z: 1 },
+};
+// ============================================================
+// Utility Functions
+// ============================================================
+function generateId() {
+    return `${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+}
+function deepClone(obj) {
+    return JSON.parse(JSON.stringify(obj));
+}
+function getValueAtPath(obj, path) {
+    const parts = path.split('.');
+    let current = obj;
+    for (const part of parts) {
+        if (current === null || current === undefined) {
+            return undefined;
+        }
+        if (typeof current !== 'object') {
+            return undefined;
+        }
+        const index = parseInt(part, 10);
+        if (!isNaN(index) && Array.isArray(current)) {
+            current = current[index];
+        }
+        else {
+            current = current[part];
+        }
+    }
+    return current;
+}
+function setValueAtPath(obj, path, value) {
+    const parts = path.split('.');
+    let current = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const part = parts[i];
+        if (current === null || current === undefined) {
+            return;
+        }
+        if (typeof current !== 'object') {
+            return;
+        }
+        const index = parseInt(part, 10);
+        if (!isNaN(index) && Array.isArray(current)) {
+            current = current[index];
+        }
+        else {
+            current = current[part];
+        }
+    }
+    if (current && typeof current === 'object') {
+        const lastPart = parts[parts.length - 1];
+        const index = parseInt(lastPart, 10);
+        if (!isNaN(index) && Array.isArray(current)) {
+            current[index] = value;
+        }
+        else {
+            current[lastPart] = value;
+        }
+    }
+}
+function compareValues(a, b) {
+    return JSON.stringify(a) === JSON.stringify(b);
+}
+// ============================================================
+// Prefab Manager
+// ============================================================
+class PrefabManager {
+    constructor() {
+        this.prefabs = new Map();
+        this.instances = new Map();
+        this.prefabVersions = new Map();
+    }
+    // ─── Prefab Creation ───────────────────────────────────
+    createPrefab(name, rootEntity) {
+        const id = `prefab_${generateId()}`;
+        const now = Date.now();
+        const root = {
+            id: `entity_${generateId()}`,
+            name: rootEntity?.name ?? name,
+            parentId: null,
+            transform: rootEntity?.transform ?? deepClone(DEFAULT_TRANSFORM),
+            components: rootEntity?.components ?? [],
+            children: rootEntity?.children ?? [],
+            tags: rootEntity?.tags ?? [],
+            layer: rootEntity?.layer ?? 'default',
+            active: rootEntity?.active ?? true,
+        };
+        const prefab = {
+            id,
+            name,
+            description: '',
+            version: 1,
+            createdAt: now,
+            modifiedAt: now,
+            author: '',
+            rootEntity: root,
+            entities: new Map([[root.id, root]]),
+            nestedPrefabs: [],
+            tags: [],
+            category: 'General',
+        };
+        this.prefabs.set(id, prefab);
+        this.prefabVersions.set(id, 1);
+        return prefab;
+    }
+    createPrefabFromEntities(name, entities) {
+        const prefab = this.createPrefab(name);
+        // Find root (entity with no parent or parent not in list)
+        const entityIds = new Set(entities.map((e) => e.id));
+        const root = entities.find((e) => !e.parentId || !entityIds.has(e.parentId));
+        if (root) {
+            prefab.rootEntity = deepClone(root);
+            prefab.entities.set(root.id, prefab.rootEntity);
+        }
+        // Add all entities
+        for (const entity of entities) {
+            if (entity.id !== prefab.rootEntity.id) {
+                const clone = deepClone(entity);
+                prefab.entities.set(clone.id, clone);
+            }
+        }
+        this.updatePrefabVersion(prefab.id);
+        return prefab;
+    }
+    // ─── Prefab Variants ───────────────────────────────────
+    createVariant(basePrefabId, name) {
+        const basePrefab = this.prefabs.get(basePrefabId);
+        if (!basePrefab) {
+            return null;
+        }
+        const variant = this.createPrefab(name);
+        variant.variantOf = basePrefabId;
+        variant.inheritedOverrides = [];
+        // Copy base structure
+        variant.rootEntity = deepClone(basePrefab.rootEntity);
+        variant.rootEntity.id = `entity_${generateId()}`;
+        variant.entities.clear();
+        variant.entities.set(variant.rootEntity.id, variant.rootEntity);
+        for (const [, entity] of basePrefab.entities) {
+            if (entity.id !== basePrefab.rootEntity.id) {
+                const clone = deepClone(entity);
+                clone.id = `entity_${generateId()}`;
+                variant.entities.set(clone.id, clone);
+            }
+        }
+        variant.nestedPrefabs = deepClone(basePrefab.nestedPrefabs);
+        return variant;
+    }
+    getBasePrefab(variantId) {
+        const variant = this.prefabs.get(variantId);
+        if (!variant?.variantOf) {
+            return null;
+        }
+        return this.prefabs.get(variant.variantOf) ?? null;
+    }
+    applyVariantOverrides(variantId) {
+        const variant = this.prefabs.get(variantId);
+        if (!variant || !variant.variantOf) {
+            return;
+        }
+        const base = this.prefabs.get(variant.variantOf);
+        if (!base) {
+            return;
+        }
+        // Apply inherited overrides from base to variant
+        if (variant.inheritedOverrides) {
+            for (const override of variant.inheritedOverrides) {
+                const targetEntity = this.findEntityByPathRoot(variant, override.path);
+                if (targetEntity) {
+                    setValueAtPath(targetEntity, override.path, override.overridenValue);
+                }
+            }
+        }
+        this.updatePrefabVersion(variantId);
+    }
+    // ─── Nested Prefabs ────────────────────────────────────
+    addNestedPrefab(parentPrefabId, nestedPrefabId, parentEntityId, transform) {
+        const parentPrefab = this.prefabs.get(parentPrefabId);
+        const nestedPrefab = this.prefabs.get(nestedPrefabId);
+        if (!parentPrefab || !nestedPrefab) {
+            return null;
+        }
+        if (!parentPrefab.entities.has(parentEntityId)) {
+            return null;
+        }
+        // Check for circular reference
+        if (this.hasCircularReference(parentPrefabId, nestedPrefabId)) {
+            console.error('Circular prefab reference detected');
+            return null;
+        }
+        const reference = {
+            instanceId: `nested_${generateId()}`,
+            prefabId: nestedPrefabId,
+            parentEntityId,
+            overrides: [],
+            transform: {
+                ...deepClone(DEFAULT_TRANSFORM),
+                ...transform,
+            },
+        };
+        parentPrefab.nestedPrefabs.push(reference);
+        this.updatePrefabVersion(parentPrefabId);
+        return reference;
+    }
+    removeNestedPrefab(parentPrefabId, instanceId) {
+        const parentPrefab = this.prefabs.get(parentPrefabId);
+        if (!parentPrefab) {
+            return false;
+        }
+        const index = parentPrefab.nestedPrefabs.findIndex((n) => n.instanceId === instanceId);
+        if (index === -1) {
+            return false;
+        }
+        parentPrefab.nestedPrefabs.splice(index, 1);
+        this.updatePrefabVersion(parentPrefabId);
+        return true;
+    }
+    hasCircularReference(parentId, childId, visited = new Set()) {
+        if (parentId === childId) {
+            return true;
+        }
+        if (visited.has(childId)) {
+            return true;
+        }
+        visited.add(childId);
+        const childPrefab = this.prefabs.get(childId);
+        if (!childPrefab) {
+            return false;
+        }
+        for (const nested of childPrefab.nestedPrefabs) {
+            if (this.hasCircularReference(parentId, nested.prefabId, visited)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    // ─── Instantiation ─────────────────────────────────────
+    instantiate(prefabId, worldTransform) {
+        const prefab = this.prefabs.get(prefabId);
+        if (!prefab) {
+            return null;
+        }
+        const instance = {
+            id: `instance_${generateId()}`,
+            prefabId,
+            name: prefab.name,
+            overrides: [],
+            worldTransform: {
+                ...deepClone(DEFAULT_TRANSFORM),
+                ...worldTransform,
+            },
+            nestedInstances: new Map(),
+            isLinked: true,
+            createdAt: Date.now(),
+            lastSyncedAt: Date.now(),
+        };
+        // Instantiate nested prefabs recursively
+        for (const nestedRef of prefab.nestedPrefabs) {
+            const nestedInstance = this.instantiate(nestedRef.prefabId, nestedRef.transform);
+            if (nestedInstance) {
+                // Apply nested prefab overrides
+                nestedInstance.overrides = deepClone(nestedRef.overrides);
+                instance.nestedInstances.set(nestedRef.instanceId, nestedInstance);
+            }
+        }
+        this.instances.set(instance.id, instance);
+        return instance;
+    }
+    destroyInstance(instanceId) {
+        const instance = this.instances.get(instanceId);
+        if (!instance) {
+            return false;
+        }
+        // Destroy nested instances
+        for (const [, nested] of instance.nestedInstances) {
+            this.destroyInstance(nested.id);
+        }
+        this.instances.delete(instanceId);
+        return true;
+    }
+    // ─── Override Management ───────────────────────────────
+    setOverride(instanceId, path, value) {
+        const instance = this.instances.get(instanceId);
+        if (!instance) {
+            return;
+        }
+        const prefab = this.prefabs.get(instance.prefabId);
+        if (!prefab) {
+            return;
+        }
+        const originalValue = this.getOriginalValue(prefab, path);
+        // Check if value is same as original
+        if (compareValues(originalValue, value)) {
+            this.removeOverride(instanceId, path);
+            return;
+        }
+        // Check if override already exists
+        const existingIndex = instance.overrides.findIndex((o) => o.path === path);
+        const override = {
+            path,
+            originalValue,
+            overridenValue: value,
+            overrideType: 'modify',
+            timestamp: Date.now(),
+        };
+        if (existingIndex !== -1) {
+            instance.overrides[existingIndex] = override;
+        }
+        else {
+            instance.overrides.push(override);
+        }
+        this.onInstanceChanged?.(instanceId);
+    }
+    removeOverride(instanceId, path) {
+        const instance = this.instances.get(instanceId);
+        if (!instance) {
+            return;
+        }
+        instance.overrides = instance.overrides.filter((o) => o.path !== path);
+        this.onInstanceChanged?.(instanceId);
+    }
+    revertAllOverrides(instanceId) {
+        const instance = this.instances.get(instanceId);
+        if (!instance) {
+            return;
+        }
+        instance.overrides = [];
+        this.onInstanceChanged?.(instanceId);
+    }
+    applyOverridesToPrefab(instanceId) {
+        const instance = this.instances.get(instanceId);
+        if (!instance) {
+            return;
+        }
+        const prefab = this.prefabs.get(instance.prefabId);
+        if (!prefab) {
+            return;
+        }
+        // Apply all overrides to the prefab
+        for (const override of instance.overrides) {
+            const entity = this.findEntityByPathRoot(prefab, override.path);
+            if (entity) {
+                setValueAtPath(entity, override.path, override.overridenValue);
+            }
+        }
+        // Clear instance overrides
+        instance.overrides = [];
+        this.updatePrefabVersion(instance.prefabId);
+    }
+    hasOverrides(instanceId) {
+        const instance = this.instances.get(instanceId);
+        return instance ? instance.overrides.length > 0 : false;
+    }
+    getOverrides(instanceId) {
+        const instance = this.instances.get(instanceId);
+        return instance ? [...instance.overrides] : [];
+    }
+    getOriginalValue(prefab, path) {
+        // Parse path to find the entity and property
+        const entity = this.findEntityByPathRoot(prefab, path);
+        if (!entity) {
+            return undefined;
+        }
+        const relativePath = this.getRelativePropertyPath(path);
+        return getValueAtPath(entity, relativePath);
+    }
+    findEntityByPathRoot(prefab, path) {
+        const parts = path.split('.');
+        // Check if path starts with entity reference
+        if (parts[0].startsWith('entity_')) {
+            return prefab.entities.get(parts[0]) ?? null;
+        }
+        // Default to root entity
+        return prefab.rootEntity;
+    }
+    getRelativePropertyPath(path) {
+        const parts = path.split('.');
+        // Skip entity ID if present
+        if (parts[0].startsWith('entity_')) {
+            return parts.slice(1).join('.');
+        }
+        return path;
+    }
+    // ─── Linking ───────────────────────────────────────────
+    unlinkInstance(instanceId) {
+        const instance = this.instances.get(instanceId);
+        if (!instance) {
+            return;
+        }
+        instance.isLinked = false;
+        instance.unpackedAt = Date.now();
+        // Unlink nested instances
+        for (const [, nested] of instance.nestedInstances) {
+            this.unlinkInstance(nested.id);
+        }
+        this.onInstanceChanged?.(instanceId);
+    }
+    relinkInstance(instanceId) {
+        const instance = this.instances.get(instanceId);
+        if (!instance) {
+            return false;
+        }
+        // Check if prefab still exists
+        if (!this.prefabs.has(instance.prefabId)) {
+            return false;
+        }
+        instance.isLinked = true;
+        instance.unpackedAt = undefined;
+        instance.lastSyncedAt = Date.now();
+        this.onInstanceChanged?.(instanceId);
+        return true;
+    }
+    // ─── Synchronization ───────────────────────────────────
+    syncInstance(instanceId) {
+        const instance = this.instances.get(instanceId);
+        if (!instance || !instance.isLinked) {
+            return;
+        }
+        const prefab = this.prefabs.get(instance.prefabId);
+        if (!prefab) {
+            return;
+        }
+        this.prefabVersions.get(instance.prefabId) ?? 0;
+        // Instance is already synced
+        if (instance.lastSyncedAt >= prefab.modifiedAt) {
+            return;
+        }
+        // Re-apply overrides after sync
+        // (In a real implementation, you'd merge changes intelligently)
+        instance.lastSyncedAt = Date.now();
+        // Sync nested instances
+        for (const [, nested] of instance.nestedInstances) {
+            this.syncInstance(nested.id);
+        }
+        this.onInstanceChanged?.(instanceId);
+    }
+    syncAllInstances(prefabId) {
+        for (const [instanceId, instance] of this.instances) {
+            if (instance.prefabId === prefabId && instance.isLinked) {
+                this.syncInstance(instanceId);
+            }
+        }
+    }
+    updatePrefabVersion(prefabId) {
+        const prefab = this.prefabs.get(prefabId);
+        if (prefab) {
+            prefab.version++;
+            prefab.modifiedAt = Date.now();
+            this.prefabVersions.set(prefabId, prefab.version);
+            this.onPrefabChanged?.(prefabId);
+        }
+    }
+    // ─── Entity Management ─────────────────────────────────
+    addEntity(prefabId, entity, parentId) {
+        const prefab = this.prefabs.get(prefabId);
+        if (!prefab) {
+            return null;
+        }
+        const newEntity = {
+            id: `entity_${generateId()}`,
+            name: entity.name ?? 'New Entity',
+            parentId: parentId ?? prefab.rootEntity.id,
+            transform: entity.transform ?? deepClone(DEFAULT_TRANSFORM),
+            components: entity.components ?? [],
+            children: entity.children ?? [],
+            tags: entity.tags ?? [],
+            layer: entity.layer ?? 'default',
+            active: entity.active ?? true,
+        };
+        prefab.entities.set(newEntity.id, newEntity);
+        // Update parent's children list
+        const parent = prefab.entities.get(newEntity.parentId);
+        if (parent) {
+            parent.children.push(newEntity.id);
+        }
+        this.updatePrefabVersion(prefabId);
+        return newEntity;
+    }
+    removeEntity(prefabId, entityId) {
+        const prefab = this.prefabs.get(prefabId);
+        if (!prefab) {
+            return false;
+        }
+        if (entityId === prefab.rootEntity.id) {
+            return false;
+        } // Can't remove root
+        const entity = prefab.entities.get(entityId);
+        if (!entity) {
+            return false;
+        }
+        // Remove from parent's children
+        if (entity.parentId) {
+            const parent = prefab.entities.get(entity.parentId);
+            if (parent) {
+                parent.children = parent.children.filter((id) => id !== entityId);
+            }
+        }
+        // Remove children recursively
+        for (const childId of entity.children) {
+            this.removeEntity(prefabId, childId);
+        }
+        prefab.entities.delete(entityId);
+        this.updatePrefabVersion(prefabId);
+        return true;
+    }
+    // ─── Component Management ──────────────────────────────
+    addComponent(prefabId, entityId, component) {
+        const prefab = this.prefabs.get(prefabId);
+        if (!prefab) {
+            return null;
+        }
+        const entity = prefab.entities.get(entityId);
+        if (!entity) {
+            return null;
+        }
+        const newComponent = {
+            id: `component_${generateId()}`,
+            type: component.type ?? 'Unknown',
+            properties: component.properties ?? {},
+            enabled: component.enabled ?? true,
+        };
+        entity.components.push(newComponent);
+        this.updatePrefabVersion(prefabId);
+        return newComponent;
+    }
+    removeComponent(prefabId, entityId, componentId) {
+        const prefab = this.prefabs.get(prefabId);
+        if (!prefab) {
+            return false;
+        }
+        const entity = prefab.entities.get(entityId);
+        if (!entity) {
+            return false;
+        }
+        const index = entity.components.findIndex((c) => c.id === componentId);
+        if (index === -1) {
+            return false;
+        }
+        entity.components.splice(index, 1);
+        this.updatePrefabVersion(prefabId);
+        return true;
+    }
+    // ─── Comparison ────────────────────────────────────────
+    comparePrefabs(prefabIdA, prefabIdB) {
+        const prefabA = this.prefabs.get(prefabIdA);
+        const prefabB = this.prefabs.get(prefabIdB);
+        if (!prefabA || !prefabB) {
+            return null;
+        }
+        const diff = {
+            added: [],
+            removed: [],
+            modified: [],
+            componentAdded: [],
+            componentRemoved: [],
+            entityAdded: [],
+            entityRemoved: [],
+        };
+        // Compare entities
+        const entityIdsA = new Set(prefabA.entities.keys());
+        const entityIdsB = new Set(prefabB.entities.keys());
+        for (const id of entityIdsB) {
+            if (!entityIdsA.has(id)) {
+                diff.entityAdded.push(id);
+            }
+        }
+        for (const id of entityIdsA) {
+            if (!entityIdsB.has(id)) {
+                diff.entityRemoved.push(id);
+            }
+        }
+        // Compare matching entities
+        for (const [id, entityA] of prefabA.entities) {
+            const entityB = prefabB.entities.get(id);
+            if (!entityB) {
+                continue;
+            }
+            this.compareEntities(entityA, entityB, id, diff);
+        }
+        return diff;
+    }
+    compareInstanceToPrefab(instanceId) {
+        const instance = this.instances.get(instanceId);
+        if (!instance) {
+            return null;
+        }
+        const prefab = this.prefabs.get(instance.prefabId);
+        if (!prefab) {
+            return null;
+        }
+        const diff = {
+            added: [],
+            removed: [],
+            modified: [],
+            componentAdded: [],
+            componentRemoved: [],
+            entityAdded: [],
+            entityRemoved: [],
+        };
+        // List all overrides as modifications
+        for (const override of instance.overrides) {
+            diff.modified.push({
+                path: override.path,
+                oldValue: override.originalValue,
+                newValue: override.overridenValue,
+            });
+        }
+        return diff;
+    }
+    compareEntities(entityA, entityB, prefix, diff) {
+        // Compare transform
+        this.compareProperty(entityA.transform, entityB.transform, `${prefix}.transform`, diff);
+        // Compare components
+        const compIdsA = new Set(entityA.components.map((c) => c.id));
+        const compIdsB = new Set(entityB.components.map((c) => c.id));
+        for (const comp of entityB.components) {
+            if (!compIdsA.has(comp.id)) {
+                diff.componentAdded.push(`${prefix}.${comp.id}`);
+            }
+        }
+        for (const comp of entityA.components) {
+            if (!compIdsB.has(comp.id)) {
+                diff.componentRemoved.push(`${prefix}.${comp.id}`);
+            }
+        }
+        // Compare matching components
+        for (const compA of entityA.components) {
+            const compB = entityB.components.find((c) => c.id === compA.id);
+            if (!compB) {
+                continue;
+            }
+            this.compareProperty(compA.properties, compB.properties, `${prefix}.${compA.id}.properties`, diff);
+        }
+    }
+    compareProperty(valueA, valueB, path, diff) {
+        if (typeof valueA !== typeof valueB) {
+            diff.modified.push({ path, oldValue: valueA, newValue: valueB });
+            return;
+        }
+        if (valueA === null || valueB === null) {
+            if (valueA !== valueB) {
+                diff.modified.push({ path, oldValue: valueA, newValue: valueB });
+            }
+            return;
+        }
+        if (typeof valueA !== 'object') {
+            if (valueA !== valueB) {
+                diff.modified.push({ path, oldValue: valueA, newValue: valueB });
+            }
+            return;
+        }
+        if (Array.isArray(valueA) && Array.isArray(valueB)) {
+            if (valueA.length !== valueB.length) {
+                diff.modified.push({ path, oldValue: valueA, newValue: valueB });
+                return;
+            }
+            for (let i = 0; i < valueA.length; i++) {
+                this.compareProperty(valueA[i], valueB[i], `${path}.${i}`, diff);
+            }
+            return;
+        }
+        const objA = valueA;
+        const objB = valueB;
+        const keysA = new Set(Object.keys(objA));
+        const keysB = new Set(Object.keys(objB));
+        for (const key of keysB) {
+            if (!keysA.has(key)) {
+                diff.added.push(`${path}.${key}`);
+            }
+        }
+        for (const key of keysA) {
+            if (!keysB.has(key)) {
+                diff.removed.push(`${path}.${key}`);
+            }
+            else {
+                this.compareProperty(objA[key], objB[key], `${path}.${key}`, diff);
+            }
+        }
+    }
+    // ─── Serialization ─────────────────────────────────────
+    serializePrefab(prefabId) {
+        const prefab = this.prefabs.get(prefabId);
+        if (!prefab) {
+            return null;
+        }
+        const serialized = {
+            ...prefab,
+            entities: Object.fromEntries(prefab.entities),
+        };
+        return JSON.stringify(serialized, null, 2);
+    }
+    deserializePrefab(json) {
+        try {
+            const data = JSON.parse(json);
+            const prefab = {
+                ...data,
+                entities: new Map(Object.entries(data.entities)),
+                createdAt: data.createdAt ?? Date.now(),
+                modifiedAt: data.modifiedAt ?? Date.now(),
+            };
+            this.prefabs.set(prefab.id, prefab);
+            this.prefabVersions.set(prefab.id, prefab.version);
+            return prefab;
+        }
+        catch (error) {
+            console.error('Failed to deserialize prefab:', error);
+            return null;
+        }
+    }
+    serializeInstance(instanceId) {
+        const instance = this.instances.get(instanceId);
+        if (!instance) {
+            return null;
+        }
+        const serialized = {
+            ...instance,
+            nestedInstances: Object.fromEntries(instance.nestedInstances),
+        };
+        return JSON.stringify(serialized, null, 2);
+    }
+    deserializeInstance(json) {
+        try {
+            const data = JSON.parse(json);
+            const instance = {
+                ...data,
+                nestedInstances: new Map(Object.entries(data.nestedInstances)),
+            };
+            this.instances.set(instance.id, instance);
+            return instance;
+        }
+        catch (error) {
+            console.error('Failed to deserialize instance:', error);
+            return null;
+        }
+    }
+    // ─── Queries ───────────────────────────────────────────
+    getPrefab(prefabId) {
+        return this.prefabs.get(prefabId);
+    }
+    getInstance(instanceId) {
+        return this.instances.get(instanceId);
+    }
+    getAllPrefabs() {
+        return Array.from(this.prefabs.values());
+    }
+    getAllInstances() {
+        return Array.from(this.instances.values());
+    }
+    getInstancesOfPrefab(prefabId) {
+        return this.getAllInstances().filter((i) => i.prefabId === prefabId);
+    }
+    searchPrefabs(query) {
+        const lowerQuery = query.toLowerCase();
+        return this.getAllPrefabs().filter((p) => p.name.toLowerCase().includes(lowerQuery) ||
+            p.description.toLowerCase().includes(lowerQuery) ||
+            p.tags.some((t) => t.toLowerCase().includes(lowerQuery)));
+    }
+    getPrefabsByCategory(category) {
+        return this.getAllPrefabs().filter((p) => p.category === category);
+    }
+    getCategories() {
+        const categories = new Set();
+        for (const prefab of this.prefabs.values()) {
+            categories.add(prefab.category);
+        }
+        return Array.from(categories).sort();
+    }
+    // ─── Callbacks ─────────────────────────────────────────
+    setOnPrefabChanged(callback) {
+        this.onPrefabChanged = callback;
+    }
+    setOnInstanceChanged(callback) {
+        this.onInstanceChanged = callback;
+    }
+    // ─── Cleanup ───────────────────────────────────────────
+    deletePrefab(prefabId) {
+        const prefab = this.prefabs.get(prefabId);
+        if (!prefab) {
+            return false;
+        }
+        // Delete all instances
+        for (const instance of this.getInstancesOfPrefab(prefabId)) {
+            this.destroyInstance(instance.id);
+        }
+        // Remove from variants
+        for (const variant of this.prefabs.values()) {
+            if (variant.variantOf === prefabId) {
+                variant.variantOf = undefined;
+            }
+        }
+        // Remove nested references
+        for (const p of this.prefabs.values()) {
+            p.nestedPrefabs = p.nestedPrefabs.filter((n) => n.prefabId !== prefabId);
+        }
+        this.prefabs.delete(prefabId);
+        this.prefabVersions.delete(prefabId);
+        return true;
+    }
+    clear() {
+        this.prefabs.clear();
+        this.instances.clear();
+        this.prefabVersions.clear();
+    }
+}
+// ============================================================
+// Factory Functions
+// ============================================================
+function createPrefabManager() {
+    return new PrefabManager();
+}
+function createDefaultEntity(name = 'Entity') {
+    return {
+        id: `entity_${generateId()}`,
+        name,
+        parentId: null,
+        transform: deepClone(DEFAULT_TRANSFORM),
+        components: [],
+        children: [],
+        tags: [],
+        layer: 'default',
+        active: true,
+    };
+}
+function createComponent(type, properties = {}) {
+    return {
+        id: `component_${generateId()}`,
+        type,
+        properties,
+        enabled: true,
+    };
+}
+
+export { DEFAULT_TRANSFORM, PrefabManager, createComponent, createDefaultEntity, createPrefabManager };
+//# sourceMappingURL=PrefabSystem.js.map