@drincs/pixi-vn 0.6.4 → 0.6.6

package/dist/classes/index.mjs

@@ -1,4 +1,4 @@
-import 'deep-diff';
+import { diff } from 'deep-diff';
 import sha1 from 'crypto-js/sha1';
 import { Sprite, Container, Application, Text, Assets, Texture } from 'pixi.js';
 
@@ -64,23 +64,26 @@ var CanvasEvent = class {
     throw new Error("[Pixi'VN] The method CanvasEvent.fn() must be overridden");
   }
 };
+function getStepSha1(step) {
+  let sha1String = sha1(step.toString().toLocaleLowerCase());
+  return sha1String.toString();
+}
 function checkIfStepsIsEqual(step1, step2) {
   return step1 === step2;
 }
 
-// src/classes/Label.ts
-var Label = class {
+// src/classes/LabelAbstract.ts
+var LabelAbstract = class {
   /**
    * @param id is the id of the label
-   * @param steps is the list of steps that the label will perform
-   * @param onStepRun is a function that will be executed before any step is executed, is useful for example to make sure all images used have been cached
-   * @param choiseIndex is the index of the choice that the label will perform
+   * @param props is the properties of the label
    */
-  constructor(id, steps, onStepRun, choiseIndex) {
+  constructor(id, props) {
     this._id = id;
-    this._steps = steps;
-    this._onStepRun = onStepRun;
-    this._choiseIndex = choiseIndex;
+    this._onStepStart = props == null ? void 0 : props.onStepStart;
+    this._onLoadStep = props == null ? void 0 : props.onLoadStep;
+    this._onStepEnd = props == null ? void 0 : props.onStepEnd;
+    this._choiseIndex = props == null ? void 0 : props.choiseIndex;
   }
   /**
    * Get the id of the label. This variable is used in the system to get the label by id, {@link getLabelById}
@@ -88,17 +91,6 @@ var Label = class {
   get id() {
     return this._id;
   }
-  /**
-   * Get the steps of the label.
-   * This class should be extended and the steps method should be overridden.
-   * Every time you update this list will also be updated when the other game versions load.
-   */
-  get steps() {
-    if (typeof this._steps === "function") {
-      return this._steps();
-    }
-    return this._steps;
-  }
   /**
    * Get the corresponding steps number
    * @param externalSteps
@@ -117,28 +109,66 @@ var Label = class {
     return res;
   }
   /**
-   * Get the function that will be executed before any step is executed, is useful for example to make sure all images used have been cached
+   * Is a function that will be executed in {@link Label#onStepStart} and when the user goes back to it or when the user laods a save file.
+   * @returns Promise<void> or void
+   */
+  get onStepStart() {
+    return (stepIndex, label) => __async(this, null, function* () {
+      if (this._onLoadStep) {
+        yield this._onLoadStep(stepIndex, label);
+      }
+      if (this._onStepStart) {
+        return yield this._onStepStart(stepIndex, label);
+      }
+    });
+  }
+  /**
+   * Get the function that will be executed a old step is reloaded. A step is reloaded when the user goes back to it or when the user laods a save file.
    * @returns Promise<void> or void
-   * @example
-   * ```typescript
-   * newLabel("id", [], () => {
-   *     Assets.load('path/to/image1.png')
-   *     Assets.load('path/to/image2.png')
-   * })
-   * ```
    */
-  get onStepRun() {
-    return this._onStepRun;
+  get onLoadStep() {
+    return this._onLoadStep;
+  }
+  /**
+   * Is a function that will be executed when the step ends.
+   * @returns Promise<void> or void
+   */
+  get onStepEnd() {
+    return this._onStepEnd;
   }
   get choiseIndex() {
     return this._choiseIndex;
   }
 };
 
+// src/classes/Label.ts
+var Label = class extends LabelAbstract {
+  /**
+   * @param id is the id of the label
+   * @param steps is the list of steps that the label will perform
+   * @param props is the properties of the label
+   */
+  constructor(id, steps, props) {
+    super(id, props);
+    this._steps = steps;
+  }
+  /**
+   * Get the steps of the label.
+   */
+  get steps() {
+    if (typeof this._steps === "function") {
+      return this._steps();
+    }
+    return this._steps;
+  }
+};
+
 // src/classes/CloseLabel.ts
 var CLOSE_LABEL_ID = "__close-label-id__";
 function newCloseLabel(choiseIndex) {
-  return new Label(CLOSE_LABEL_ID, [], void 0, choiseIndex);
+  return new Label(CLOSE_LABEL_ID, [], {
+    choiseIndex
+  });
 }
 
 // src/decorators/LabelDecorator.ts
@@ -228,8 +258,6 @@ function getMemoryContainer(element) {
   };
 }
 function setMemoryContainer(element, memory) {
-  memory.width && (element.width = memory.width);
-  memory.height && (element.height = memory.height);
   memory.isRenderGroup && (element.isRenderGroup = memory.isRenderGroup);
   memory.blendMode && (element.blendMode = memory.blendMode);
   memory.tint && (element.tint = memory.tint);
@@ -262,6 +290,8 @@ function setMemoryContainer(element, memory) {
   memory.interactive && (element.interactive = memory.interactive);
   memory.interactiveChildren && (element.interactiveChildren = memory.interactiveChildren);
   memory.hitArea && (element.hitArea = memory.hitArea);
+  memory.width && (element.width = memory.width);
+  memory.height && (element.height = memory.height);
 }
 function getTexture(imageUrl) {
   return __async(this, null, function* () {
@@ -670,29 +700,57 @@ var ChoiceMenuOption = class {
   /**
    * @param text Text to be displayed in the menu
    * @param label Label to be opened when the option is selected or the id of the label
+   * @param props Properties to be passed to the label and olther parameters that you can use when get all the choice menu options. It be converted to a JSON string, so it cannot contain functions or classes.
    * @param type Type of the label to be opened. @default "call"
-   * @param props Properties to be passed to the label, when the label is called. it cannot contain functions or classes. @default {}
    */
-  constructor(text, label, type = "call", props) {
+  constructor(text, label, props, type = "call") {
     /**
-     * Properties to be passed to the label
+     * Properties to be passed to the label and olther parameters that you can use when get all the choice menu options.
+     * @example
+     * ```tsx
+     * setChoiceMenuOptions([
+     *     new ChoiceMenuOption("Hello", helloLabel, { disabled: true }),
+     * ])
+     * return <List>
+     *     {getChoiceMenuOptions()?.map((item, index) => {
+     *         return (
+     *             <ChoiceButton
+     *                 disabled={item.props.disabled}
+     *                 onClick={() => {
+     *                     afterSelectChoice(item)
+     *                 }}
+     *             >
+     *                 {item.text}
+     *             </ChoiceButton>
+     *         )
+     *     })}
+     * </List>
+     * ```
      */
     this.props = {};
-    if (typeof label === "string") {
-      let tLabel = getLabelById(label);
-      if (!tLabel) {
-        throw new Error(`[Pixi'VN] Label ${label} not found`);
-      } else {
-        label = tLabel;
-      }
-    }
     this.text = text;
-    this.label = label;
+    this._label = label;
     this.type = type;
     if (props) {
       this.props = props;
     }
   }
+  /**
+   * Label to be opened when the option is selected
+   */
+  get label() {
+    let label = this._label;
+    if (typeof label === "string") {
+      let res = getLabelById(label);
+      if (res) {
+        label = res;
+      } else {
+        console.error(`Label ${label} not found, so it will be closed`);
+        label = newCloseLabel();
+      }
+    }
+    return label;
+  }
 };
 var ChoiceMenuOptionClose = class {
   /**
@@ -709,7 +767,27 @@ var ChoiceMenuOptionClose = class {
      */
     this.type = Close;
     /**
-     * Properties to be passed to the label
+     * Properties to be passed to the label and olther parameters that you can use when get all the choice menu options.
+     * @example
+     * ```tsx
+     * setChoiceMenuOptions([
+     *     new ChoiceMenuOption("Hello", helloLabel, { disabled: true }),
+     * ])
+     * return <List>
+     *     {getChoiceMenuOptions()?.map((item, index) => {
+     *         return (
+     *             <ChoiceButton
+     *                 disabled={item.props.disabled}
+     *                 onClick={() => {
+     *                     afterSelectChoice(item)
+     *                 }}
+     *             >
+     *                 {item.text}
+     *             </ChoiceButton>
+     *         )
+     *     })}
+     * </List>
+     * ```
      */
     this.props = {};
     this.text = text;
@@ -717,6 +795,81 @@ var ChoiceMenuOptionClose = class {
   }
 };
 
+// src/functions/DialogueUtility.ts
+function setDialogue(props) {
+  let text = "";
+  let character = void 0;
+  let dialogue;
+  if (typeof props === "string") {
+    text = props;
+    dialogue = new DialogueBaseModel(text, character);
+  } else if (!(props instanceof DialogueBaseModel)) {
+    text = props.text;
+    if (props.character) {
+      if (typeof props.character === "string") {
+        character = props.character;
+      } else {
+        character = props.character.id;
+      }
+    }
+    dialogue = new DialogueBaseModel(text, character);
+  } else {
+    dialogue = props;
+  }
+  GameStorageManager.setVariable(GameStorageManager.keysSystem.CURRENT_DIALOGUE_MEMORY_KEY, dialogue);
+  GameStorageManager.setVariable(GameStorageManager.keysSystem.LAST_DIALOGUE_ADDED_IN_STEP_MEMORY_KEY, GameStepManager.lastStepIndex);
+}
+function getDialogue() {
+  return GameStorageManager.getVariable(GameStorageManager.keysSystem.CURRENT_DIALOGUE_MEMORY_KEY);
+}
+function clearDialogue() {
+  GameStorageManager.setVariable(GameStorageManager.keysSystem.CURRENT_DIALOGUE_MEMORY_KEY, void 0);
+}
+function setChoiceMenuOptions(options) {
+  let value = options.map((option) => {
+    if (option instanceof ChoiceMenuOptionClose) {
+      return {
+        text: option.text,
+        type: Close,
+        closeCurrentLabel: option.closeCurrentLabel
+      };
+    }
+    return __spreadProps(__spreadValues({}, option), {
+      label: option.label.id
+    });
+  });
+  GameStorageManager.setVariable(GameStorageManager.keysSystem.CURRENT_MENU_OPTIONS_MEMORY_KEY, value);
+  GameStorageManager.setVariable(GameStorageManager.keysSystem.LAST_MENU_OPTIONS_ADDED_IN_STEP_MEMORY_KEY, GameStepManager.lastStepIndex);
+}
+function getChoiceMenuOptions() {
+  let d = GameStorageManager.getVariable(GameStorageManager.keysSystem.CURRENT_MENU_OPTIONS_MEMORY_KEY);
+  if (d) {
+    let options = [];
+    d.forEach((option, index) => {
+      if (option.type === Close) {
+        let itemLabel = newCloseLabel(index);
+        let choice = new ChoiceMenuOptionClose(option.text, option.closeCurrentLabel);
+        choice.label = itemLabel;
+        options.push(choice);
+        return;
+      }
+      let label = getLabelById(option.label);
+      if (label) {
+        let itemLabel = new Label(label.id, label.steps, {
+          onStepStart: label.onStepStart,
+          choiseIndex: index
+        });
+        options.push(new ChoiceMenuOption(option.text, itemLabel, option.props, option.type));
+      }
+    });
+    return options;
+  }
+  return void 0;
+}
+function clearChoiceMenuOptions() {
+  GameStorageManager.setVariable(GameStorageManager.keysSystem.CURRENT_MENU_OPTIONS_MEMORY_KEY, void 0);
+}
+
 // src/classes/ticker/TickerBase.ts
 var TickerBase = class {
   /**
@@ -797,8 +950,9 @@ FadeAlphaTicker = __decorateClass([
 ], FadeAlphaTicker);
 
 // src/functions/TickerUtility.ts
-function updateTickerProgression(args, propertyName, progression) {
-  if (args[propertyName] === void 0 || !progression || args[propertyName] === progression.limit) {
+function updateTickerProgression(args, propertyName, progression, valueConvert) {
+  let limit = valueConvert && progression.limit ? valueConvert(progression.limit) : progression.limit;
+  if (args[propertyName] === void 0 || !progression || args[propertyName] === limit) {
     return;
   }
   if (typeof args[propertyName] === "number") {
@@ -817,22 +971,25 @@ function updateTickerProgression(args, propertyName, progression) {
     }
   }
 }
-function getLinearProgression(number, progression) {
-  if (progression.limit !== void 0) {
-    if (number > progression.limit && progression.amt > 0) {
-      return progression.limit;
-    } else if (number < progression.limit && progression.amt < 0) {
-      return progression.limit;
+function getLinearProgression(number, progression, valueConvert) {
+  let limit = valueConvert && progression.limit ? valueConvert(progression.limit) : progression.limit;
+  let amt = valueConvert ? valueConvert(progression.amt) : progression.amt;
+  if (limit !== void 0) {
+    if (number > limit && amt > 0) {
+      return limit;
+    } else if (number < limit && amt < 0) {
+      return limit;
     }
   }
-  return number + progression.amt / 60;
+  return number + amt;
 }
-function getExponentialProgression(number, progression) {
-  if (progression.limit !== void 0) {
-    if (number > progression.limit && progression.percentage > 0) {
-      return progression.limit;
-    } else if (number < progression.limit && progression.percentage < 0) {
-      return progression.limit;
+function getExponentialProgression(number, progression, valueConvert) {
+  let limit = valueConvert && progression.limit ? valueConvert(progression.limit) : progression.limit;
+  if (limit !== void 0) {
+    if (number > limit && progression.percentage > 0) {
+      return limit;
+    } else if (number < limit && progression.percentage < 0) {
+      return limit;
     }
   }
   return number + number * progression.percentage;
@@ -845,15 +1002,13 @@ var MoveTicker = class extends TickerBase {
     let ySpeed = 1;
     if (args.speed) {
       if (typeof args.speed === "number") {
-        xSpeed = args.speed;
-        ySpeed = args.speed;
+        xSpeed = this.speedConvert(args.speed);
+        ySpeed = this.speedConvert(args.speed);
       } else {
-        xSpeed = args.speed.x;
-        ySpeed = args.speed.y;
+        xSpeed = this.speedConvert(args.speed.x);
+        ySpeed = this.speedConvert(args.speed.y);
       }
     }
-    xSpeed /= 60;
-    ySpeed /= 60;
     let destination = args.destination;
     let tagToRemoveAfter2 = args.tagToRemoveAfter || [];
     if (typeof tagToRemoveAfter2 === "string") {
@@ -893,7 +1048,10 @@ var MoveTicker = class extends TickerBase {
       }
     });
     if (args.speedProgression)
-      updateTickerProgression(args, "speed", args.speedProgression);
+      updateTickerProgression(args, "speed", args.speedProgression, this.speedConvert);
+  }
+  speedConvert(speed) {
+    return speed / 6;
   }
 };
 MoveTicker = __decorateClass([
@@ -901,7 +1059,7 @@ MoveTicker = __decorateClass([
 ], MoveTicker);
 var RotateTicker = class extends TickerBase {
   fn(ticker, args, tags, tickerId) {
-    let speed = (args.speed === void 0 ? 1 : args.speed) / 60;
+    let speed = this.speedConvert(args.speed === void 0 ? 1 : args.speed);
     let clockwise = args.clockwise === void 0 ? true : args.clockwise;
     let tagToRemoveAfter2 = args.tagToRemoveAfter || [];
     if (typeof tagToRemoveAfter2 === "string") {
@@ -929,7 +1087,10 @@ var RotateTicker = class extends TickerBase {
       }
     });
     if (args.speedProgression)
-      updateTickerProgression(args, "speed", args.speedProgression);
+      updateTickerProgression(args, "speed", args.speedProgression, this.speedConvert);
+  }
+  speedConvert(speed) {
+    return speed / 60;
   }
 };
 RotateTicker = __decorateClass([
@@ -941,15 +1102,13 @@ var ZoomTicker = class extends TickerBase {
     let ySpeed = 0.1;
     if (args.speed) {
       if (typeof args.speed === "number") {
-        xSpeed = args.speed;
-        ySpeed = args.speed;
+        xSpeed = this.speedConvert(args.speed);
+        ySpeed = this.speedConvert(args.speed);
       } else {
-        xSpeed = args.speed.x;
-        ySpeed = args.speed.y;
+        xSpeed = this.speedConvert(args.speed.x);
+        ySpeed = this.speedConvert(args.speed.y);
       }
     }
-    xSpeed /= 60;
-    ySpeed /= 60;
     let tagToRemoveAfter2 = args.tagToRemoveAfter || [];
     if (typeof tagToRemoveAfter2 === "string") {
       tagToRemoveAfter2 = [tagToRemoveAfter2];
@@ -1016,7 +1175,10 @@ var ZoomTicker = class extends TickerBase {
       }
     });
     if (args.speedProgression)
-      updateTickerProgression(args, "speed", args.speedProgression);
+      updateTickerProgression(args, "speed", args.speedProgression, this.speedConvert);
+  }
+  speedConvert(speed) {
+    return speed / 60;
   }
   onEndOfTicker(tag, tickerId, _element, tagToRemoveAfter2) {
     GameWindowManager.onEndOfTicker(tag, this, tagToRemoveAfter2, tickerId);
@@ -1040,6 +1202,47 @@ function createExportableElement(element) {
   }
 }
 
+// src/functions/DiffUtility.ts
+function restoreDeepDiffChanges(data, differences) {
+  let result = createExportableElement(data);
+  differences.forEach((diff2) => {
+    let dataToEdit = result;
+    if (diff2.path && diff2.path.length > 0) {
+      diff2.path.forEach((path, index) => {
+        if (diff2.path && index === diff2.path.length - 1) {
+          if (diff2.kind === "E" || diff2.kind === "D") {
+            dataToEdit[path] = diff2.lhs;
+          } else if (diff2.kind === "N") {
+            if (Number.isInteger(path)) {
+              if (Array.isArray(dataToEdit)) {
+                dataToEdit.splice(path, 1);
+              }
+            } else if (typeof path === "string") {
+              delete dataToEdit[path];
+            }
+          } else if (diff2.kind === "A") {
+            let index2 = diff2.index;
+            if (diff2.item.kind === "N") {
+              dataToEdit[path].splice(index2, 1);
+            } else if (diff2.item.kind === "E" || diff2.item.kind === "D") {
+              dataToEdit[path][index2] = diff2.item.lhs;
+            } else if (diff2.item.kind === "A") {
+              console.warn("[Pixi'VN] Nested array found, skipping diff", diff2);
+            } else {
+              console.warn("[Pixi'VN] No array found, skipping diff", diff2);
+            }
+          }
+        } else {
+          dataToEdit = dataToEdit[path];
+        }
+      });
+    } else {
+      console.warn("[Pixi'VN] No path found, skipping diff", diff2);
+    }
+  });
+  return result;
+}
+
 // src/managers/StorageManager.ts
 var _GameStorageManager = class _GameStorageManager {
   constructor() {
@@ -1861,6 +2064,621 @@ _GameWindowManager._currentTickersSteps = {};
 _GameWindowManager._currentTickersTimeouts = {};
 var GameWindowManager = _GameWindowManager;
 
+// src/managers/StepManager.ts
+var _GameStepManager = class _GameStepManager {
+  constructor() {
+  }
+  static get stepsHistory() {
+    return _GameStepManager._stepsHistory;
+  }
+  /**
+   * lastStepIndex is the last step index that occurred during the progression of the steps. **Not is the length of the stepsHistory - 1.**
+   */
+  static get lastStepIndex() {
+    return _GameStepManager._lastStepIndex;
+  }
+  /**
+   * Increase the last step index that occurred during the progression of the steps.
+   */
+  static increaseLastStepIndex() {
+    _GameStepManager._lastStepIndex++;
+  }
+  static get openedLabels() {
+    return _GameStepManager._openedLabels;
+  }
+  /**
+   * currentLabelId is the current label id that occurred during the progression of the steps.
+   */
+  static get currentLabelId() {
+    if (_GameStepManager._openedLabels.length > 0) {
+      let item = _GameStepManager._openedLabels[_GameStepManager._openedLabels.length - 1];
+      return item.label;
+    }
+    return void 0;
+  }
+  /**
+   * currentLabel is the current label that occurred during the progression of the steps.
+   */
+  static get currentLabel() {
+    if (_GameStepManager.currentLabelId) {
+      return getLabelById(_GameStepManager.currentLabelId);
+    }
+  }
+  static get currentLabelStepIndex() {
+    if (_GameStepManager._openedLabels.length > 0) {
+      let item = _GameStepManager._openedLabels[_GameStepManager._openedLabels.length - 1];
+      return item.currentStepIndex;
+    }
+    return null;
+  }
+  /**
+   * lastHistoryStep is the last history step that occurred during the progression of the steps.
+   */
+  static get lastHistoryStep() {
+    if (_GameStepManager._stepsHistory.length > 0) {
+      return _GameStepManager._stepsHistory[_GameStepManager._stepsHistory.length - 1];
+    }
+    return null;
+  }
+  static get originalStepData() {
+    if (!_GameStepManager._originalStepData) {
+      return {
+        path: "",
+        storage: {},
+        canvas: {
+          childrenTagsOrder: [],
+          currentElements: {},
+          currentTickers: {},
+          currentTickersSteps: {}
+        },
+        labelIndex: -1,
+        openedLabels: []
+      };
+    }
+    return createExportableElement(_GameStepManager._originalStepData);
+  }
+  static set originalStepData(value) {
+    _GameStepManager._originalStepData = createExportableElement(value);
+  }
+  static get currentStepData() {
+    let currentStepData = {
+      path: window.location.pathname,
+      storage: GameStorageManager.export(),
+      canvas: GameWindowManager.export(),
+      labelIndex: _GameStepManager.currentLabelStepIndex || 0,
+      openedLabels: createExportableElement(_GameStepManager._openedLabels)
+    };
+    return currentStepData;
+  }
+  /* Edit History Methods */
+  /**
+   * Add a label to the history.
+   * @param label The label to add to the history.
+   */
+  static addStepHistory(step, choiseMade) {
+    let stepHistory = getStepSha1(step);
+    let currentStepData = _GameStepManager.currentStepData;
+    if (_GameStepManager.originalStepData) {
+      if (_GameStepManager.originalStepData.openedLabels.length === currentStepData.openedLabels.length) {
+        try {
+          let lastStepDataOpenedLabelsString = JSON.stringify(_GameStepManager.originalStepData.openedLabels);
+          let historyStepOpenedLabelsString = JSON.stringify(currentStepData.openedLabels);
+          if (lastStepDataOpenedLabelsString === historyStepOpenedLabelsString && _GameStepManager.originalStepData.path === currentStepData.path && _GameStepManager.originalStepData.labelIndex === currentStepData.labelIndex) {
+            return;
+          }
+        } catch (e) {
+          console.error("[Pixi'VN] Error comparing openedLabels", e);
+        }
+      }
+    }
+    let data = diff(_GameStepManager.originalStepData, currentStepData);
+    if (data) {
+      let dialoge = void 0;
+      let requiredChoices = void 0;
+      if (GameStorageManager.getVariable(GameStorageManager.keysSystem.LAST_DIALOGUE_ADDED_IN_STEP_MEMORY_KEY) === _GameStepManager.lastStepIndex) {
+        dialoge = getDialogue();
+      }
+      if (GameStorageManager.getVariable(GameStorageManager.keysSystem.LAST_MENU_OPTIONS_ADDED_IN_STEP_MEMORY_KEY) === _GameStepManager.lastStepIndex) {
+        requiredChoices = GameStorageManager.getVariable(GameStorageManager.keysSystem.CURRENT_MENU_OPTIONS_MEMORY_KEY);
+      }
+      _GameStepManager._stepsHistory.push({
+        diff: data,
+        currentLabel: _GameStepManager.currentLabelId,
+        dialoge,
+        choices: requiredChoices,
+        stepSha1: stepHistory,
+        index: _GameStepManager.lastStepIndex,
+        choiceIndexMade: choiseMade
+      });
+      _GameStepManager.originalStepData = currentStepData;
+    }
+    _GameStepManager.increaseLastStepIndex();
+  }
+  /**
+   * Add a label to the history.
+   * @param label The label to add to the history.
+   */
+  static pushNewLabel(label) {
+    let currentLabel = getLabelById(label);
+    if (!currentLabel) {
+      throw new Error(`[Pixi'VN] Label ${label} not found`);
+    }
+    _GameStepManager._openedLabels.push({
+      label,
+      currentStepIndex: 0
+    });
+  }
+  /**
+   * Close the current label and add it to the history.
+   * @returns 
+   */
+  static closeCurrentLabel() {
+    if (!_GameStepManager.currentLabelId) {
+      console.warn("[Pixi'VN] No label to close");
+      return;
+    }
+    if (!_GameStepManager.currentLabel) {
+      console.error("[Pixi'VN] currentLabel not found");
+      return;
+    }
+    _GameStepManager._openedLabels.pop();
+  }
+  /**
+   * Close all labels and add them to the history. **Attention: This method can cause an unhandled game ending.**
+   */
+  static closeAllLabels() {
+    while (_GameStepManager._openedLabels.length > 0) {
+      _GameStepManager.closeCurrentLabel();
+    }
+  }
+  /**
+   * Increase the current step index of the current label.
+   */
+  static increaseCurrentStepIndex() {
+    let item = _GameStepManager._openedLabels[_GameStepManager._openedLabels.length - 1];
+    _GameStepManager._openedLabels[_GameStepManager._openedLabels.length - 1] = __spreadProps(__spreadValues({}, item), {
+      currentStepIndex: item.currentStepIndex + 1
+    });
+  }
+  static restorLastLabelList() {
+    _GameStepManager._openedLabels = _GameStepManager.originalStepData.openedLabels;
+  }
+  /* Run Methods */
+  static get canGoNext() {
+    let options = getChoiceMenuOptions();
+    if (options && options.length > 0) {
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Execute the next step and add it to the history.
+   * @param props The props to pass to the step.
+   * @param choiseMade The index of the choise made by the player. (This params is used in the choice menu)
+   * @returns StepLabelResultType or undefined.
+   * @example
+   * ```typescript
+   *     function nextOnClick() {
+   *     setLoading(true)
+   *     GameStepManager.goNext(yourParams)
+   *         .then((result) => {
+   *             setUpdate((p) => p + 1)
+   *             setLoading(false)
+   *             if (result) {
+   *                 // your code
+   *             }
+   *         })
+   *         .catch((e) => {
+   *             setLoading(false)
+   *             console.error(e)
+   *         })
+   * }
+   * ```
+   */
+  static goNext(props, choiseMade) {
+    return __async(this, null, function* () {
+      if (!_GameStepManager.canGoNext) {
+        console.warn("[Pixi'VN] The player must make a choice");
+        return;
+      }
+      if (_GameStepManager.currentLabel && _GameStepManager.currentLabel.onStepEnd) {
+        yield _GameStepManager.currentLabel.onStepEnd(_GameStepManager.currentLabelStepIndex || 0, _GameStepManager.currentLabel);
+      }
+      _GameStepManager.increaseCurrentStepIndex();
+      return yield _GameStepManager.runCurrentStep(props, choiseMade);
+    });
+  }
+  /**
+   * Execute the current step and add it to the history.
+   * @param props The props to pass to the step.
+   * @param choiseMade The choise made by the player.
+   * @returns StepLabelResultType or undefined.
+   */
+  static runCurrentStep(props, choiseMade) {
+    return __async(this, null, function* () {
+      if (_GameStepManager.currentLabelId) {
+        let currentLabelStepIndex = _GameStepManager.currentLabelStepIndex;
+        if (currentLabelStepIndex === null) {
+          console.error("[Pixi'VN] currentLabelStepIndex is null");
+          return;
+        }
+        let currentLabel = _GameStepManager.currentLabel;
+        if (!currentLabel) {
+          console.error("[Pixi'VN] currentLabel not found");
+          return;
+        }
+        if (currentLabel.steps.length > currentLabelStepIndex) {
+          let onStepRun = currentLabel.onStepStart;
+          if (onStepRun) {
+            yield onStepRun(currentLabelStepIndex, currentLabel);
+          }
+          let step = currentLabel.steps[currentLabelStepIndex];
+          let result = yield step(props);
+          _GameStepManager.addStepHistory(step, choiseMade);
+          return result;
+        } else if (_GameStepManager.openedLabels.length > 1) {
+          _GameStepManager.closeCurrentLabel();
+          return yield _GameStepManager.goNext(props, choiseMade);
+        } else {
+          _GameStepManager.restorLastLabelList();
+          console.error("[Pixi'VN] The end of the game is not managed, so the game is blocked. Read this documentation to know how to manage the end of the game: https://pixi-vn.web.app/start/labels.html#how-manage-the-end-of-the-game");
+          return;
+        }
+      }
+    });
+  }
+  /**
+   * Execute the label and add it to the history. (It's similar to Ren'Py's call function)
+   * @param label The label to execute or the id of the label
+   * @param props The props to pass to the label.
+   * @returns StepLabelResultType or undefined.
+   * @example
+   * ```typescript
+   * GameStepManager.callLabel(startLabel, yourParams).then((result) => {
+   *     if (result) {
+   *         // your code
+   *     }
+   * })
+   * ```
+   * @example
+   * ```typescript
+   * // if you use it in a step label you should return the result.
+   * return GameStepManager.callLabel(startLabel).then((result) => {
+   *     return result
+   * })
+   * ```
+   */
+  static callLabel(label, props) {
+    return __async(this, null, function* () {
+      let choiseMade = void 0;
+      let labelId;
+      if (typeof label === "string") {
+        labelId = label;
+      } else {
+        labelId = label.id;
+        if (typeof label.choiseIndex === "number") {
+          choiseMade = label.choiseIndex;
+        }
+      }
+      try {
+        if (labelId === CLOSE_LABEL_ID) {
+          let closeCurrentLabel = newCloseLabel(choiseMade);
+          let choice = {
+            label: closeCurrentLabel,
+            text: "",
+            closeCurrentLabel: false,
+            type: "close",
+            props: {}
+          };
+          return _GameStepManager.closeChoiceMenu(choice, props);
+        }
+        let tempLabel = getLabelById(labelId);
+        if (!tempLabel) {
+          throw new Error(`[Pixi'VN] Label ${labelId} not found`);
+        }
+        if (_GameStepManager.currentLabel && _GameStepManager.currentLabel.onStepEnd) {
+          yield _GameStepManager.currentLabel.onStepEnd(_GameStepManager.currentLabelStepIndex || 0, _GameStepManager.currentLabel);
+        }
+        _GameStepManager.pushNewLabel(tempLabel.id);
+      } catch (e) {
+        console.error("[Pixi'VN] Error calling label", e);
+        return;
+      }
+      return yield _GameStepManager.runCurrentStep(props, choiseMade);
+    });
+  }
+  /**
+   * Execute the label, close the current label, execute the new label and add the new label to the history. (It's similar to Ren'Py's jump function)
+   * @param label The label to execute.
+   * @param props The props to pass to the label or the id of the label
+   * @returns StepLabelResultType or undefined.
+   * @example
+   * ```typescript
+   * GameStepManager.jumpLabel(startLabel, yourParams).then((result) => {
+   *     if (result) {
+   *         // your code
+   *     }
+   * })
+   * ```
+   * @example
+   * ```typescript
+   * // if you use it in a step label you should return the result.
+   * return GameStepManager.jumpLabel(startLabel).then((result) => {
+   *     return result
+   * })
+   * ```
+   */
+  static jumpLabel(label, props) {
+    return __async(this, null, function* () {
+      _GameStepManager.closeCurrentLabel();
+      let choiseMade = void 0;
+      let labelId;
+      if (typeof label === "string") {
+        labelId = label;
+      } else {
+        labelId = label.id;
+        if (typeof label.choiseIndex === "number") {
+          choiseMade = label.choiseIndex;
+        }
+      }
+      try {
+        if (labelId === CLOSE_LABEL_ID) {
+          let closeCurrentLabel = newCloseLabel(choiseMade);
+          let choice = {
+            label: closeCurrentLabel,
+            text: "",
+            closeCurrentLabel: false,
+            type: "close",
+            props: {}
+          };
+          return _GameStepManager.closeChoiceMenu(choice, props);
+        }
+        let tempLabel = getLabelById(labelId);
+        if (!tempLabel) {
+          throw new Error(`[Pixi'VN] Label ${labelId} not found`);
+        }
+        if (_GameStepManager.currentLabel && _GameStepManager.currentLabel.onStepEnd) {
+          yield _GameStepManager.currentLabel.onStepEnd(_GameStepManager.currentLabelStepIndex || 0, _GameStepManager.currentLabel);
+        }
+        _GameStepManager.pushNewLabel(tempLabel.id);
+      } catch (e) {
+        console.error("[Pixi'VN] Error jumping label", e);
+        return;
+      }
+      return yield _GameStepManager.runCurrentStep(props, choiseMade);
+    });
+  }
+  /**
+   * When the player is in a choice menu, can use this function to exit to the choice menu.
+   * @param choice
+   * @param props
+   * @returns StepLabelResultType or undefined.
+   * @example
+   * ```typescript
+   * GameStepManager.closeChoiceMenu(yourParams).then((result) => {
+   *     if (result) {
+   *         // your code
+   *     }
+   * })
+   * ```
+   */
+  static closeChoiceMenu(choice, props) {
+    return __async(this, null, function* () {
+      let label = choice.label;
+      let choiseMade = void 0;
+      if (typeof label.choiseIndex === "number") {
+        choiseMade = label.choiseIndex;
+      }
+      if (choice.closeCurrentLabel) {
+        _GameStepManager.closeCurrentLabel();
+      }
+      return _GameStepManager.goNext(props, choiseMade);
+    });
+  }
+  /* After Update Methods */
+  // /**
+  //  * After the update or code edit, some steps or labels may no longer match.
+  //  * - In case of step mismatch, the game will be updated to the last matching step.
+  //  * - In case of label mismatch, the game gives an error.
+  //  * @returns 
+  //  */
+  // private static afterUpdate() {
+  //     // TODO: implement
+  //     if (!GameStepManager.currentLabel) {
+  //         // TODO: implement
+  //         return
+  //     }
+  //     let currentLabel = getLabelInstanceByClassName(GameStepManager.currentLabel)
+  //     if (!currentLabel) {
+  //         console.error("Label not found")
+  //         return
+  //     }
+  //     let oldSteps = GameStepManager.stepsAfterLastHistoryLabel
+  //     let currentStepIndex = currentLabel.getCorrespondingStepsNumber(oldSteps)
+  //     let stepToRemove = oldSteps.length - currentStepIndex
+  //     GameStepManager.removeLastHistoryNodes(stepToRemove)
+  //     GameStepManager.loadLastStep()
+  // }
+  // private static loadLastStep() {
+  //     // TODO: implement
+  // }
+  // /**
+  //  * Remove a number of items from the last of the history.
+  //  * @param itemNumber The number of items to remove from the last of the history.
+  //  */
+  // private static removeLastHistoryNodes(itemNumber: number) {
+  //     // TODO: implement
+  //     for (let i = 0; i < itemNumber; i++) {
+  //         GameStepManager._stepsHistory.pop()
+  //     }
+  // }
+  // /**
+  //  * stepsAfterLastHistoryLabel is a list of steps that occurred after the last history label.
+  //  */
+  // private static get stepsAfterLastHistoryLabel(): StepHistoryDataType[] {
+  //     let length = GameStepManager._stepsHistory.length
+  //     let steps: StepHistoryDataType[] = []
+  //     for (let i = length - 1; i >= 0; i--) {
+  //         let element = GameStepManager._stepsHistory[i]
+  //         if (typeof element === "object" && "stepSha1" in element) {
+  //             steps.push(element.stepSha1)
+  //         }
+  //         else {
+  //             break
+  //         }
+  //     }
+  //     steps = steps.reverse()
+  //     return steps
+  // }
+  /* Go Back & Refresh Methods */
+  /**
+   * Go back to the last step and add it to the history.
+   * @param navigate The navigate function.
+   * @param steps The number of steps to go back.
+   * @returns 
+   * @example
+   * ```typescript
+   * export function goBack(navigate: (path: string) => void, afterBack?: () => void) {
+   *     GameStepManager.goBack(navigate)
+   *     afterBack && afterBack()
+   * }
+   * ```
+   */
+  static goBack(navigate, steps = 1) {
+    return __async(this, null, function* () {
+      if (steps <= 0) {
+        console.warn("[Pixi'VN] Steps must be greater than 0");
+        return;
+      }
+      if (_GameStepManager._stepsHistory.length <= 1) {
+        console.warn("[Pixi'VN] No steps to go back");
+        return;
+      }
+      let restoredStep = _GameStepManager.goBackInternal(steps, _GameStepManager.originalStepData);
+      if (restoredStep) {
+        _GameStepManager._originalStepData = restoredStep;
+        _GameStepManager._openedLabels = createExportableElement(restoredStep.openedLabels);
+        if (_GameStepManager.currentLabel && _GameStepManager.currentLabel.onLoadStep) {
+          yield _GameStepManager.currentLabel.onLoadStep(_GameStepManager.currentLabelStepIndex || 0, _GameStepManager.currentLabel);
+        }
+        GameStorageManager.import(createExportableElement(restoredStep.storage));
+        GameWindowManager.import(createExportableElement(restoredStep.canvas));
+        navigate(restoredStep.path);
+      } else {
+        console.error("[Pixi'VN] Error going back");
+      }
+    });
+  }
+  static goBackInternal(steps, restoredStep) {
+    if (steps <= 0) {
+      return restoredStep;
+    }
+    if (_GameStepManager._stepsHistory.length == 0) {
+      return restoredStep;
+    }
+    let lastHistoryStep = _GameStepManager.lastHistoryStep;
+    if (lastHistoryStep) {
+      try {
+        let result = restoreDeepDiffChanges(restoredStep, lastHistoryStep.diff);
+        _GameStepManager._lastStepIndex = lastHistoryStep.index;
+        _GameStepManager._stepsHistory.pop();
+        return _GameStepManager.goBackInternal(steps - 1, result);
+      } catch (e) {
+        console.error("[Pixi'VN] Error applying diff", e);
+        return restoredStep;
+      }
+    } else {
+      return restoredStep;
+    }
+  }
+  /**
+   * Return true if it is possible to go back.
+   */
+  static get canGoBack() {
+    return _GameStepManager._stepsHistory.length > 1;
+  }
+  /**
+   * Add a label to the history.
+   */
+  static clear() {
+    _GameStepManager._stepsHistory = [];
+    _GameStepManager._openedLabels = [];
+  }
+  /* Export and Import Methods */
+  /**
+   * Export the history to a JSON string.
+   * @returns The history in a JSON string.
+   */
+  static exportJson() {
+    return JSON.stringify(this.export());
+  }
+  /**
+   * Export the history to an object.
+   * @returns The history in an object.
+   */
+  static export() {
+    return {
+      stepsHistory: _GameStepManager._stepsHistory,
+      openedLabels: _GameStepManager._openedLabels,
+      lastStepIndex: _GameStepManager._lastStepIndex,
+      originalStepData: _GameStepManager._originalStepData
+    };
+  }
+  /**
+   * Import the history from a JSON string.
+   * @param dataString The history in a JSON string.
+   */
+  static importJson(dataString) {
+    return __async(this, null, function* () {
+      yield _GameStepManager.import(JSON.parse(dataString));
+    });
+  }
+  /**
+   * Import the history from an object.
+   * @param data The history in an object.
+   */
+  static import(data) {
+    return __async(this, null, function* () {
+      _GameStepManager.clear();
+      try {
+        if (data.hasOwnProperty("stepsHistory")) {
+          _GameStepManager._stepsHistory = data["stepsHistory"];
+        } else {
+          console.warn("[Pixi'VN] Could not import stepsHistory data, so will be ignored");
+        }
+        if (data.hasOwnProperty("openedLabels")) {
+          _GameStepManager._openedLabels = data["openedLabels"];
+        } else {
+          console.warn("[Pixi'VN] Could not import openedLabels data, so will be ignored");
+        }
+        if (data.hasOwnProperty("lastStepIndex")) {
+          _GameStepManager._lastStepIndex = data["lastStepIndex"];
+        } else {
+          console.warn("[Pixi'VN] Could not import lastStepIndex data, so will be ignored");
+        }
+        if (data.hasOwnProperty("originalStepData")) {
+          _GameStepManager._originalStepData = data["originalStepData"];
+        } else {
+          console.warn("[Pixi'VN] Could not import originalStepData data, so will be ignored");
+        }
+        if (_GameStepManager.currentLabel && _GameStepManager.currentLabel.onLoadStep) {
+          yield _GameStepManager.currentLabel.onLoadStep(_GameStepManager.currentLabelStepIndex || 0, _GameStepManager.currentLabel);
+        }
+      } catch (e) {
+        console.error("[Pixi'VN] Error importing data", e);
+      }
+    });
+  }
+};
+/**
+ * stepHistory is a list of label events and steps that occurred during the progression of the steps.
+ */
+_GameStepManager._stepsHistory = [];
+_GameStepManager._lastStepIndex = 0;
+_GameStepManager._openedLabels = [];
+_GameStepManager._originalStepData = void 0;
+var GameStepManager = _GameStepManager;
+
 // src/classes/StoredClassModel.ts
 var StoredClassModel = class {
   /**
@@ -2021,6 +2839,54 @@ var DialogueBaseModel = class {
   }
 };
 
-export { CanvasEvent, CharacterBaseModel2 as CharacterBaseModel, ChoiceMenuOption, ChoiceMenuOptionClose, DialogueBaseModel, Label, StoredClassModel };
+// src/classes/LabelJson.ts
+var LabelJson2 = class extends LabelAbstract {
+  /**
+   * @param id is the id of the label
+   * @param steps is the list of steps that the label will perform
+   * @param props is the properties of the label
+   */
+  constructor(id, steps, props) {
+    super(id, props);
+    this._steps = steps;
+  }
+  /**
+   * Get the steps of the label.
+   */
+  get steps() {
+    if (typeof this._steps === "function") {
+      return this._steps().map(this.stepConverter);
+    }
+    return this._steps.map(this.stepConverter);
+  }
+  stepConverter(step) {
+    return (props) => {
+      if (step.currentChoiceMenuOptions) {
+        setChoiceMenuOptions(step.currentChoiceMenuOptions);
+      } else {
+        clearChoiceMenuOptions();
+      }
+      if (step.dialog) {
+        setDialogue(step.dialog);
+      } else {
+        clearDialogue();
+      }
+      if (step.labelToOpen) {
+        if (step.labelToOpen.type === "jump") {
+          GameStepManager.jumpLabel(step.labelToOpen.labelId, props);
+        } else {
+          GameStepManager.callLabel(step.labelToOpen.labelId, props);
+        }
+      }
+      if (step.end === "game_end") {
+        console.warn("[Pixi'VN] Game end not implemented");
+      } else if (step.end === "label_end") {
+        GameStepManager.closeCurrentLabel();
+      }
+    };
+  }
+};
+
+export { CanvasEvent, CharacterBaseModel2 as CharacterBaseModel, ChoiceMenuOption, ChoiceMenuOptionClose, DialogueBaseModel, Label, LabelJson2 as LabelJson, StoredClassModel };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map