Merge remote-tracking branch 'origin/main'

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drincs/pixi-vn",
-  "version": "0.10.22",
+  "version": "0.10.23",
   "type": "module",
   "description": "Pixi'VN is a npm package that provides various features for creating visual novels.",
   "main": "./dist/index.cjs",

src/classes/StoredClassModel.ts

@@ -1,4 +1,4 @@
-import { StorageManagerStatic } from "../managers";
+import StorageManagerStatic from "../managers/StorageManagerStatic";
 
 /**
  * StoredClassModel is a abstract class that contains the methods to store a class in the game.

src/classes/canvas/Container.ts

@@ -1,5 +1,6 @@
 import { ContainerEvents, ContainerOptions, EventEmitter, Container as PixiContainer } from "pixi.js";
 import { CANVAS_CONTAINER_ID } from "../../constants";
+import { canvasComponentDecoratorFn } from "../../decorators/canvas-element-decorator";
 import { getEventInstanceById } from "../../decorators/event-decorator";
 import { importCanvasElement } from "../../functions/canvas/canvas-import-utility";
 import { getMemoryContainer } from "../../functions/canvas/canvas-memory-utility";
@@ -121,6 +122,7 @@ export default class Container<
         return super.on(event, fn, context);
     }
 }
+canvasComponentDecoratorFn(Container, CANVAS_CONTAINER_ID);
 
 export async function setMemoryContainer<T extends PixiContainer>(
     element: T | PixiContainer,

src/classes/canvas/ImageContainer.ts

@@ -1,5 +1,6 @@
 import { ObservablePoint, PointData, Texture } from "pixi.js";
 import { CANVAS_IMAGE_CONTAINER_ID } from "../../constants";
+import { canvasComponentDecoratorFn } from "../../decorators/canvas-element-decorator";
 import {
     calculateAlignByPosition,
     calculatePercentagePositionByPosition,
@@ -365,6 +366,7 @@ export default class ImageContainer
         super.y = value;
     }
 }
+canvasComponentDecoratorFn(ImageContainer, CANVAS_IMAGE_CONTAINER_ID);
 
 export async function setMemoryImageContainer(
     element: ImageContainer,

src/classes/canvas/ImageSprite.ts

@@ -1,5 +1,6 @@
 import { ObservablePoint, Sprite as PixiSprite, PointData, Texture, TextureSource, TextureSourceLike } from "pixi.js";
 import { CANVAS_IMAGE_ID } from "../../constants";
+import { canvasComponentDecoratorFn } from "../../decorators/canvas-element-decorator";
 import { addImage, getTexture, showWithDissolve } from "../../functions";
 import { getMemorySprite } from "../../functions/canvas/canvas-memory-utility";
 import {
@@ -320,6 +321,7 @@ export default class ImageSprite<Memory extends ImageSpriteMemory = ImageSpriteM
         super.y = value;
     }
 }
+canvasComponentDecoratorFn(ImageSprite, CANVAS_IMAGE_ID);
 
 export async function setMemoryImageSprite(
     element: ImageSprite,

src/classes/canvas/Sprite.ts

@@ -9,6 +9,7 @@ import {
     TextureSourceLike,
 } from "pixi.js";
 import { CANVAS_SPRITE_ID } from "../../constants";
+import { canvasComponentDecoratorFn } from "../../decorators/canvas-element-decorator";
 import { getEventInstanceById, getEventTypeById } from "../../decorators/event-decorator";
 import { getTexture } from "../../functions";
 import { getMemorySprite } from "../../functions/canvas/canvas-memory-utility";
@@ -142,6 +143,7 @@ export default class Sprite<Memory extends SpriteOptions & CanvasBaseItemMemory
         return mySprite;
     }
 }
+canvasComponentDecoratorFn(Sprite, CANVAS_SPRITE_ID);
 
 export async function setMemorySprite<Memory extends SpriteBaseMemory>(
     element: Sprite<any>,

src/classes/canvas/Text.ts

@@ -1,5 +1,6 @@
 import { ContainerChild, ContainerEvents, EventEmitter, Text as PixiText, TextOptions } from "pixi.js";
 import { CANVAS_TEXT_ID } from "../../constants";
+import { canvasComponentDecoratorFn } from "../../decorators/canvas-element-decorator";
 import { getEventInstanceById, getEventTypeById } from "../../decorators/event-decorator";
 import { getMemoryText } from "../../functions/canvas/canvas-memory-utility";
 import { logger } from "../../functions/log-utility";
@@ -104,6 +105,7 @@ export default class Text extends PixiText implements CanvasBaseItem<TextMemory>
         return super.on(event, fn, context);
     }
 }
+canvasComponentDecoratorFn(Text, CANVAS_TEXT_ID);
 
 export async function setMemoryText(element: Text, memory: TextMemory | {}) {
     await setMemoryContainer(element, memory);

src/classes/canvas/VideoSprite.ts

@@ -1,5 +1,6 @@
 import { Sprite as PixiSprite, Texture, TextureSourceLike } from "pixi.js";
 import { CANVAS_VIDEO_ID } from "../../constants";
+import { canvasComponentDecoratorFn } from "../../decorators/canvas-element-decorator";
 import { addVideo, showWithDissolve } from "../../functions";
 import { VideoSpriteMemory, VideoSpriteOptions } from "../../interface";
 import ImageSprite, { setMemoryImageSprite } from "./ImageSprite";
@@ -27,95 +28,94 @@ import ImageSprite, { setMemoryImageSprite } from "./ImageSprite";
  */
 export default class VideoSprite extends ImageSprite<VideoSpriteMemory> {
     constructor(options?: VideoSpriteOptions | Texture | undefined, textureAlias?: string) {
-        let loop = undefined
-        let paused = undefined
-        let currentTime = undefined
+        let loop = undefined;
+        let paused = undefined;
+        let currentTime = undefined;
         if (options && "loop" in options && options?.loop !== undefined) {
-            loop = options.loop
-            delete options.loop
+            loop = options.loop;
+            delete options.loop;
         }
         if (options && "paused" in options && options?.paused !== undefined) {
-            paused = options.paused
-            delete options.paused
+            paused = options.paused;
+            delete options.paused;
         }
         if (options && "currentTime" in options && options?.currentTime !== undefined) {
-            currentTime = options.currentTime
-            delete options.currentTime
+            currentTime = options.currentTime;
+            delete options.currentTime;
         }
-        super(options, textureAlias)
+        super(options, textureAlias);
         if (loop) {
-            this.loop = loop
+            this.loop = loop;
         }
         if (paused) {
-            this.paused = paused
+            this.paused = paused;
         }
         if (currentTime) {
-            this.currentTime = currentTime
+            this.currentTime = currentTime;
         }
     }
-    pixivnId: string = CANVAS_VIDEO_ID
+    pixivnId: string = CANVAS_VIDEO_ID;
     override get memory(): VideoSpriteMemory {
         return {
             ...super.memory,
             pixivnId: this.pixivnId,
             loop: this.loop,
             paused: this._paused,
             currentTime: this.currentTime,
-        }
+        };
     }
