@novely/core 0.35.0 → 0.36.0-beta.0

package/dist/index.d.ts

@@ -452,7 +452,7 @@ interface NovelyInit<$Language extends Lang, $Characters extends Record<string,
     /**
      * @default "lazy"
      */
-    preloadAssets?: 'lazy' | 'blocking';
+    preloadAssets?: 'lazy' | 'blocking' | 'automatic';
     /**
      * Fetching function
      */

package/dist/index.global.js

@@ -245,9 +245,16 @@ var Novely = (() => {
   }
 
   // src/utils.ts
-  var matchAction = ({ getContext, push, forward }, values) => {
+  var matchAction = ({ getContext, onBeforeActionCall, push, forward }, values) => {
     return (action, props, { ctx, data }) => {
       const context = typeof ctx === "string" ? getContext(ctx) : ctx;
+      if (action !== "say") {
+        onBeforeActionCall({
+          action,
+          props,
+          ctx: context
+        });
+      }
       return values[action]({
         ctx: context,
         data,
@@ -412,7 +419,7 @@ var Novely = (() => {
   var getActionsFromPath = (story, path, filter) => {
     let current = story;
     let precurrent;
-    let ignoreNested = false;
+    let ignoreNestedBefore = null;
     let index = 0;
     let skipPreserve = void 0;
     const skip = /* @__PURE__ */ new Set();
@@ -433,11 +440,11 @@ var Novely = (() => {
         if (isNumber(val)) {
           index++;
           let startIndex = 0;
-          if (ignoreNested) {
-            const prev = findLastPathItemBeforeItemOfType(path.slice(0, index), "block");
+          if (ignoreNestedBefore) {
+            const prev = findLastPathItemBeforeItemOfType(path.slice(0, index), ignoreNestedBefore);
             if (prev) {
               startIndex = prev[1];
-              ignoreNested = false;
+              ignoreNestedBefore = null;
             }
           }
           for (let i = startIndex; i <= val; i++) {
@@ -472,7 +479,7 @@ var Novely = (() => {
         current = story[val];
       } else if (type === "block:exit" || type === "choice:exit" || type === "condition:exit") {
         current = blocks.pop();
-        ignoreNested = true;
+        ignoreNestedBefore = type.slice(0, -5);
       }
     }
     return {
@@ -656,6 +663,9 @@ var Novely = (() => {
     }
   };
   var getResourseType = async (request, url) => {
+    if (!isCSSImage(url)) {
+      return "other";
+    }
     const extension = getUrlFileExtension(url);
     if (HOWLER_SUPPORTED_FILE_FORMATS.has(extension)) {
       return "audio";
@@ -769,6 +779,68 @@ var Novely = (() => {
     }
     return path;
   };
+  var isBlockingAction = (action) => {
+    return isUserRequiredAction(action) || isSkippedDuringRestore(action[0]) && action[0] !== "vibrate";
+  };
+  var collectActionsBeforeBlockingAction = ({ path, refer }) => {
+    const collection = [];
+    let action = refer(path);
+    while (true) {
+      if (action == void 0) {
+        const { exitImpossible } = exitPath({
+          path,
+          refer
+        });
+        if (exitImpossible) {
+          break;
+        }
+      }
+      if (!action) {
+        break;
+      }
+      if (isBlockingAction(action)) {
+        const [name, ...props] = action;
+        if (name === "choice") {
+          const choiceProps = props;
+          for (let i = 0; i < choiceProps.length; i++) {
+            const branchContent = choiceProps[i];
+            if (!Array.isArray(branchContent))
+              continue;
+            const virtualPath = klona(path);
+            virtualPath.push(["choice", i], [null, 0]);
+            const innerActions = collectActionsBeforeBlockingAction({
+              path: virtualPath,
+              refer
+            });
+            collection.push(...innerActions);
+          }
+        } else if (name === "condition") {
+          const conditionProps = props;
+          const conditions = Object.keys(conditionProps[1]);
+          for (const condition of conditions) {
+            const virtualPath = klona(path);
+            virtualPath.push(["condition", condition], [null, 0]);
+            const innerActions = collectActionsBeforeBlockingAction({
+              path: virtualPath,
+              refer
+            });
+            collection.push(...innerActions);
+          }
+        }
+        break;
+      }
+      collection.push(action);
+      if (action[0] === "jump") {
+        path = [["jump", action[1]], [null, 0]];
+      } else if (action[0] == "block") {
+        path.push(["block", action[1]], [null, 0]);
+      } else {
+        nextPath(path);
+      }
+      action = refer(path);
+    }
+    return collection;
+  };
 
   // ../../node_modules/.pnpm/dequal@2.0.3/node_modules/dequal/lite/index.mjs
   var has = Object.prototype.hasOwnProperty;
@@ -1087,6 +1159,26 @@ var Novely = (() => {
     const intime = (value) => {
       return times.add(value), value;
     };
+    const handleAssetsPreloading = async () => {
+      const { preloadAudioBlocking, preloadImageBlocking } = renderer.misc;
+      const list = mapSet(ASSETS_TO_PRELOAD, (asset) => {
+        return limitAssetsDownload(async () => {
+          const type = await getResourseType(request, asset);
+          switch (type) {
+            case "audio": {
+              await preloadAudioBlocking(asset);
+              break;
+            }
+            case "image": {
+              await preloadImageBlocking(asset);
+              break;
+            }
+          }
+        });
+      });
+      await Promise.allSettled(list);
+      ASSETS_TO_PRELOAD.clear();
+    };
     const scriptBase = async (part) => {
       Object.assign(story, flattenStory(part));
       let loadingIsShown = false;
@@ -1098,31 +1190,14 @@ var Novely = (() => {
         if (!loadingIsShown) {
           renderer.ui.showLoading();
         }
-        const { preloadAudioBlocking, preloadImageBlocking } = renderer.misc;
-        const list = mapSet(ASSETS_TO_PRELOAD, (asset) => {
-          return limitAssetsDownload(async () => {
-            const type = await getResourseType(request, asset);
-            switch (type) {
-              case "audio": {
-                await preloadAudioBlocking(asset);
-                break;
-              }
-              case "image": {
-                await preloadImageBlocking(asset);
-                break;
-              }
-            }
-          });
-        });
-        await Promise.allSettled(list);
+        await handleAssetsPreloading();
       }
-      ASSETS_TO_PRELOAD.clear();
       await dataLoaded.promise;
       renderer.ui.hideLoading();
       if (!initialScreenWasShown) {
         initialScreenWasShown = true;
         if (initialScreen === "game") {
-          restore();
+          restore(void 0);
         } else {
           renderer.ui.showScreen(initialScreen);
         }
@@ -1131,6 +1206,33 @@ var Novely = (() => {
     const script = (part) => {
       return limitScript(() => scriptBase(part));
     };
+    const checkAndAddToPreloadingList = (action2, props) => {
+      if (action2 === "showBackground") {
+        if (isImageAsset(props[0])) {
+          ASSETS_TO_PRELOAD.add(props[0]);
+        }
+        if (props[0] && typeof props[0] === "object") {
+          for (const value of Object.values(props[0])) {
+            if (!isImageAsset(value))
+              continue;
+            ASSETS_TO_PRELOAD.add(value);
+          }
+        }
+      }
+      if (isAudioAction(action2) && isString(props[0])) {
+        ASSETS_TO_PRELOAD.add(props[0]);
+      }
+      if (action2 === "showCharacter" && isString(props[0]) && isString(props[1])) {
+        const images = characters[props[0]].emotions[props[1]];
+        if (Array.isArray(images)) {
+          for (const asset of images) {
+            ASSETS_TO_PRELOAD.add(asset);
+          }
+        } else {
+          ASSETS_TO_PRELOAD.add(images);
+        }
+      }
+    };
     const action = new Proxy({}, {
       get(_, action2) {
         if (action2 in renderer.actions) {
@@ -1138,31 +1240,7 @@ var Novely = (() => {
         }
         return (...props) => {
           if (preloadAssets === "blocking") {
-            if (action2 === "showBackground") {
-              if (isImageAsset(props[0])) {
-                ASSETS_TO_PRELOAD.add(props[0]);
-              }
-              if (props[0] && typeof props[0] === "object") {
-                for (const value of Object.values(props[0])) {
-                  if (!isImageAsset(value))
-                    continue;
-                  ASSETS_TO_PRELOAD.add(value);
-                }
-              }
-            }
-            if (isAudioAction(action2) && isString(props[0])) {
-              ASSETS_TO_PRELOAD.add(props[0]);
-            }
-            if (action2 === "showCharacter" && isString(props[0]) && isString(props[1])) {
-              const images = characters[props[0]].emotions[props[1]];
-              if (Array.isArray(images)) {
-                for (const asset of images) {
-                  ASSETS_TO_PRELOAD.add(asset);
-                }
-              } else {
-                ASSETS_TO_PRELOAD.add(images);
-              }
-            }
+            checkAndAddToPreloadingList(action2, props);
           }
           return [action2, ...props];
         };
@@ -1289,7 +1367,12 @@ var Novely = (() => {
           return prev.saves.push(save2), prev;
         });
       }
-      restore(save2);
+      const context = renderer.getContext(MAIN_CONTEXT_KEY);
+      const stack = useStack(context);
+      stack.value = save2;
+      context.meta.restoring = context.meta.goingBack = false;
+      renderer.ui.showScreen("game");
+      render(context);
     };
     const set = (save2, ctx) => {
       const stack = useStack(ctx || MAIN_CONTEXT_KEY);
@@ -1344,8 +1427,8 @@ var Novely = (() => {
           data: latest[1]
         });
       }
-      const lastQueueItem = queue.at(-1) || [];
-      const lastQueueItemRequiresUserAction = isSkippedDuringRestore(lastQueueItem[0]) || isUserRequiredAction(lastQueueItem);
+      const lastQueueItem = queue.at(-1);
+      const lastQueueItemRequiresUserAction = lastQueueItem && isBlockingAction(lastQueueItem);
       await run((item) => {
         if (!latest)
           return;
@@ -1512,6 +1595,40 @@ var Novely = (() => {
         matchActionOptions.push(ctx);
         if (!ctx.meta.preview)
           interactivity(true);
+      },
+      onBeforeActionCall({ action: action2, props, ctx }) {
+        if (preloadAssets !== "automatic")
+          return;
+        if (ctx.meta.preview || ctx.meta.restoring)
+          return;
+        if (!isBlockingAction([action2, ...props]))
+          return;
+        try {
+          const collection = collectActionsBeforeBlockingAction({
+            path: nextPath(klona(useStack(ctx).value[0])),
+            refer
+          });
+          for (const [action3, ...props2] of collection) {
+            checkAndAddToPreloadingList(action3, props2);
+          }
+          const { preloadAudioBlocking, preloadImage } = renderer.misc;
+          ASSETS_TO_PRELOAD.forEach(async (asset) => {
+            ASSETS_TO_PRELOAD.delete(asset);
+            const type = await getResourseType(request, asset);
+            switch (type) {
+              case "audio": {
+                preloadAudioBlocking(asset);
+                break;
+              }
+              case "image": {
+                preloadImage(asset);
+                break;
+              }
+            }
+          });
+        } catch (cause) {
+          console.error(cause);
+        }
       }
     };
     const match = matchAction(matchActionOptions, {
@@ -1793,6 +1910,9 @@ var Novely = (() => {
         render(ctx);
       },
       preload({ ctx, push }, [source]) {
+        if (DEV && preloadAssets !== "lazy") {
+          console.error(`You do not need a preload action becase "preloadAssets" strategy was set to "${preloadAssets}"`);
+        }
         if (!ctx.meta.goingBack && !ctx.meta.restoring && !PRELOADED_ASSETS.has(source)) {
           PRELOADED_ASSETS.add(renderer.misc.preloadImage(source));
         }