@novely/core 0.35.0 → 0.36.0-beta.1

package/dist/index.js

@@ -82,9 +82,16 @@ function klona(val) {
 }
 
 // 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,
@@ -249,7 +256,7 @@ var getOppositeAction = (action) => {
 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();
@@ -270,11 +277,11 @@ var getActionsFromPath = (story, path, filter) => {
       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++) {
@@ -309,7 +316,7 @@ var getActionsFromPath = (story, path, filter) => {
       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 {
@@ -493,6 +500,9 @@ var fetchContentType = async (request, url) => {
   }
 };
 var getResourseType = async (request, url) => {
+  if (!isCSSImage(url)) {
+    return "other";
+  }
   const extension = getUrlFileExtension(url);
   if (HOWLER_SUPPORTED_FILE_FORMATS.has(extension)) {
     return "audio";
@@ -606,6 +616,68 @@ var nextPath = (path) => {
   }
   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;
+};
 
 // src/novely.ts
 import { dequal } from "dequal/lite";
@@ -896,6 +968,31 @@ 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 assetsToPreloadAdd = (asset) => {
+    if (!PRELOADED_ASSETS.has(asset)) {
+      ASSETS_TO_PRELOAD.add(asset);
+    }
+  };
   const scriptBase = async (part) => {
     Object.assign(story, flattenStory(part));
     let loadingIsShown = false;
@@ -907,31 +1004,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);
       }
@@ -940,6 +1020,33 @@ var novely = ({
   const script = (part) => {
     return limitScript(() => scriptBase(part));
   };
+  const checkAndAddToPreloadingList = (action2, props) => {
+    if (action2 === "showBackground") {
+      if (isImageAsset(props[0])) {
+        assetsToPreloadAdd(props[0]);
+      }
+      if (props[0] && typeof props[0] === "object") {
+        for (const value of Object.values(props[0])) {
+          if (!isImageAsset(value))
+            continue;
+          assetsToPreloadAdd(value);
+        }
+      }
+    }
+    if (isAudioAction(action2) && isString(props[0])) {
+      assetsToPreloadAdd(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) {
+          assetsToPreloadAdd(asset);
+        }
+      } else {
+        assetsToPreloadAdd(images);
+      }
+    }
+  };
   const action = new Proxy({}, {
     get(_, action2) {
       if (action2 in renderer.actions) {
@@ -947,31 +1054,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];
       };
@@ -1098,7 +1181,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);
@@ -1153,8 +1241,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;
@@ -1321,6 +1409,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, {
@@ -1602,6 +1724,9 @@ var novely = ({
       render(ctx);
     },
     preload({ ctx, push }, [source]) {
+      if (DEV2 && 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));
       }