-    override set memory(_value: VideoSpriteMemory) { }
+    override set memory(_value: VideoSpriteMemory) {}
     override async setMemory(value: VideoSpriteMemory) {
-        this.memory = value
-        return await setMemoryVideoSprite(this, value)
+        this.memory = value;
+        return await setMemoryVideoSprite(this, value);
     }
     static override from(source: Texture | TextureSourceLike, skipCache?: boolean) {
-        let sprite = PixiSprite.from(source, skipCache)
-        let mySprite = new VideoSprite()
-        mySprite.texture = sprite.texture
-        return mySprite
+        let sprite = PixiSprite.from(source, skipCache);
+        let mySprite = new VideoSprite();
+        mySprite.texture = sprite.texture;
+        return mySprite;
     }
 
     override async load() {
-        await super.load()
-        this.loop = this._looop
-        this.currentTime = this._currentTime
-        this.paused = this._paused
+        await super.load();
+        this.loop = this._looop;
+        this.currentTime = this._currentTime;
+        this.paused = this._paused;
     }
 
-    private _looop: boolean = false
+    private _looop: boolean = false;
     /**
      * Set to true if you want the video to loop.
      */
     get loop() {
-        return this.texture?.source?.resource?.loop || false
+        return this.texture?.source?.resource?.loop || false;
     }
     set loop(value: boolean) {
-        this._looop = value
+        this._looop = value;
         if (this.texture?.source?.resource) {
-            this.texture.source.resource.loop = value
+            this.texture.source.resource.loop = value;
         }
     }
 
