@novely/core 0.34.0 → 0.36.0-beta.0

package/dist/index.js

@@ -47,6 +47,7 @@ var MAIN_CONTEXT_KEY = "$MAIN";
 
 // src/shared.ts
 var STACK_MAP = /* @__PURE__ */ new Map();
+var CUSTOM_ACTION_MAP = /* @__PURE__ */ new Map();
 var PRELOADED_ASSETS = /* @__PURE__ */ new Set();
 
 // src/utils.ts
@@ -81,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,
@@ -248,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();
@@ -269,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++) {
@@ -308,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 {
@@ -492,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";
@@ -605,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";
@@ -751,6 +824,76 @@ var replace = (input, data, pluralization, actions, pr) => {
   });
 };
 
+// src/custom-action.ts
+var createCustomActionNode = (id) => {
+  const div = document.createElement("div");
+  div.setAttribute("data-id", id);
+  return div;
+};
+var getCustomActionHolder = (ctx, fn) => {
+  const cached = CUSTOM_ACTION_MAP.get(ctx.id + fn.key);
+  if (cached) {
+    return cached;
+  }
+  const holder = {
+    cleanup: noop,
+    node: null,
+    fn,
+    localData: {}
+  };
+  CUSTOM_ACTION_MAP.set(ctx.id + fn.key, holder);
+  return holder;
+};
+var handleCustomAction = (ctx, fn, { lang, state, setMountElement, setClear, remove: renderersRemove }) => {
+  const holder = getCustomActionHolder(ctx, fn);
+  const flags = {
+    ...ctx.meta
+  };
+  const getDomNodes = (insert = true) => {
+    if (holder.node || !insert) {
+      return {
+        element: holder.node,
+        root: ctx.root
+      };
+    }
+    holder.node = insert ? createCustomActionNode(fn.key) : null;
+    setMountElement(holder.node);
+    return {
+      element: holder.node,
+      root: ctx.root
+    };
+  };
+  const clear = (func) => {
+    setClear(holder.cleanup = () => {
+      func();
+      holder.node = null;
+      holder.cleanup = noop;
+      setMountElement(null);
+      setClear(noop);
+    });
+  };
+  const data = (updatedData) => {
+    if (updatedData) {
+      return holder.localData = updatedData;
+    }
+    return holder.localData;
+  };
+  const remove = () => {
+    holder.cleanup();
+    renderersRemove();
+  };
+  return fn({
+    flags,
+    lang,
+    state,
+    data,
+    clear,
+    remove,
+    rendererContext: ctx,
+    getDomNodes
+  });
+};
+
 // src/storage.ts
 var localStorageStorage = (options) => {
   return {
@@ -825,6 +968,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;
@@ -836,31 +999,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);
       }
@@ -869,6 +1015,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) {
@@ -876,31 +1049,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];
       };
@@ -1027,7 +1176,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);
@@ -1072,7 +1226,7 @@ var novely = ({
         }
         const [action2, fn] = element;
         if (action2 === "custom") {
-          context.clearCustom(fn);
+          getCustomActionHolder(context, fn).cleanup();
         }
       }
     }
@@ -1082,8 +1236,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;
@@ -1197,6 +1351,9 @@ var novely = ({
     }
     return capitalize(language.nameOverride || getIntlLanguageDisplayName(lang));
   };
+  const clearCustomAction = (ctx, fn) => {
+    getCustomActionHolder(ctx, fn).cleanup();
+  };
   const renderer = createRenderer({
     mainContextKey: MAIN_CONTEXT_KEY,
     characters,
@@ -1210,6 +1367,7 @@ var novely = ({
     preview,
     removeContext,
     getStateFunction,
+    clearCustomAction,
     languages,
     storageData,
     coreData,
@@ -1246,6 +1404,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, {
@@ -1453,19 +1645,31 @@ var novely = ({
         forward
       );
     },
-    custom({ ctx, push }, [handler]) {
-      if (handler.requireUserAction) {
+    custom({ ctx, push }, [fn]) {
+      if (fn.requireUserAction) {
         ctx.clearBlockingActions(void 0);
       }
-      const result = ctx.custom(handler, () => {
-        if (ctx.meta.restoring)
-          return;
-        if (handler.requireUserAction && !ctx.meta.preview) {
+      const state = getStateFunction(ctx);
+      const lang = storageData.get().meta[0];
+      const result = handleCustomAction(ctx, fn, {
+        ...ctx.custom(fn),
+        state,
+        lang
+      });
+      const next2 = () => {
+        if (fn.requireUserAction && !ctx.meta.preview) {
           enmemory(ctx);
           interactivity(true);
         }
         push();
-      });
+      };
+      if (!ctx.meta.restoring) {
+        if (isPromise(result)) {
+          result.then(next2);
+        } else {
+          next2();
+        }
+      }
       return result;
     },
     vibrate({ ctx, push }, pattern) {
@@ -1515,6 +1719,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));
       }