@novely/core 0.24.0 → 0.26.0

package/dist/index.global.js

@@ -161,7 +161,7 @@ var Novely = (() => {
   });
 
   // src/constants.ts
-  var SKIPPED_DURING_RESTORE = /* @__PURE__ */ new Set(["dialog", "choice", "input", "vibrate", "text"]);
+  var SKIPPED_DURING_RESTORE = /* @__PURE__ */ new Set(["dialog", "say", "choice", "input", "vibrate", "text"]);
   var BLOCK_EXIT_STATEMENTS = /* @__PURE__ */ new Set(["choice:exit", "condition:exit", "block:exit"]);
   var BLOCK_STATEMENTS = /* @__PURE__ */ new Set(["choice", "condition", "block"]);
   var AUDIO_ACTIONS = /* @__PURE__ */ new Set([
@@ -256,8 +256,8 @@ var Novely = (() => {
     return startsWith("http") || startsWith("/") || startsWith(".") || startsWith("data");
   };
   var str = String;
-  var isUserRequiredAction = (action, meta) => {
-    return action === "custom" && meta[0] && meta[0].requireUserAction;
+  var isUserRequiredAction = ([action, ...meta]) => {
+    return Boolean(action === "custom" && meta[0] && meta[0].requireUserAction);
   };
   var getLanguage = (languages) => {
     let { language } = navigator;
@@ -378,11 +378,13 @@ var Novely = (() => {
     };
     return MAP[action];
   };
-  var getActionsFromPath = (story, path, raw = false) => {
+  var getActionsFromPath = (story, path, filter) => {
     let current = story;
     let precurrent;
     let ignoreNested = false;
     let index = 0;
+    let skipPreserve = void 0;
+    const skip = /* @__PURE__ */ new Set();
     const max = path.reduce((acc, [type, val]) => {
       if (isNull(type) && isNumber(val)) {
         return acc + 1;
@@ -411,21 +413,19 @@ var Novely = (() => {
             const item = current[i];
             if (!isAction(item))
               continue;
-            const [action, ...meta] = item;
-            const push = () => {
-              queue.push([action, meta]);
-            };
-            if (raw) {
-              push();
-              continue;
+            const [action] = item;
+            const last = index === max && i === val;
+            const shouldSkip = isSkippedDuringRestore(action) || isUserRequiredAction(item);
+            if (shouldSkip) {
+              skip.add(item);
             }
-            if (isSkippedDuringRestore(action) || isUserRequiredAction(action, meta)) {
-              if (index === max && i === val) {
-                push();
-              }
+            if (shouldSkip && last) {
+              skipPreserve = item;
+            }
+            if (filter && shouldSkip && !last) {
               continue;
             } else {
-              push();
+              queue.push(item);
             }
           }
         }
@@ -444,9 +444,13 @@ var Novely = (() => {
         ignoreNested = true;
       }
     }
-    return queue;
+    return {
+      queue,
+      skip,
+      skipPreserve
+    };
   };
-  var createQueueProcessor = (queue) => {
+  var createQueueProcessor = (queue, options) => {
     const processedQueue = [];
     const keep = /* @__PURE__ */ new Set();
     const characters = /* @__PURE__ */ new Set();
@@ -455,70 +459,83 @@ var Novely = (() => {
       sound: /* @__PURE__ */ new Set()
     };
     const next = (i) => queue.slice(i + 1);
-    for (const [i, [action, meta]] of queue.entries()) {
+    for (const [i, item] of queue.entries()) {
+      const [action, ...params] = item;
       keep.add(action);
+      if (options.skip.has(item) && item !== options.skipPreserve) {
+        continue;
+      }
       if (action === "function" || action === "custom") {
-        if (action === "custom" && meta[0].callOnlyLatest) {
-          const notLatest = next(i).some(([, _meta]) => {
-            if (!_meta || !meta)
+        if (action === "custom" && params[0].callOnlyLatest) {
+          const notLatest = next(i).some(([, func]) => {
+            if (!isFunction(func))
               return false;
-            const c0 = _meta[0];
-            const c1 = meta[0];
-            const isIdenticalID = c0.id && c1.id && c0.id === c1.id;
+            const c0 = func;
+            const c1 = params[0];
+            const isIdenticalID = Boolean(c0.id && c1.id && c0.id === c1.id);
             const isIdenticalByReference = c0 === c1;
             return isIdenticalID || isIdenticalByReference || str(c0) === str(c1);
           });
           if (notLatest)
             continue;
         }
-        processedQueue.push([action, meta]);
+        processedQueue.push(item);
       } else if (action === "showCharacter" || action === "playSound" || action === "playMusic" || action === "voice") {
         const closing = getOppositeAction(action);
-        const skip = next(i).some(([_action, _meta]) => {
-          if (!_meta || !meta)
-            return false;
-          if (_meta[0] !== meta[0])
+        const skip = next(i).some(([_action, target]) => {
+          if (target !== params[0]) {
             return false;
+          }
           return _action === closing || _action === action;
         });
         if (skip)
           continue;
         if (action === "showCharacter") {
-          characters.add(meta[0]);
+          characters.add(params[0]);
         } else if (action === "playMusic") {
-          audio.music.add(meta[0]);
+          audio.music.add(params[0]);
         } else if (action === "playSound") {
-          audio.sound.add(meta[0]);
+          audio.sound.add(params[0]);
         }
-        processedQueue.push([action, meta]);
-      } else if (action === "showBackground" || action === "animateCharacter" || action === "preload") {
-        const skip = next(i).some(([_action], i2, array) => action === _action);
+        processedQueue.push(item);
+      } else if (action === "showBackground" || action === "preload") {
+        const skip = next(i).some(([_action]) => action === _action);
+        if (skip)
+          continue;
+        processedQueue.push(item);
+      } else if (action === "animateCharacter") {
+        const skip = next(i).some(([_action, character], j, array) => {
+          if (action === _action && character === params[0]) {
+            return true;
+          }
+          const next2 = array.slice(j);
+          const characterWillAnimate = next2.some(([__action, __character]) => action === __action);
+          const hasBlockingActions = next2.some((item2) => options.skip.has(item2));
+          return characterWillAnimate && hasBlockingActions;
+        });
         if (skip)
           continue;
-        processedQueue.push([action, meta]);
+        processedQueue.push(item);
       } else {
-        processedQueue.push([action, meta]);
+        processedQueue.push(item);
       }
     }
     const run = async (match) => {
-      for await (const [action, meta] of processedQueue) {
-        const result = match(action, meta);
+      for await (const [action, ...params] of processedQueue) {
+        const result = match(action, params);
         if (isPromise(result)) {
           await result;
         }
       }
       processedQueue.length = 0;
     };
-    const getKeep = () => {
-      return {
+    return {
+      run,
+      keep: {
         keep,
         characters,
         audio
-      };
-    };
-    return {
-      run,
-      getKeep
+      }
     };
   };
   var getStack = (ctx) => {
@@ -750,17 +767,17 @@ var Novely = (() => {
     output.push(input);
     return output;
   };
-  var unwrap = (c) => {
+  var flattenAllowedContent = (c, state) => {
     if (Array.isArray(c)) {
-      return c.map((item) => unwrap(item)).join("<br>");
+      return c.map((item) => flattenAllowedContent(item, state)).join("<br>");
     }
     if (typeof c === "function") {
-      return unwrap(c());
+      return flattenAllowedContent(c(state), state);
     }
     return c;
   };
   var replace = (str2, obj, pluralization, actions, pr) => {
-    return unwrap(str2).replaceAll(RGX, (x, key, y) => {
+    return str2.replaceAll(RGX, (x, key, y) => {
       x = 0;
       y = obj;
       const [pathstr, plural, action] = split(key.trim(), ["@", "%"]);
@@ -820,7 +837,8 @@ var Novely = (() => {
     askBeforeExit = true,
     preloadAssets = "lazy",
     parallelAssetsDownloadLimit = 15,
-    fetch: request = fetch
+    fetch: request = fetch,
+    saveOnUnload = true
   }) => {
     const languages = Object.keys(translation);
     const limitScript = (0, import_p_limit.default)(1);
@@ -910,46 +928,57 @@ var Novely = (() => {
         };
       }
     });
-    function state(value) {
-      const stack = useStack(MAIN_CONTEXT_KEY);
-      if (!value)
-        return stack.value[1];
-      const prev = stack.value[1];
-      const val = isFunction(value) ? value(prev) : deepmerge(prev, value);
-      stack.value[1] = val;
-    }
-    const getDefaultSave = (state2 = {}) => {
+    const getDefaultSave = (state = {}) => {
       return [
         [
           ["jump", "start"],
           [null, 0]
         ],
-        state2,
+        state,
         [intime(Date.now()), "auto"]
       ];
     };
     const getLanguageWithoutParameters = () => {
-      return getLanguage2(languages, getLanguage);
+      const language = getLanguage2(languages, getLanguage);
+      if (languages.includes(language)) {
+        return language;
+      }
+      if (DEV) {
+        throw new Error(`Attempt to use unsupported language "${language}". Supported languages: ${languages.join(", ")}.`);
+      }
+      throw 0;
     };
     const initialData = {
       saves: [],
       data: klona(defaultData),
       meta: [getLanguageWithoutParameters(), DEFAULT_TYPEWRITER_SPEED, 1, 1, 1]
     };
-    const coreData = {
+    const storageData = store(initialData);
+    const coreData = store({
       dataLoaded: false
+    });
+    const onDataLoadedPromise = ({ cancelled }) => {
+      if (cancelled) {
+        dataLoaded.promise.then(onDataLoadedPromise);
+        return;
+      }
+      coreData.update((data2) => {
+        data2.dataLoaded = true;
+        return data2;
+      });
     };
-    const $ = store(initialData);
-    const $$ = store(coreData);
+    dataLoaded.promise.then(onDataLoadedPromise);
     const onStorageDataChange = (value) => {
-      if ($$.get().dataLoaded)
+      if (coreData.get().dataLoaded)
         storage.set(value);
     };
     const throttledOnStorageDataChange = throttle(onStorageDataChange, throttleTimeout);
     const throttledEmergencyOnStorageDataChange = throttle(() => {
-      onStorageDataChange($.get());
+      if (saveOnUnload === true || saveOnUnload === "prod" && !DEV) {
+        onStorageDataChange(storageData.get());
+      }
     }, 10);
-    $.subscribe(throttledOnStorageDataChange);
+    storageData.subscribe(throttledOnStorageDataChange);
     const getStoredData = async () => {
       let stored = await storage.get();
       for (const migration of migrations) {
@@ -965,9 +994,8 @@ var Novely = (() => {
       if (isEmpty(stored.data)) {
         stored.data = defaultData;
       }
-      $$.update((prev) => (prev.dataLoaded = true, prev));
       dataLoaded.resolve();
-      $.set(stored);
+      storageData.set(stored);
     };
     storageDelay.then(getStoredData);
     const initial = getDefaultSave(klona(defaultState));
@@ -979,13 +1007,13 @@ var Novely = (() => {
     addEventListener("visibilitychange", onVisibilityChange);
     addEventListener("beforeunload", throttledEmergencyOnStorageDataChange);
     const save = (override = false, type = override ? "auto" : "manual") => {
-      if (!$$.get().dataLoaded)
+      if (!coreData.get().dataLoaded)
         return;
       if (!autosaves && type === "auto")
         return;
       const stack = useStack(MAIN_CONTEXT_KEY);
       const current = klona(stack.value);
-      $.update((prev) => {
+      storageData.update((prev) => {
         const isLatest = findLastIndex(prev.saves, (value) => times.has(value[2][0])) === prev.saves.length - 1;
         current[2][0] = intime(Date.now());
         current[2][1] = type;
@@ -1003,29 +1031,29 @@ var Novely = (() => {
       });
     };
     const newGame = () => {
-      if (!$$.get().dataLoaded)
+      if (!coreData.get().dataLoaded)
         return;
       const save2 = getDefaultSave(klona(defaultState));
       if (autosaves) {
-        $.update((prev) => {
+        storageData.update((prev) => {
           return prev.saves.push(save2), prev;
         });
       }
       restore(save2);
     };
     const set = (save2, ctx) => {
-      const stack = useStack(ctx || renderer.getContext(MAIN_CONTEXT_KEY));
+      const stack = useStack(ctx || MAIN_CONTEXT_KEY);
       stack.value = save2;
       return restore(save2);
     };
     let interacted = 0;
     const restore = async (save2) => {
-      if (!$$.get().dataLoaded)
+      if (!coreData.get().dataLoaded)
         return;
-      let latest = save2 || $.get().saves.at(-1);
+      let latest = save2 || storageData.get().saves.at(-1);
       if (!latest) {
         latest = klona(initial);
-        $.update((prev) => {
+        storageData.update((prev) => {
           prev.saves.push(latest);
           return prev;
         });
@@ -1036,19 +1064,22 @@ var Novely = (() => {
       const previous = stack.previous;
       const [path] = stack.value = latest;
       renderer.ui.showScreen("game");
-      const queue = getActionsFromPath(story, path);
-      const processor = createQueueProcessor(queue);
-      const { keep, characters: characters2, audio } = processor.getKeep();
+      const { queue, skip, skipPreserve } = getActionsFromPath(story, path, false);
+      const processor = createQueueProcessor(queue, {
+        skip,
+        skipPreserve
+      });
+      const { keep, characters: characters2, audio } = processor.keep;
       if (previous) {
-        const prevQueue = getActionsFromPath(story, previous[0], true);
-        const currQueue = getActionsFromPath(story, path, true);
-        for (let i = prevQueue.length - 1; i > currQueue.length; i--) {
+        const { queue: prevQueue } = getActionsFromPath(story, previous[0], false);
+        for (let i = prevQueue.length - 1; i > queue.length; i--) {
           const element = prevQueue[i];
-          if (isAction(element)) {
-            const [action2, props] = element;
-            if (action2 === "custom") {
-              context.clearCustom(props[0]);
-            }
+          if (!isAction(element)) {
+            continue;
+          }
+          const [action2, fn] = element;
+          if (action2 === "custom") {
+            context.clearCustom(fn);
           }
         }
       }
@@ -1068,9 +1099,6 @@ var Novely = (() => {
       render(context);
     };
     const refer = (path) => {
-      if (!path) {
-        path = useStack(MAIN_CONTEXT_KEY).value[0];
-      }
       let current = story;
       let precurrent = story;
       const blocks = [];
@@ -1109,7 +1137,7 @@ var Novely = (() => {
       ctx.audio.destroy();
       const [time, type] = current[2];
       if (type === "auto" && interacted <= 1 && times.has(time)) {
-        $.update((prev) => {
+        storageData.update((prev) => {
           prev.saves = prev.saves.filter((save2) => save2 !== current);
           return prev;
         });
@@ -1126,11 +1154,13 @@ var Novely = (() => {
       return translation[lang].internal[key];
     };
     const preview = async ([path, data2], name) => {
-      const queue = getActionsFromPath(story, path);
+      const { queue } = getActionsFromPath(story, path, true);
       const ctx = renderer.getContext(name);
       ctx.meta.restoring = true;
       ctx.meta.preview = true;
-      const processor = createQueueProcessor(queue);
+      const processor = createQueueProcessor(queue, {
+        skip: /* @__PURE__ */ new Set()
+      });
       await processor.run((action2, props) => {
         if (isAudioAction(action2))
           return;
@@ -1147,6 +1177,23 @@ var Novely = (() => {
     const removeContext = (name) => {
       STACK_MAP.delete(name);
     };
+    const getStateAtCtx = (context) => {
+      return useStack(context).value[1];
+    };
+    const getStateFunction = (context) => {
+      const stack = useStack(context);
+      const state = (value) => {
+        const _state = getStateAtCtx(context);
+        if (!value) {
+          return _state;
+        }
+        const prev = _state;
+        const val = isFunction(value) ? value(prev) : deepmerge(prev, value);
+        stack.value[1] = val;
+        return void 0;
+      };
+      return state;
+    };
     const renderer = createRenderer({
       mainContextKey: MAIN_CONTEXT_KEY,
       characters,
@@ -1159,9 +1206,10 @@ var Novely = (() => {
       t,
       preview,
       removeContext,
+      getStateFunction,
       languages,
-      $,
-      $$
+      storageData,
+      coreData
     });
     const useStack = createUseStackFunction(renderer);
     useStack(MAIN_CONTEXT_KEY).push(initial);
@@ -1175,15 +1223,19 @@ var Novely = (() => {
       stack.push(current);
       save(true, "auto");
     };
-    const next = (ctx) => {
-      const stack = useStack(ctx);
-      const path = stack.value[0];
+    const nextPath = (path) => {
       const last = path.at(-1);
       if (last && (isNull(last[0]) || last[0] === "jump") && isNumber(last[1])) {
         last[1]++;
       } else {
         path.push([null, 0]);
       }
+      return path;
+    };
+    const next = (ctx) => {
+      const stack = useStack(ctx);
+      const path = stack.value[0];
+      nextPath(path);
     };
     const matchActionInit = {
       getContext: renderer.getContext,
@@ -1205,7 +1257,7 @@ var Novely = (() => {
       wait({ ctx, push }, [time]) {
         if (ctx.meta.restoring)
           return;
-        setTimeout(push, isFunction(time) ? time() : time);
+        setTimeout(push, isFunction(time) ? time(getStateAtCtx(ctx)) : time);
       },
       showBackground({ ctx, push }, [background]) {
         ctx.background(background);
@@ -1251,7 +1303,7 @@ var Novely = (() => {
         const name = (() => {
           const c = character;
           const cs = characters;
-          const [lang] = $.get().meta;
+          const [lang] = storageData.get().meta;
           if (c && c in cs) {
             const block = cs[c].name;
             if (typeof block === "string") {
@@ -1264,15 +1316,31 @@ var Novely = (() => {
           return c || "";
         })();
         ctx.dialog(
-          unwrap2(content, data2),
-          unwrap2(name, data2),
+          templateReplace(content, data2),
+          templateReplace(name, data2),
           character,
           emotion,
           forward
         );
       },
+      say({ ctx, data: data2 }, [character, content]) {
+        if (DEV && !characters[character]) {
+          throw new Error(`Attempt to call Say action with unknown character "${character}"`);
+        }
+        match("dialog", [character, content], {
+          ctx,
+          data: data2
+        });
+      },
       function({ ctx, push }, [fn]) {
-        const result = fn(ctx.meta.restoring, ctx.meta.goingBack, ctx.meta.preview);
+        const { restoring, goingBack, preview: preview2 } = ctx.meta;
+        const result = fn({
+          lang: storageData.get().meta[0],
+          goingBack,
+          restoring,
+          preview: preview2,
+          state: getStateFunction(ctx)
+        });
         if (!ctx.meta.restoring) {
           result ? result.then(push) : push();
         }
@@ -1284,22 +1352,26 @@ var Novely = (() => {
           choices.unshift(question);
           question = "";
         }
-        const unwrappedChoices = choices.map(([content, action2, visible]) => {
-          if (DEV && action2.length === 0 && (!visible || visible())) {
+        const transformedChoices = choices.map(([content, action2, visible]) => {
+          const shown = !visible || visible({
+            lang: storageData.get().meta[0],
+            state: getStateAtCtx(ctx)
+          });
+          if (DEV && action2.length === 0 && !shown) {
             console.warn(`Choice children should not be empty, either add content there or make item not selectable`);
           }
-          return [unwrap2(content, data2), action2, visible];
+          return [templateReplace(content, data2), shown];
         });
-        if (DEV && unwrappedChoices.length === 0) {
+        if (DEV && transformedChoices.length === 0) {
           throw new Error(`Running choice without variants to choose from, look at how to use Choice action properly [https://novely.pages.dev/guide/actions/choice#usage]`);
         }
-        ctx.choices(unwrap2(question, data2), unwrappedChoices, (selected) => {
+        ctx.choices(templateReplace(question, data2), transformedChoices, (selected) => {
           if (!ctx.meta.preview) {
             enmemory(ctx);
           }
           const stack = useStack(ctx);
           const offset = isWithoutQuestion ? 0 : 1;
-          if (DEV && !unwrappedChoices[selected]) {
+          if (DEV && !transformedChoices[selected]) {
             throw new Error("Choice children is empty, either add content there or make item not selectable");
           }
           stack.value[0].push(["choice", selected + offset], [null, 0]);
@@ -1338,7 +1410,7 @@ var Novely = (() => {
           throw new Error(`Attempt to use Condition action with empty variants object`);
         }
         if (!ctx.meta.restoring) {
-          const val = String(condition());
+          const val = String(condition(getStateAtCtx(ctx)));
           if (DEV && !variants[val]) {
             throw new Error(`Attempt to go to unknown variant "${val}"`);
           }
@@ -1361,7 +1433,7 @@ var Novely = (() => {
       },
       input({ ctx, data: data2, forward }, [question, onInput, setup]) {
         ctx.input(
-          unwrap2(question, data2),
+          templateReplace(question, data2),
           onInput,
           setup || noop,
           forward
@@ -1399,7 +1471,7 @@ var Novely = (() => {
         push();
       },
       text({ ctx, data: data2, forward }, text) {
-        const string = text.map((content) => unwrap2(content, data2)).join(" ");
+        const string = text.map((content) => templateReplace(content, data2)).join(" ");
         if (DEV && string.length === 0) {
           throw new Error(`Action Text was called with empty string or array`);
         }
@@ -1491,52 +1563,106 @@ var Novely = (() => {
     const interactivity = (value = false) => {
       interacted = value ? interacted + 1 : 0;
     };
-    const unwrap2 = (content, values) => {
+    const templateReplace = (content, values) => {
       const {
         data: data2,
         meta: [lang]
-      } = $.get();
-      const obj = values ? values : data2;
-      const cnt = isFunction(content) ? content() : typeof content === "string" ? content : content[lang];
-      const str2 = isFunction(cnt) ? cnt() : cnt;
-      const trans = translation[lang];
-      if (trans.actions || trans.plural) {
-        return replace(str2, obj, trans.plural, trans.actions, new Intl.PluralRules(trans.tag || lang));
-      }
-      return replace(str2, obj);
+      } = storageData.get();
+      const obj = values || data2;
+      const cnt = isFunction(content) ? content(obj) : typeof content === "string" ? content : content[lang];
+      const str2 = flattenAllowedContent(
+        isFunction(cnt) ? cnt(obj) : cnt,
+        obj
+      );
+      const t2 = translation[lang];
+      const pluralRules = (t2.plural || t2.actions) && new Intl.PluralRules(t2.tag || lang);
+      return replace(
+        str2,
+        obj,
+        t2.plural,
+        t2.actions,
+        pluralRules
+      );
     };
-    function data(value) {
+    const data = (value) => {
+      const _data = storageData.get().data;
       if (!value)
-        return $.get().data;
-      const prev = $.get().data;
-      const val = isFunction(value) ? value(prev) : deepmerge(prev, value);
-      $.update((prev2) => {
-        prev2.data = val;
-        return prev2;
+        return _data;
+      const val = isFunction(value) ? value(_data) : deepmerge(_data, value);
+      storageData.update((prev) => {
+        prev.data = val;
+        return prev;
       });
-    }
+      return void 0;
+    };
     return {
       /**
        * Function to set game script
+       *
+       * @example
+       * ```ts
+       * engine.script({
+       *   start: [
+       *     action.function(() => {})
+       *   ]
+       * })
+       * ```
        */
       script,
       /**
-       * Function to get actions
+       * Get actions
+       *
+       * @example
+       * ```ts
+       * engine.script({
+       *   start: [
+       *     action.function(() => {})
+       *   ]
+       * })
+       * ```
        */
       action,
       /**
-       * State that belongs to games
+       * @deprecated Will be removed BUT replaced with state passed into actions as a parameter
        */
-      state,
+      state: getStateFunction(MAIN_CONTEXT_KEY),
       /**
-       * Unlike `state`, stored at global scope instead and shared between games
+       * Store data between games
+       *
+       * @example
+       * ```ts
+       * engine.script({
+       *   start: [
+       *     action.function(() => {
+       *       // Paid content should be purchased only once
+       *       // So it will be available in any save
+       *       data({ paid_content_purchased: true })
+       *     })
+       *   ]
+       * })
+       * ```
        */
       data,
       /**
-       * Unwraps translatable content to a string value
+       * @deprecated Renamed into `templateReplace`
        */
       unwrap(content) {
-        return unwrap2(content, $.get().data);
+        return templateReplace(content);
+      },
+      /**
+       * Replaces content inside {{braces}} with using global data
+       * @example
+       * ```ts
+       * data({ name: 'Alexei' })
+       *
+       * templateReplace('{{name}} is our hero')
+       * templateReplace({
+       *  en: (data) => 'Hello, ' + data.name
+       * })
+       * ```
+       */
+      templateReplace(content) {
+        return templateReplace(content);
       },
       /**
        * Cancel data loading, hide UI, ignore page change events