-    private _paused: boolean = false
+    private _paused: boolean = false;
     /**
      * Set to true if you want the video to be paused.
      */
     get paused() {
-        return this.texture?.source?.resource?.paused || false
+        return this.texture?.source?.resource?.paused || false;
     }
     set paused(value: boolean) {
         if (value) {
-            this.pause()
-        }
-        else {
-            this.play()
+            this.pause();
+        } else {
+            this.play();
         }
     }
     /**
      * Pause the video.
      */
     pause() {
-        this._paused = true
+        this._paused = true;
         if (this.texture?.source?.resource) {
             this.texture.source.resource.pause();
         }
@@ -124,52 +124,57 @@ export default class VideoSprite extends ImageSprite<VideoSpriteMemory> {
      * Play the video.
      */
     play() {
-        this._paused = false
+        this._paused = false;
         if (this.texture?.source?.resource) {
             this.texture.source.resource.play();
         }
     }
 
-    private _currentTime: number = 0
+    private _currentTime: number = 0;
     /**
      * The current time of the video.
      */
     get currentTime(): number {
-        return this.texture?.source?.resource?.currentTime || 0
+        return this.texture?.source?.resource?.currentTime || 0;
     }
     set currentTime(value: number) {
-        let duration = this.duration
+        let duration = this.duration;
         if (duration && value >= duration) {
-            value = 0
+            value = 0;
         }
-        this._currentTime = value
+        this._currentTime = value;
         if (this.texture?.source?.resource) {
-            this.texture.source.resource.currentTime = value
+            this.texture.source.resource.currentTime = value;
         }
     }
 
     /**
      * Restart the video.
      */
     restart() {
-        this.currentTime = 0
+        this.currentTime = 0;
     }
 
     /**
      * The duration of the video.
      */
     get duration(): number | undefined {
         if (this.texture?.source?.resource) {
-            return this.texture.source.resource.duration || 0
+            return this.texture.source.resource.duration || 0;
         }
     }
 }
+canvasComponentDecoratorFn(VideoSprite, CANVAS_VIDEO_ID);
 
-export async function setMemoryVideoSprite(element: VideoSprite, memory: VideoSpriteMemory | {}, options?: {
-    ignoreTexture?: boolean,
-}) {
-    await setMemoryImageSprite(element, memory, { ignoreTexture: options?.ignoreTexture })
-    "loop" in memory && memory.loop !== undefined && (element.loop = memory.loop)
-    "currentTime" in memory && memory.currentTime !== undefined && (element.currentTime = memory.currentTime)
-    "paused" in memory && memory.paused !== undefined && (element.paused = memory.paused)
+export async function setMemoryVideoSprite(
+    element: VideoSprite,
+    memory: VideoSpriteMemory | {},
+    options?: {
+        ignoreTexture?: boolean;
+    }
+) {
+    await setMemoryImageSprite(element, memory, { ignoreTexture: options?.ignoreTexture });
+    "loop" in memory && memory.loop !== undefined && (element.loop = memory.loop);
+    "currentTime" in memory && memory.currentTime !== undefined && (element.currentTime = memory.currentTime);
+    "paused" in memory && memory.paused !== undefined && (element.paused = memory.paused);
 }

src/decorators/canvas-element-decorator.ts

@@ -1,13 +1,4 @@
-import { Container, ImageContainer, ImageSprite, Sprite, Text, VideoSprite } from "../classes";
 import CanvasBaseItem from "../classes/canvas/CanvasBaseItem";
-import {
-    CANVAS_CONTAINER_ID,
-    CANVAS_IMAGE_CONTAINER_ID,
-    CANVAS_IMAGE_ID,
-    CANVAS_SPRITE_ID,
-    CANVAS_TEXT_ID,
-    CANVAS_VIDEO_ID,
-} from "../constants";
 import { logger } from "../functions/log-utility";
 import { CanvasElementAliasType } from "../types/CanvasElementAliasType";
 
@@ -19,44 +10,26 @@ const registeredCanvasElement: { [name: CanvasElementAliasType]: typeof CanvasBa
  */
 export default function canvasComponentDecorator(name?: CanvasElementAliasType) {
     return function (target: typeof CanvasBaseItem<any>) {
-        if (!name) {
-            name = target.name;
-        }
-        if (registeredCanvasElement[name]) {
-            logger.warn(`CanvasElement ${name} already registered`);
-        }
-        target.prototype.pixivnId = name;
-        registeredCanvasElement[name] = target;
+        canvasComponentDecoratorFn(target, name);
     };
 }
 
+export function canvasComponentDecoratorFn(target: typeof CanvasBaseItem<any>, name?: CanvasElementAliasType) {
+    if (!name) {
+        name = target.name;
+    }
+    if (registeredCanvasElement[name]) {
+        logger.warn(`CanvasElement ${name} already registered`);
+    }
+    target.prototype.pixivnId = name;
+    registeredCanvasElement[name] = target;
+}
+
 export function getCanvasElementTypeById<T extends typeof CanvasBaseItem<any>>(
     canvasId: CanvasElementAliasType
 ): T | undefined {
     try {
         let eventType = registeredCanvasElement[canvasId];
-        if (!eventType) {
-            switch (canvasId) {
-                case CANVAS_CONTAINER_ID:
-                    eventType = Container;
-                    break;
-                case CANVAS_VIDEO_ID:
-                    eventType = VideoSprite;
-                    break;
-                case CANVAS_IMAGE_ID:
-                    eventType = ImageSprite;
-                    break;
-                case CANVAS_SPRITE_ID:
-                    eventType = Sprite;
-                    break;
-                case CANVAS_TEXT_ID:
-                    eventType = Text;
-                    break;
-                case CANVAS_IMAGE_CONTAINER_ID:
-                    eventType = ImageContainer;
-                    break;
-            }
-        }
         if (!eventType) {
             logger.error(
                 `CanvasElement ${canvasId} not found, did you forget to register it with the canvasComponentDecorator?`

src/decorators/label-decorator.ts

@@ -1,4 +1,4 @@
-import { Label } from "../classes";
+import Label from "../classes/Label";
 import LabelAbstract from "../classes/LabelAbstract";
 import { logger } from "../functions/log-utility";
 import { LabelProps } from "../interface";

src/index.ts

@@ -22,6 +22,10 @@ export * from "./decorators";
 export * from "./functions";
 export * from "./interface";
 export * from "./managers";
+export { default as CanvasManagerStatic } from "./managers/CanvasManagerStatic";
+export { default as NarrationManagerStatic } from "./managers/NarrationManagerStatic";
+export { default as SoundManagerStatic } from "./managers/SoundManagerStatic";
+export { default as StorageManagerStatic } from "./managers/StorageManagerStatic";
 export * from "./types";
 export * from "./types/ticker";
 

src/interface/managers/StorageManagerInterface.ts

@@ -1,4 +1,4 @@
-import { StorageManagerStatic } from "../../managers";
+import StorageManagerStatic from "../../managers/StorageManagerStatic";
 import { StorageElementType } from "../../types";
 import ExportedStorage from "../export/ExportedStorage";