@galacean/engine-loader 0.0.0-experimental-2.0-spine.0 → 0.0.0-experimental-2.0-spine.1

package/dist/main.js

@@ -643,6 +643,39 @@ function float32ArrayToVector2(float32Array, vertexCount) {
     return array;
 }
 
+function _is_native_reflect_construct() {
+    // Since Reflect.construct can't be properly polyfilled, some
+    // implementations (e.g. core-js@2) don't set the correct internal slots.
+    // Those polyfills don't allow us to subclass built-ins, so we need to
+    // use our fallback implementation.
+    try {
+        // If the internal slots aren't set, this throws an error similar to
+        //   TypeError: this is not a Boolean object.
+        var result = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {}));
+    } catch (_) {}
+    return (_is_native_reflect_construct = function() {
+        return !!result;
+    })();
+}
+
+function _construct(Parent, args, Class) {
+    if (_is_native_reflect_construct()) _construct = Reflect.construct;
+    else {
+        _construct = function construct(Parent, args, Class) {
+            var a = [null];
+            a.push.apply(a, args);
+            var Constructor = Function.bind.apply(Parent, a);
+            var instance = new Constructor();
+
+            if (Class) _set_prototype_of(instance, Class.prototype);
+
+            return instance;
+        };
+    }
+
+    return _construct.apply(null, arguments);
+}
+
 function _object_without_properties_loose(source, excluded) {
     if (source == null) return {};
 
@@ -776,16 +809,17 @@ var ReflectionParser = /*#__PURE__*/ function() {
    * 1. null/undefined/primitive → passthrough
    * 2. Array → recurse each element
    * 3. { $ref }       → asset reference
-   * 4. { $type }      → polymorphic type construct
+   * 4. { $type }      → polymorphic type construct; optional $args are constructor args
    * 5. { $class }     → registered class constructor
    * 6. { $entity }    → entity reference by path (flat index + optional children descent)
    * 7. { $component } → component reference
    * 8. { $signal }    → signal binding
-   * 9. plain object   → recurse values (modify originValue in place if exists)
+   * 9. { $props/$calls } → mutate the existing target object
+   * 10. plain object   → recurse values (modify originValue in place if exists)
    */ _proto._resolveValue = function _resolveValue(value, originValue) {
         var _this, _loop = function(key) {
-            promises.push(_this._resolveValue(obj[key], target[key]).then(function(v) {
-                return target[key] = v;
+            promises.push(_this._resolveValue(obj[key], target1[key]).then(function(v) {
+                return target1[key] = v;
             }));
         };
         var _this1 = this;
@@ -814,12 +848,22 @@ var ReflectionParser = /*#__PURE__*/ function() {
         }
         // $type — polymorphic type: construct instance and apply remaining props
         if ("$type" in obj) {
-            var $type = obj.$type, rest = _object_without_properties_loose(obj, [
-                "$type"
+            var $type = obj.$type, $args = obj.$args, $props = obj.$props, $calls = obj.$calls, rest = _object_without_properties_loose(obj, [
+                "$type",
+                "$args",
+                "$props",
+                "$calls"
             ]);
             return this._resolveRegisteredClass($type, "$type").then(function(Class) {
-                var instance = new Class();
-                return Object.keys(rest).length > 0 ? _this1.parseProps(instance, rest) : instance;
+                if ($args !== undefined && !Array.isArray($args)) {
+                    return Promise.reject(new Error("$type.$args must be an array"));
+                }
+                return Promise.all(($args != null ? $args : []).map(function(arg) {
+                    return _this1._resolveValue(arg);
+                })).then(function(resolvedArgs) {
+                    var instance = _construct(Class, [].concat(resolvedArgs));
+                    return _this1._applyRuntimeMutation(instance, Object.keys(rest).length > 0 ? rest : undefined, $props, $calls);
+                });
             });
         }
         // $class — registered class constructor for factory-style methods.
@@ -838,14 +882,50 @@ var ReflectionParser = /*#__PURE__*/ function() {
         if ("$signal" in obj) {
             return this._resolveSignal(originValue, obj.$signal);
         }
+        // Runtime mutation block for existing nested objects.
+        if ("$props" in obj || "$calls" in obj) {
+            var target = originValue && (typeof originValue === "undefined" ? "undefined" : _type_of(originValue)) === "object" && !Array.isArray(originValue) ? originValue : {};
+            return this._applyRuntimeMutation(target, undefined, obj.$props, obj.$calls);
+        }
         // Plain object — recurse each value, modifying originValue in place or building a new object
-        var target = originValue && (typeof originValue === "undefined" ? "undefined" : _type_of(originValue)) === "object" && !Array.isArray(originValue) ? originValue : {};
+        var target1 = originValue && (typeof originValue === "undefined" ? "undefined" : _type_of(originValue)) === "object" && !Array.isArray(originValue) ? originValue : {};
         var promises = [];
         for(var key in obj)_this = this, _loop(key);
         return Promise.all(promises).then(function() {
-            return target;
+            return target1;
         });
     };
+    _proto._applyRuntimeMutation = function _applyRuntimeMutation(target, directProps, runtimeProps, runtimeCalls) {
+        var props = directProps ? _extends({}, directProps) : undefined;
+        var calls;
+        try {
+            var normalizedProps = this._normalizeRuntimeProps(runtimeProps);
+            if (normalizedProps) {
+                props = Object.assign(props != null ? props : {}, normalizedProps);
+            }
+            calls = this._normalizeRuntimeCalls(runtimeCalls);
+        } catch (error) {
+            return Promise.reject(error);
+        }
+        return this.parseMutationBlock(target, {
+            props: props,
+            calls: calls
+        });
+    };
+    _proto._normalizeRuntimeProps = function _normalizeRuntimeProps(props) {
+        if (props === undefined) return undefined;
+        if (props == null || (typeof props === "undefined" ? "undefined" : _type_of(props)) !== "object" || Array.isArray(props)) {
+            throw new Error("$props must be an object");
+        }
+        return props;
+    };
+    _proto._normalizeRuntimeCalls = function _normalizeRuntimeCalls(calls) {
+        if (calls === undefined) return undefined;
+        if (!Array.isArray(calls)) {
+            throw new Error("$calls must be an array");
+        }
+        return calls;
+    };
     _proto._getRegisteredClass = function _getRegisteredClass(value, sentinel) {
         if (typeof value !== "string" || value.length === 0) {
             throw new Error("" + sentinel + " must be a non-empty registered class name string");