@rive-app/canvas-lite 2.37.4 → 2.37.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rive-app/canvas-lite",
-  "version": "2.37.4",
+  "version": "2.37.6",
   "description": "A lite version of Rive's canvas based web api.",
   "main": "rive.js",
   "homepage": "https://rive.app",

package/rive.js

@@ -174,6 +174,16 @@ var RuntimeLoader = /** @class */ (function () {
     // Class is never instantiated
     function RuntimeLoader() {
     }
+    // Rejects all pending awaitInstance() promises and resets loading state so
+    // the next call to getInstance() / awaitInstance() can retry with a new URL.
+    RuntimeLoader.notifyError = function (error) {
+        var _a;
+        RuntimeLoader.isLoading = false;
+        while (RuntimeLoader.errorCallbackQueue.length > 0) {
+            (_a = RuntimeLoader.errorCallbackQueue.shift()) === null || _a === void 0 ? void 0 : _a(error);
+        }
+        RuntimeLoader.callBackQueue = [];
+    };
     // Loads the runtime
     RuntimeLoader.loadRuntime = function () {
         // Capture the URL at call time so the catch closure always refers to the
@@ -192,6 +202,7 @@ var RuntimeLoader = /** @class */ (function () {
                 performance.measure('rive:wasm-init', 'rive:wasm-init:start', 'rive:wasm-init:end');
             }
             RuntimeLoader.runtime = rive;
+            RuntimeLoader.errorCallbackQueue = [];
             // Fire all the callbacks
             while (RuntimeLoader.callBackQueue.length > 0) {
                 (_a = RuntimeLoader.callBackQueue.shift()) === null || _a === void 0 ? void 0 : _a(RuntimeLoader.runtime);
@@ -244,14 +255,15 @@ var RuntimeLoader = /** @class */ (function () {
                     "\nTo resolve, you may need to:",
                     "1. Check your network connection",
                     "2. Set a new WASM source via RuntimeLoader.setWasmUrl()",
-                    "3. Call RuntimeLoader.loadRuntime() again",
+                    "3. Call RuntimeLoader.awaitInstance() again",
                 ].join("\n");
                 console.error(errorMessage);
+                RuntimeLoader.notifyError(new Error(errorMessage));
             }
         });
     };
     // Provides a runtime instance via a callback
-    RuntimeLoader.getInstance = function (callback) {
+    RuntimeLoader.getInstance = function (callback, onError) {
         // If it's not loading, start loading runtime
         if (!RuntimeLoader.isLoading) {
             RuntimeLoader.isLoading = true;
@@ -259,15 +271,18 @@ var RuntimeLoader = /** @class */ (function () {
         }
         if (!RuntimeLoader.runtime) {
             RuntimeLoader.callBackQueue.push(callback);
+            if (onError) {
+                RuntimeLoader.errorCallbackQueue.push(onError);
+            }
         }
         else {
             callback(RuntimeLoader.runtime);
         }
     };
-    // Provides a runtime instance via a promise
+    // Provides a runtime instance via a promise; rejects if WASM fails to load.
     RuntimeLoader.awaitInstance = function () {
-        return new Promise(function (resolve) {
-            return RuntimeLoader.getInstance(function (rive) { return resolve(rive); });
+        return new Promise(function (resolve, reject) {
+            return RuntimeLoader.getInstance(resolve, reject);
         });
     };
     // Manually sets the wasm url
@@ -314,6 +329,8 @@ var RuntimeLoader = /** @class */ (function () {
     // the fallback entirely. Defaults to pulling from the jsdelivr CDN.
     RuntimeLoader.wasmFallbackURL = "https://cdn.jsdelivr.net/npm/".concat(package_json__WEBPACK_IMPORTED_MODULE_1__.name, "@").concat(package_json__WEBPACK_IMPORTED_MODULE_1__.version, "/rive_fallback.wasm");
     RuntimeLoader.wasmBinary = null;
+    // Error callbacks enqueued from .getInstance()
+    RuntimeLoader.errorCallbackQueue = [];
     /**
      * When true, performance.mark / performance.measure entries are emitted for
      * WASM initialization.
@@ -2529,7 +2546,7 @@ moduleRtn = da;
 /* 5 */
 /***/ ((module) => {
 
-module.exports = /*#__PURE__*/JSON.parse('{"name":"@rive-app/canvas-lite","version":"2.37.4","description":"A lite version of Rive\'s canvas based web api.","main":"rive.js","homepage":"https://rive.app","repository":{"type":"git","url":"https://github.com/rive-app/rive-wasm/tree/master/js"},"keywords":["rive","animation"],"author":"Rive","contributors":["Luigi Rosso <luigi@rive.app> (https://rive.app)","Maxwell Talbot <max@rive.app> (https://rive.app)","Arthur Vivian <arthur@rive.app> (https://rive.app)","Umberto Sonnino <umberto@rive.app> (https://rive.app)","Matthew Sullivan <matt.j.sullivan@gmail.com> (mailto:matt.j.sullivan@gmail.com)"],"license":"MIT","files":["rive.js","rive.js.map","rive.wasm","rive_fallback.wasm","rive.d.ts","rive_advanced.mjs.d.ts","runtimeLoader.d.ts","utils"],"typings":"rive.d.ts","dependencies":{},"browser":{"fs":false,"path":false}}');
+module.exports = /*#__PURE__*/JSON.parse('{"name":"@rive-app/canvas-lite","version":"2.37.6","description":"A lite version of Rive\'s canvas based web api.","main":"rive.js","homepage":"https://rive.app","repository":{"type":"git","url":"https://github.com/rive-app/rive-wasm/tree/master/js"},"keywords":["rive","animation"],"author":"Rive","contributors":["Luigi Rosso <luigi@rive.app> (https://rive.app)","Maxwell Talbot <max@rive.app> (https://rive.app)","Arthur Vivian <arthur@rive.app> (https://rive.app)","Umberto Sonnino <umberto@rive.app> (https://rive.app)","Matthew Sullivan <matt.j.sullivan@gmail.com> (mailto:matt.j.sullivan@gmail.com)"],"license":"MIT","files":["rive.js","rive.js.map","rive.wasm","rive_fallback.wasm","rive.d.ts","rive_advanced.mjs.d.ts","runtimeLoader.d.ts","utils"],"typings":"rive.d.ts","dependencies":{},"browser":{"fs":false,"path":false}}');
 
 /***/ }),
 /* 6 */
@@ -3883,7 +3900,8 @@ var Animator = /** @class */ (function () {
      * @param animatables the name(s) of animations to add
      * @param playing whether animations should play on instantiation
      */
-    Animator.prototype.initLinearAnimations = function (animatables, playing) {
+    Animator.prototype.initLinearAnimations = function (animatables, playing, isFallingBackFromStateMachines) {
+        if (isFallingBackFromStateMachines === void 0) { isFallingBackFromStateMachines = false; }
         // Play/pause already instanced items, or create new instances
         // This validation is kept to maintain compatibility with current behavior.
         // But given that it this is called during artboard initialization
@@ -3904,6 +3922,10 @@ var Animator = /** @class */ (function () {
                     newAnimation.apply(1.0);
                     this.animations.push(newAnimation);
                 }
+                else if (isFallingBackFromStateMachines) { // Throw LoadError if we cannot load the state machine name at all
+                    var smInitializationMessage = "State Machine with name ".concat(animatables[i], " not found");
+                    throw new RiveError(smInitializationMessage);
+                }
                 else {
                     console.error("Animation with name ".concat(animatables[i], " not found."));
                 }
@@ -3934,10 +3956,11 @@ var Animator = /** @class */ (function () {
                     this.stateMachines.push(newStateMachine);
                 }
                 else {
-                    console.warn("State Machine with name ".concat(animatables[i], " not found."));
+                    console.warn("State Machine with name ".concat(animatables[i], " not found. Falling back to find an animation with the same name."));
+                    // TODO: Remove this fallback in next major release as it complicates initialization.
                     // In order to maintain compatibility with current behavior, if a state machine is not found
                     // we look for an animation with the same name
-                    this.initLinearAnimations([animatables[i]], playing);
+                    this.initLinearAnimations([animatables[i]], playing, true);
                 }
             }
         }
@@ -4539,17 +4562,26 @@ var RiveFile = /** @class */ (function () {
     };
     RiveFile.prototype.initData = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var _a, loader, loaderWrapper, _b, fileFinalizer;
+            var _a, error_1, loader, loaderWrapper, _b, fileFinalizer;
             return __generator(this, function (_c) {
                 switch (_c.label) {
                     case 0:
-                        if (!(this.src && !this.buffer)) return [3 /*break*/, 2];
+                        if (!(this.src && !this.buffer)) return [3 /*break*/, 4];
+                        _c.label = 1;
+                    case 1:
+                        _c.trys.push([1, 3, , 4]);
                         _a = this;
                         return [4 /*yield*/, loadRiveFile(this.src)];
-                    case 1:
-                        _a.buffer = _c.sent();
-                        _c.label = 2;
                     case 2:
+                        _a.buffer = _c.sent();
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_1 = _c.sent();
+                        if (error_1 instanceof Error) {
+                            throw error_1;
+                        }
+                        throw new RiveError(RiveFile.fileLoadErrorMessage);
+                    case 4:
                         if (this.destroyed) {
                             return [2 /*return*/];
                         }
@@ -4562,7 +4594,7 @@ var RiveFile = /** @class */ (function () {
                             performance.mark('rive:file-load:start');
                         _b = this;
                         return [4 /*yield*/, this.runtime.load(new Uint8Array(this.buffer), loader, this.enableRiveAssetCDN)];
-                    case 3:
+                    case 5:
                         _b.file = _c.sent();
                         if (this.enablePerfMarks) {
                             performance.mark('rive:file-load:end');
@@ -4626,7 +4658,7 @@ var RiveFile = /** @class */ (function () {
     };
     RiveFile.prototype.init = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var _a, bufferResolved, runtimeResolved, error_1;
+            var _a, bufferResolved, runtimeResolved, error_2;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
@@ -4658,8 +4690,8 @@ var RiveFile = /** @class */ (function () {
                         }
                         return [3 /*break*/, 5];
                     case 4:
-                        error_1 = _b.sent();
-                        this.fireLoadError(error_1 instanceof Error ? error_1.message : RiveFile.fileLoadErrorMessage);
+                        error_2 = _b.sent();
+                        this.fireLoadError(error_2 instanceof Error ? error_2.message : RiveFile.fileLoadErrorMessage);
                         return [3 /*break*/, 5];
                     case 5: return [2 /*return*/];
                 }
@@ -4671,7 +4703,7 @@ var RiveFile = /** @class */ (function () {
             type: EventType.LoadError,
             data: message,
         });
-        throw new Error(message);
+        throw new RiveError(message);
     };
     /**
      * Subscribe to Rive-generated events
@@ -4995,11 +5027,13 @@ var Rive = /** @class */ (function () {
                 }
             })
                 .catch(function (e) {
+                // initData already catches RiveErrors for load issues like artboard/state machine initialization
+                // failures, so just console error and catch here so we don't double-fire the LoadError event
                 console.error(e);
             });
         })
             .catch(function (e) {
-            console.error(e);
+            _this.eventManager.fire({ type: EventType.LoadError, data: e.message });
         });
     };
     /**
@@ -5081,7 +5115,7 @@ var Rive = /** @class */ (function () {
     // Returns true for successful initialization.
     Rive.prototype.initData = function (artboardName, animationNames, stateMachineNames, autoplay, autoBind) {
         return __awaiter(this, void 0, void 0, function () {
-            var riveFile, error_2, msg;
+            var riveFile, error_3, msg;
             var _a;
             return __generator(this, function (_b) {
                 switch (_b.label) {
@@ -5115,11 +5149,19 @@ var Rive = /** @class */ (function () {
                         // Check for audio
                         this.initializeAudio();
                         // Everything's set up, emit a load event
-                        this.loaded = true;
-                        this.eventManager.fire({
-                            type: EventType.Load,
-                            data: (_a = this.src) !== null && _a !== void 0 ? _a : "buffer",
-                        });
+                        try {
+                            this.loaded = true;
+                            this.eventManager.fire({
+                                type: EventType.Load,
+                                data: (_a = this.src) !== null && _a !== void 0 ? _a : "buffer",
+                            });
+                        }
+                        catch (e) {
+                            // If any synchronous errors surface from the user-supplied onLoad callback,
+                            // this will console.error the error but will not invoke LoadError (onLoadError).
+                            // Notably, this will not interfere with Rive rendering
+                            console.error(e);
+                        }
                         // Only initialize paused state machines after the load event has been fired
                         // to allow users to initialize inputs and view models before the first advance
                         this.animator.advanceIfPaused();
@@ -5130,9 +5172,8 @@ var Rive = /** @class */ (function () {
                         this.drawFrame();
                         return [2 /*return*/, true];
                     case 3:
-                        error_2 = _b.sent();
-                        msg = resolveErrorMessage(error_2);
-                        console.warn(msg);
+                        error_3 = _b.sent();
+                        msg = resolveErrorMessage(error_3);
                         this.eventManager.fire({ type: EventType.LoadError, data: msg });
                         return [2 /*return*/, Promise.reject(msg)];
                     case 4: return [2 /*return*/];
@@ -5151,10 +5192,7 @@ var Rive = /** @class */ (function () {
             : this.file.defaultArtboard();
         // Check we have a working artboard
         if (!rootArtboard) {
-            var msg = "Invalid artboard name or no default artboard";
-            console.warn(msg);
-            this.eventManager.fire({ type: EventType.LoadError, data: msg });
-            return;
+            throw new RiveError("Invalid artboard name or no default artboard");
         }
         this.artboard = rootArtboard;
         rootArtboard.volume = this._volume * audioManager.systemVolume;
@@ -7173,6 +7211,9 @@ var loadRiveFile = function (src) { return __awaiter(void 0, void 0, void 0, fun
                 return [4 /*yield*/, fetch(req)];
             case 1:
                 res = _a.sent();
+                if (!res.ok) {
+                    throw new Error("Failed to fetch the Rive file: HTTP ".concat(res.status));
+                }
                 return [4 /*yield*/, res.arrayBuffer()];
             case 2:
                 buffer = _a.sent();