@novely/core 0.15.1 → 0.16.0-alpha.0

package/dist/index.d.ts

@@ -381,9 +381,9 @@ interface NovelyInit<Languages extends string, Characters extends Record<string,
 }
 declare const novely: <Languages extends string, Characters extends Record<string, Character<Languages>>, StateScheme extends State, DataScheme extends Data>({ characters, storage, storageDelay, renderer: createRenderer, initialScreen, translation, languages, state: defaultState, data: defaultData, autosaves, migrations, throttleTimeout, getLanguage, overrideLanguage, askBeforeExit, preloadAssets, }: NovelyInit<Languages, Characters, StateScheme, DataScheme>) => {
     /**
-     * Function to set story
+     * Function to set game script
      */
-    withStory: (story: Story) => Promise<void>;
+    script: (part: Story) => Promise<void>;
     /**
      * Function to get actions
      */

package/dist/index.global.js

@@ -1,9 +1,14 @@
 "use strict";
 var Novely = (() => {
+  var __create = Object.create;
   var __defProp = Object.defineProperty;
   var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
   var __export = (target, all) => {
     for (var name in all)
       __defProp(target, name, { get: all[name], enumerable: true });
@@ -16,8 +21,134 @@ var Novely = (() => {
     }
     return to;
   };
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+  // ../../node_modules/.pnpm/yocto-queue@0.1.0/node_modules/yocto-queue/index.js
+  var require_yocto_queue = __commonJS({
+    "../../node_modules/.pnpm/yocto-queue@0.1.0/node_modules/yocto-queue/index.js"(exports, module) {
+      "use strict";
+      var Node = class {
+        /// value;
+        /// next;
+        constructor(value) {
+          this.value = value;
+          this.next = void 0;
+        }
+      };
+      var Queue = class {
+        // TODO: Use private class fields when targeting Node.js 12.
+        // #_head;
+        // #_tail;
+        // #_size;
+        constructor() {
+          this.clear();
+        }
+        enqueue(value) {
+          const node = new Node(value);
+          if (this._head) {
+            this._tail.next = node;
+            this._tail = node;
+          } else {
+            this._head = node;
+            this._tail = node;
+          }
+          this._size++;
+        }
+        dequeue() {
+          const current = this._head;
+          if (!current) {
+            return;
+          }
+          this._head = this._head.next;
+          this._size--;
+          return current.value;
+        }
+        clear() {
+          this._head = void 0;
+          this._tail = void 0;
+          this._size = 0;
+        }
+        get size() {
+          return this._size;
+        }
+        *[Symbol.iterator]() {
+          let current = this._head;
+          while (current) {
+            yield current.value;
+            current = current.next;
+          }
+        }
+      };
+      module.exports = Queue;
+    }
+  });
+
+  // ../../node_modules/.pnpm/p-limit@3.1.0/node_modules/p-limit/index.js
+  var require_p_limit = __commonJS({
+    "../../node_modules/.pnpm/p-limit@3.1.0/node_modules/p-limit/index.js"(exports, module) {
+      "use strict";
+      var Queue = require_yocto_queue();
+      var pLimit2 = (concurrency) => {
+        if (!((Number.isInteger(concurrency) || concurrency === Infinity) && concurrency > 0)) {
+          throw new TypeError("Expected `concurrency` to be a number from 1 and up");
+        }
+        const queue = new Queue();
+        let activeCount = 0;
+        const next = () => {
+          activeCount--;
+          if (queue.size > 0) {
+            queue.dequeue()();
+          }
+        };
+        const run = async (fn, resolve, ...args) => {
+          activeCount++;
+          const result = (async () => fn(...args))();
+          resolve(result);
+          try {
+            await result;
+          } catch {
+          }
+          next();
+        };
+        const enqueue = (fn, resolve, ...args) => {
+          queue.enqueue(run.bind(null, fn, resolve, ...args));
+          (async () => {
+            await Promise.resolve();
+            if (activeCount < concurrency && queue.size > 0) {
+              queue.dequeue()();
+            }
+          })();
+        };
+        const generator = (fn, ...args) => new Promise((resolve) => {
+          enqueue(fn, resolve, ...args);
+        });
+        Object.defineProperties(generator, {
+          activeCount: {
+            get: () => activeCount
+          },
+          pendingCount: {
+            get: () => queue.size
+          },
+          clearQueue: {
+            value: () => {
+              queue.clear();
+            }
+          }
+        });
+        return generator;
+      };
+      module.exports = pLimit2;
+    }
+  });
+
   // src/index.ts
   var src_exports = {};
   __export(src_exports, {
@@ -353,6 +484,9 @@ var Novely = (() => {
     };
   };
 
+  // src/novely.ts
+  var import_p_limit = __toESM(require_p_limit(), 1);
+
   // ../../node_modules/.pnpm/esm-env@1.0.0/node_modules/esm-env/prod-ssr.js
   var DEV = false;
 
@@ -375,28 +509,41 @@ var Novely = (() => {
     askBeforeExit = true,
     preloadAssets = "lazy"
   }) => {
+    const limitScript = (0, import_p_limit.default)(1);
     const story = {};
     const times = /* @__PURE__ */ new Set();
     const ASSETS_TO_PRELOAD = /* @__PURE__ */ new Set();
     const assetsLoaded = createControlledPromise();
+    const dataLoaded = createControlledPromise();
+    let scriptCalled = false;
     defaultData ||= {};
     defaultState ||= {};
     const intime = (value) => {
       return times.add(value), value;
     };
-    const script = (part) => {
+    const scriptBase = async (part) => {
       Object.assign(story, flattenStory(part));
-    };
-    const withStory = async (story2) => {
-      script(story2);
       if (preloadAssets === "blocking" && ASSETS_TO_PRELOAD.size > 0) {
         renderer.ui.showScreen("loading");
         await renderer.misc.preloadImagesBlocking(ASSETS_TO_PRELOAD);
       }
+      const screen = renderer.ui.getScreen();
+      const nextScreen = scriptCalled ? screen : initialScreen;
       ASSETS_TO_PRELOAD.clear();
       assetsLoaded.resolve();
-      if (initialScreen !== "game")
-        renderer.ui.showScreen(initialScreen);
+      if (nextScreen === "game") {
+        await assetsLoaded.promise;
+        await dataLoaded.promise;
+        if (!scriptCalled) {
+          restore();
+        }
+      } else {
+        renderer.ui.showScreen(nextScreen);
+      }
+      scriptCalled = true;
+    };
+    const script = (part) => {
+      return limitScript(() => scriptBase(part));
     };
     const action = new Proxy({}, {
       get(_, prop) {
@@ -494,11 +641,8 @@ var Novely = (() => {
         stored.data = defaultData;
       }
       $$.update((prev) => (prev.dataLoaded = true, prev));
+      dataLoaded.resolve();
       $.update(() => stored);
-      if (initialScreen === "game") {
-        await assetsLoaded.promise;
-        restore();
-      }
     };
     storageDelay.then(getStoredData);
     const initial = getDefaultSave(klona(defaultState));
@@ -880,9 +1024,18 @@ var Novely = (() => {
         push();
       },
       animateCharacter([character, timeout, ...classes]) {
+        if (DEV && classes.length === 0) {
+          throw new Error("Attempt to use AnimateCharacter without classes. Classes should be provided [https://novely.pages.dev/guide/actions/animateCharacter.html]");
+        }
+        if (DEV && (timeout <= 0 || !Number.isFinite(timeout) || Number.isNaN(timeout))) {
+          throw new Error("Attempt to use AnimateCharacter with unacceptable timeout. It should be finite and greater than zero");
+        }
         const handler = (get) => {
           const { clear } = get("@@internal-animate-character", false);
           const char = renderer.store.characters[character];
+          if (DEV && !char) {
+            throw new Error(`Attempt to call AnimateCharacter with character "${character}" which is not currently exists. Maybe AnimateCharacter was called before ShowCharacter?`);
+          }
           if (!char)
             return;
           const target = char.canvas;
@@ -1026,9 +1179,9 @@ var Novely = (() => {
     }
     return {
       /**
-       * Function to set story
+       * Function to set game script
        */
-      withStory,
+      script,
       /**
        * Function to get actions
        */