@galacean/engine-loader 2.0.0-alpha.46 → 2.0.0-alpha.47

package/README.md

@@ -1 +1,3 @@
-A subpackage of `@galacean/engine`.
+A subpackage of `@galacean/engine`.
+
+Hierarchy loading creates all ordinary and instance-added components before resolving component properties and calls. References use the template component order plus additions; removals run afterward, so deleting a component does not shift a selector before its reference is resolved. Scene and Prefab loading share this lifecycle.

package/dist/main.js

@@ -1451,16 +1451,31 @@ function _instanceof(left, right) {
         var refs = this.data.refs;
         for(var i = 0, n = entities.length; i < n; i++){
             var entityConfig = entities[i];
-            if (HierarchyParser._isPrefabInstanceEntity(entityConfig)) continue;
             var entity = entityInstances[i];
+            if (HierarchyParser._isPrefabInstanceEntity(entityConfig)) {
+                var _entityConfig_instance_overrides;
+                var additions = (_entityConfig_instance_overrides = entityConfig.instance.overrides) == null ? void 0 : _entityConfig_instance_overrides.addedComponents;
+                var _additions_length;
+                for(var j = 0, m = (_additions_length = additions == null ? void 0 : additions.length) != null ? _additions_length : 0; j < m; j++){
+                    var added = additions[j];
+                    var target = HierarchyParser._resolveEntity(entity, added.target);
+                    var config = allComponents[added.component];
+                    var instance = HierarchyParser._addComponentFromConfig(target, config, refs);
+                    pendingComponents.push({
+                        instance: instance,
+                        config: config
+                    });
+                }
+                continue;
+            }
             var componentIndices = entityConfig.components;
             if (!componentIndices) continue;
-            for(var j = 0, m = componentIndices.length; j < m; j++){
-                var config = allComponents[componentIndices[j]];
-                var instance = HierarchyParser._addComponentFromConfig(entity, config, refs);
+            for(var j1 = 0, m1 = componentIndices.length; j1 < m1; j1++){
+                var config1 = allComponents[componentIndices[j1]];
+                var instance1 = HierarchyParser._addComponentFromConfig(entity, config1, refs);
                 pendingComponents.push({
-                    instance: instance,
-                    config: config
+                    instance: instance1,
+                    config: config1
                 });
             }
         }
@@ -1495,7 +1510,6 @@ function _instanceof(left, right) {
         return Promise.all(promises);
     };
     _proto._applyOverrides = function _applyOverrides(rootEntity, overrides, promises) {
-        var refs = this.data.refs;
         var reflectionParser = this._reflectionParser;
         // entityProps — entity-level property overrides
         if (overrides.entityProps) {
@@ -1513,50 +1527,39 @@ function _instanceof(left, right) {
                 promises.push(reflectionParser.parseMutationBlock(target, override1));
             }
         }
-        // addedComponents — attach top-level components[index] to a prefab entity and parse props
-        if (overrides.addedComponents) {
-            var allComponents = this.data.components;
-            for(var j2 = 0, m2 = overrides.addedComponents.length; j2 < m2; j2++){
-                var added = overrides.addedComponents[j2];
-                var entity1 = HierarchyParser._resolveEntity(rootEntity, added.target);
-                var config = allComponents[added.component];
-                var component = HierarchyParser._addComponentFromConfig(entity1, config, refs);
-                promises.push(reflectionParser.parseMutationBlock(component, config));
-            }
-        }
         // addedEntities — attach already-created top-level entityInstances[index] as a child
         if (overrides.addedEntities) {
             var entityInstances = this.context.entityInstances;
-            for(var j3 = 0, m3 = overrides.addedEntities.length; j3 < m3; j3++){
-                var added1 = overrides.addedEntities[j3];
-                var parent = HierarchyParser._resolveEntity(rootEntity, added1.parent);
-                parent.addChild(entityInstances[added1.entity]);
+            for(var j2 = 0, m2 = overrides.addedEntities.length; j2 < m2; j2++){
+                var added = overrides.addedEntities[j2];
+                var parent = HierarchyParser._resolveEntity(rootEntity, added.parent);
+                parent.addChild(entityInstances[added.entity]);
             }
         }
         // removedEntities — pre-resolve all targets then destroy (destroy shifts sibling indices)
         if (overrides.removedEntities) {
             var removed = overrides.removedEntities;
             var targets = new Array(removed.length);
-            for(var j4 = 0, m4 = removed.length; j4 < m4; j4++){
-                targets[j4] = HierarchyParser._resolveEntity(rootEntity, removed[j4]);
+            for(var j3 = 0, m3 = removed.length; j3 < m3; j3++){
+                targets[j3] = HierarchyParser._resolveEntity(rootEntity, removed[j3]);
             }
-            for(var j5 = 0, m5 = targets.length; j5 < m5; j5++){
-                targets[j5].destroy();
+            for(var j4 = 0, m4 = targets.length; j4 < m4; j4++){
+                targets[j4].destroy();
             }
         }
         // removedComponents — pre-resolve all targets then destroy (destroy shifts component indices)
         if (overrides.removedComponents) {
             var targets1 = [];
-            for(var j6 = 0, m6 = overrides.removedComponents.length; j6 < m6; j6++){
-                var override2 = overrides.removedComponents[j6];
-                var entity2 = HierarchyParser._resolveEntity(rootEntity, override2.path);
+            for(var j5 = 0, m5 = overrides.removedComponents.length; j5 < m5; j5++){
+                var override2 = overrides.removedComponents[j5];
+                var entity1 = HierarchyParser._resolveEntity(rootEntity, override2.path);
                 var selectors = override2.selectors;
                 for(var k = 0, p = selectors.length; k < p; k++){
-                    targets1.push(HierarchyParser._resolveComponent(entity2, selectors[k]));
+                    targets1.push(HierarchyParser._resolveComponent(entity1, selectors[k]));
                 }
             }
-            for(var j7 = 0, m7 = targets1.length; j7 < m7; j7++){
-                targets1[j7].destroy();
+            for(var j6 = 0, m6 = targets1.length; j6 < m6; j6++){
+                targets1[j6].destroy();
             }
         }
     };