narraleaf-react 0.5.0 → 0.6.0

package/dist/game/nlcore/elements/story.d.ts

@@ -1,78 +1,92 @@
-import { Constructable } from "../action/constructable";
-import { Scene } from "../elements/scene";
-import { SceneAction } from "../action/actions/sceneAction";
-import { Persistent, PersistentContent } from "../elements/persistent";
-import { Service } from "../elements/service";
-export declare enum Origins {
-    topLeft = "top left",
-    topRight = "top right",
-    bottomLeft = "bottom left",
-    bottomRight = "bottom right"
-}
-export interface IStoryConfig {
-    origin: Origins;
-}
-export declare class Story extends Constructable<SceneAction<"scene:action">, Story> {
-    constructor(name: string, config?: IStoryConfig);
-    /**
-     * Set the entry scene of the story
-     * @example
-     * ```typescript
-     * const story = new Story("story");
-     * const scene = new Scene("scene");
-     * story.entry(scene); // The story will start from this scene
-     * ```
-     */
-    entry(scene: Scene): this;
-    /**
-     * Register a scene to the story
-     * @example
-     * ```typescript
-     * // register a scene
-     * const story = new Story("story");
-     * const scene1 = new Scene("scene1");
-     * const scene2 = new Scene("scene2");
-     *
-     * story.register(scene1); // Register scene1
-     *
-     * scene2.action([
-     *   scene2.jump("scene1") // Jump to scene1
-     * ]);
-     * ```
-     */
-    registerScene(name: string, scene: Scene): this;
-    registerScene(scene: Scene): this;
-    /**
-     * Register a Persistent to the story
-     *
-     * You can't use a Persistent that isn't registered to the story
-     */
-    registerPersistent(persistent: Persistent<any>): this;
-    /**
-     * Create a Persistent and register it to the story
-     * @example
-     * ```typescript
-     * const persistent = story.createPersistent("playerData", {
-     *   name: "persistent",
-     * });
-     *
-     * // is equivalent to
-     * const persistent = new Persistent("playerData", {
-     *   name: "persistent",
-     * });
-     * story.registerPersistent(persistent);
-     * ```
-     */
-    createPersistent<T extends PersistentContent>(namespace: string, defaultContent: T): Persistent<T>;
-    /**
-     * Register a Service to the story
-     *
-     * **Note**: service name should be unique
-     */
-    registerService(name: string, service: Service): this;
-    /**
-     * Get a registered service, throw an error if the service isn't found
-     */
-    getService<T extends Service>(name: string): T;
-    getScene(name: string | Scene, assert?: false): Scene | null;
-}
+import { Constructable } from "../action/constructable";
+import { Scene } from "../elements/scene";
+import { SceneAction } from "../action/actions/sceneAction";
+import { Persistent, PersistentContent } from "../elements/persistent";
+import { Service } from "../elements/service";
+export declare enum Origins {
+    topLeft = "top left",
+    topRight = "top right",
+    bottomLeft = "bottom left",
+    bottomRight = "bottom right"
+}
+export interface IStoryConfig {
+    origin: Origins;
+}
+export declare class Story extends Constructable<SceneAction<"scene:action">, Story> {
+    constructor(name: string, config?: IStoryConfig);
+    /**
+     * Set the entry scene of the story
+     * @example
+     * ```typescript
+     * const story = new Story("story");
+     * const scene = new Scene("scene");
+     * story.entry(scene); // The story will start from this scene
+     * ```
+     */
+    entry(scene: Scene): this;
+    /**
+     * Register a scene to the story
+     * @example
+     * ```typescript
+     * // register a scene
+     * const story = new Story("story");
+     * const scene1 = new Scene("scene1");
+     * const scene2 = new Scene("scene2");
+     *
+     * story.register(scene1); // Register scene1
+     *
+     * scene2.action([
+     *   scene2.jump("scene1") // Jump to scene1
+     * ]);
+     * ```
+     */
+    registerScene(name: string, scene: Scene): this;
+    registerScene(scene: Scene): this;
+    /**
+     * Register a Persistent to the story
+     *
+     * You can't use a Persistent that isn't registered to the story
+     */
+    registerPersistent(persistent: Persistent<any>): this;
+    /**
+     * Create a Persistent and register it to the story
+     * @example
+     * ```typescript
+     * const persistent = story.createPersistent("playerData", {
+     *   name: "persistent",
+     * });
+     *
+     * // is equivalent to
+     * const persistent = new Persistent("playerData", {
+     *   name: "persistent",
+     * });
+     * story.registerPersistent(persistent);
+     * ```
+     */
+    createPersistent<T extends PersistentContent>(namespace: string, defaultContent: T): Persistent<T>;
+    /**
+     * Register a Service to the story
+     *
+     * **Note**: service name should be unique
+     */
+    registerService(name: string, service: Service): this;
+    /**
+     * Get a registered service, throw an error if the service isn't found
+     */
+    getService<T extends Service>(name: string): T;
+    /**
+     * Returns a 64-bit hash of the story
+     *
+     * The hash is calculated by the stringified story.
+     *
+     * If `strict` is true, the hash will be calculated by the stringified story with strict mode.
+     *
+     * In strict mode, the hash will be calculated
+     * - With all the Lambda functions stringified (If the lambda function is changed, the hash will be different)
+     *
+     * However, the hash is **not** calculated with the text content of the story.
+     */
+    hash(strict?: boolean): string;
+    stringify(strict?: boolean): string;
+    getScene(name: string | Scene, assert?: false): Scene | null;
+}

package/dist/game/nlcore/elements/transform/position.d.ts

@@ -1,103 +1,99 @@
-export declare enum CommonPositionType {
-    Left = "left",
-    Center = "center",
-    Right = "right"
-}
-export declare const CommonPositions: {
-    left: `${number}%`;
-    center: `${number}%`;
-    right: `${number}%`;
-};
-export interface IPosition {
-    toCSS(): D2Position;
-}
-export type Coord2DPosition = {
-    x: number | `${"-" | ""}${number}%`;
-    y: number | `${"-" | ""}${number}%`;
-} & Partial<OffsetPosition>;
-export type AlignPosition = {
-    xalign: number;
-    yalign: number;
-} & Partial<OffsetPosition>;
-export type OffsetPosition = {
-    xoffset: number;
-    yoffset: number;
-};
-export type RawPosition = CommonPositionType | (Partial<Coord2DPosition> & {
-    xalign?: never;
-    yalign?: never;
-}) | (Partial<AlignPosition> & {
-    x?: never;
-    y?: never;
-});
-type Unknown = typeof PositionUtils.Unknown;
-type UnknownAble<T> = T | Unknown;
-export declare class CommonPosition implements IPosition {
-    static Positions: typeof CommonPositionType;
-    static isCommonPositionType(arg: any): arg is CommonPosition;
-    readonly position: CommonPositionType;
-    /**
-     * Create a new CommonPosition instance
-     * @example
-     * ```ts
-     * new CommonPosition(CommonPosition.Positions.Center);
-     * new CommonPosition("center");
-     * ```
-     */
-    constructor(position: CommonPositionType);
-    toCSS(): D2Position;
-}
-export declare class Coord2D implements IPosition {
-    static isCoord2DPosition(arg: any): arg is Coord2D;
-    static fromCommonPosition(position: CommonPosition): Coord2D;
-    static fromAlignPosition(position: Partial<AlignPosition>): Coord2D;
-    static merge(a: Coord2D, b: Coord2D): Coord2D;
-    readonly x: UnknownAble<Coord2DPosition["x"]>;
-    readonly y: UnknownAble<Coord2DPosition["y"]>;
-    readonly xoffset: UnknownAble<number>;
-    readonly yoffset: UnknownAble<number>;
-    /**
-     * Create a new Coord2D instance
-     * @example
-     * ```ts
-     * new Coord2D("50%", "50%");
-     * new Coord2D({x: 1280, y: "50%"});
-     * new Coord2D({x: 1280, y: "-50%", xoffset: 10, yoffset: 20});
-     * ```
-     */
-    constructor(arg0: {
-        x?: UnknownAble<Coord2DPosition["x"]>;
-        y?: UnknownAble<Coord2DPosition["y"]>;
-        xoffset?: UnknownAble<number>;
-        yoffset?: UnknownAble<number>;
-    });
-    constructor(x: UnknownAble<Coord2DPosition["x"]>, y: UnknownAble<Coord2DPosition["y"]>);
-    check(): void;
-    toCSS(): D2Position<Coord2DPosition["x"], Coord2DPosition["y"]>;
-}
-export declare class Align implements IPosition {
-    static isAlignPosition(arg: any): arg is AlignPosition;
-    readonly xalign: UnknownAble<number>;
-    readonly yalign: UnknownAble<number>;
-    readonly xoffset: UnknownAble<number>;
-    readonly yoffset: UnknownAble<number>;
-    /**
-     * Create a new Align instance
-     * @example
-     * ```ts
-     * new Align(0.5, 0.5);
-     * new Align({xalign: 0.25, yalign: 0.5});
-     * new Align({xalign: 0.25, yalign: 0.5, xoffset: 10, yoffset: 20});
-     * ```
-     */
-    constructor(xalign?: UnknownAble<number>, yalign?: UnknownAble<number>);
-    constructor(arg0: {
-        xalign?: UnknownAble<number>;
-        yalign?: UnknownAble<number>;
-        xoffset?: UnknownAble<number>;
-        yoffset?: UnknownAble<number>;
-    });
-    check(): void;
-    toCSS(): D2Position;
-}
-export {};
+export declare enum CommonPositionType {
+    Left = "left",
+    Center = "center",
+    Right = "right"
+}
+export declare const CommonPositions: { [key in CommonPositionType]: `${number}%`; };
+export interface IPosition {
+    toCSS(): D2Position;
+}
+export type Coord2DPosition = {
+    x: number | `${"-" | ""}${number}%`;
+    y: number | `${"-" | ""}${number}%`;
+} & Partial<OffsetPosition>;
+export type AlignPosition = {
+    xalign: number;
+    yalign: number;
+} & Partial<OffsetPosition>;
+export type OffsetPosition = {
+    xoffset: number;
+    yoffset: number;
+};
+export type RawPosition = CommonPositionType | (Partial<Coord2DPosition> & {
+    xalign?: never;
+    yalign?: never;
+}) | (Partial<AlignPosition> & {
+    x?: never;
+    y?: never;
+});
+type Unknown = typeof PositionUtils.Unknown;
+type UnknownAble<T> = T | Unknown;
+export declare class CommonPosition implements IPosition {
+    static Positions: typeof CommonPositionType;
+    static isCommonPositionType(arg: any): arg is CommonPosition;
+    readonly position: CommonPositionType;
+    /**
+     * Create a new CommonPosition instance
+     * @example
+     * ```ts
+     * new CommonPosition(CommonPosition.Positions.Center);
+     * new CommonPosition("center");
+     * ```
+     */
+    constructor(position: CommonPositionType);
+    toCSS(): D2Position;
+}
+export declare class Coord2D implements IPosition {
+    static isCoord2DPosition(arg: any): arg is Coord2D;
+    static fromCommonPosition(position: CommonPosition): Coord2D;
+    static fromAlignPosition(position: Partial<AlignPosition>): Coord2D;
+    static merge(a: Coord2D, b: Coord2D): Coord2D;
+    readonly x: UnknownAble<Coord2DPosition["x"]>;
+    readonly y: UnknownAble<Coord2DPosition["y"]>;
+    readonly xoffset: UnknownAble<number>;
+    readonly yoffset: UnknownAble<number>;
+    /**
+     * Create a new Coord2D instance
+     * @example
+     * ```ts
+     * new Coord2D("50%", "50%");
+     * new Coord2D({x: 1280, y: "50%"});
+     * new Coord2D({x: 1280, y: "-50%", xoffset: 10, yoffset: 20});
+     * ```
+     */
+    constructor(arg0: {
+        x?: UnknownAble<Coord2DPosition["x"]>;
+        y?: UnknownAble<Coord2DPosition["y"]>;
+        xoffset?: UnknownAble<number>;
+        yoffset?: UnknownAble<number>;
+    });
+    constructor(x: UnknownAble<Coord2DPosition["x"]>, y: UnknownAble<Coord2DPosition["y"]>);
+    check(): void;
+    toCSS(): D2Position<Coord2DPosition["x"], Coord2DPosition["y"]>;
+}
+export declare class Align implements IPosition {
+    static isAlignPosition(arg: any): arg is AlignPosition;
+    readonly xalign: UnknownAble<number>;
+    readonly yalign: UnknownAble<number>;
+    readonly xoffset: UnknownAble<number>;
+    readonly yoffset: UnknownAble<number>;
+    /**
+     * Create a new Align instance
+     * @example
+     * ```ts
+     * new Align(0.5, 0.5);
+     * new Align({xalign: 0.25, yalign: 0.5});
+     * new Align({xalign: 0.25, yalign: 0.5, xoffset: 10, yoffset: 20});
+     * ```
+     */
+    constructor(xalign?: UnknownAble<number>, yalign?: UnknownAble<number>);
+    constructor(arg0: {
+        xalign?: UnknownAble<number>;
+        yalign?: UnknownAble<number>;
+        xoffset?: UnknownAble<number>;
+        yoffset?: UnknownAble<number>;
+    });
+    check(): void;
+    toCSS(): D2Position;
+}
+export {};

package/dist/game/nlcore/elements/transform/transform.d.ts

@@ -1,119 +1,119 @@
-import React from "react";
-import type { CommonDisplayableConfig } from "../../types";
-import type { DOMKeyframesDefinition } from "motion";
-import { TransformDefinitions } from "./type";
-import { CSSProps } from "../../elements/transition/type";
-export type Transformers = "position" | "opacity" | "scale" | "rotation" | "display" | "src" | "backgroundColor" | "backgroundOpacity" | "transform" | "fontColor";
-export type TransformHandler<T> = (value: T) => DOMKeyframesDefinition;
-type OverwriteMap = {
-    transform: React.CSSProperties["transform"];
-    scale: React.CSSProperties["scale"];
-    overwrite: CSSProps;
-};
-export type OverwriteDefinition = {
-    [K in keyof OverwriteMap]?: OverwriteHandler<OverwriteMap[K]>;
-};
-type OverwriteHandler<T> = (value: Partial<TransformDefinitions.Types>) => T;
-export declare class Transform<T extends TransformDefinitions.Types = CommonDisplayableConfig> {
-    /**
-     * Apply transform immediately
-     */
-    static immediate<T extends TransformDefinitions.Types>(props: TransformDefinitions.SequenceProps<T>): Transform<T>;
-    /**
-     * Go to the left side of the stage
-     */
-    static left(duration: number, easing?: TransformDefinitions.EasingDefinition): Transform<TransformDefinitions.ImageTransformProps>;
-    /**
-     * Go to the right side of the stage
-     */
-    static right(duration: number, easing?: TransformDefinitions.EasingDefinition): Transform<TransformDefinitions.ImageTransformProps>;
-    /**
-     * Go to the center of the stage
-     */
-    static center(duration: number, easing?: TransformDefinitions.EasingDefinition): Transform<TransformDefinitions.ImageTransformProps>;
-    /**
-     * Create a new transform with the given config. The sequences will be empty.
-     * @param config - The config for the transform.
-     * @returns A new transform with the given config.
-     */
-    static create<T extends TransformDefinitions.Types = CommonDisplayableConfig>(config?: Partial<TransformDefinitions.TransformConfig>): Transform<T>;
-    /**
-     * @example
-     * ```ts
-     * const transform = new Transform<ImageTransformProps>({
-     *   opacity: 1,
-     *   position: "center"
-     * }, {
-     *   duration: 0,
-     *   ease: "linear"
-     * });
-     * ```
-     */
-    constructor(sequences: TransformDefinitions.Sequence<T>[], transformConfig?: Partial<TransformDefinitions.TransformConfig>);
-    constructor(props: TransformDefinitions.SequenceProps<T>, options?: Partial<TransformDefinitions.CommonTransformProps>);
-    /**
-     * Create a new transform that repeats {@link n} x current repeat count times.
-     * @example
-     * ```ts
-     * transform
-     *   .repeat(2)
-     *   .repeat(3)
-     * // repeat 6 times
-     * ```
-     */
-    repeat(n: number): Transform<T>;
-    /**
-     * Copy the current transform.
-     * @returns {Transform<T>} A new transform with the same sequences and config.
-     */
-    copy(): Transform<T>;
-    /**
-     * Commits all staged changes to the transform sequence.
-     * This method will create a new sequence from all pending changes that have been staged via chained methods.
-     * If there are no staged changes, this method will return the current instance without modification.
-     * After committing, the staged changes array will be cleared.
-     * @returns {this} The current Transform i  nstance for method chaining
-     * @example
-     * ```ts
-     * transform
-     *   .position({ x: 100, y: 100 })
-     *   .opacity(1).commit() // will create a new sequence with opacity 1 and position x: 100, y: 100
-     *   .position({ x: 200, y: 200 })
-     *   .opacity(0).commit({ duration: 1000 }) // will create a new sequence with opacity 0 and position x: 200, y: 200 with a duration of 1 second
-     * ```
-     *
-     * **Note**: The staged changes will be committed before animation starts to ensure the latest changes are applied.
-     */
-    commit(options?: Partial<TransformDefinitions.SequenceOptions>): this;
-    /**
-     * Scale the current staging sequence.
-     * @param {number} scale - The scale of the transform.
-     * @returns {this} The current Transform instance for method chaining.
-     */
-    scale(scale: TransformDefinitions.Types["scale"]): this;
-    /**
-     * Rotate the current staging sequence.
-     * @param {number} rotation - The rotation of the transform.
-     * @returns {this} The current Transform instance for method chaining.
-     */
-    rotation(rotation: TransformDefinitions.Types["rotation"]): this;
-    /**
-     * Set the position of the current staging sequence.
-     * @param {number} position - The position of the transform.
-     * @returns {this} The current Transform instance for method chaining.
-     */
-    position(position: TransformDefinitions.Types["position"]): this;
-    /**
-     * Set the opacity of the current staging sequence.
-     * @param {number} opacity - The opacity of the transform.
-     * @returns {this} The current Transform instance for method chaining.
-     */
-    opacity(opacity: TransformDefinitions.Types["opacity"]): this;
-    /**
-     * Set the font color of the current staging sequence.
-     * @param {string} fontColor - The font color of the transform.
-     * @returns {this} The current Transform instance for method chaining.
-     */
-    fontColor(fontColor: TransformDefinitions.Types["fontColor"]): this;
-}
-export {};
+import React from "react";
+import type { CommonDisplayableConfig } from "../../types";
+import type { DOMKeyframesDefinition } from "motion";
+import { TransformDefinitions } from "./type";
+import { CSSProps } from "../../elements/transition/type";
+export type Transformers = "position" | "opacity" | "scale" | "rotation" | "display" | "src" | "backgroundColor" | "backgroundOpacity" | "transform" | "fontColor";
+export type TransformHandler<T> = (value: T) => DOMKeyframesDefinition;
+type OverwriteMap = {
+    transform: React.CSSProperties["transform"];
+    scale: React.CSSProperties["scale"];
+    overwrite: CSSProps;
+};
+export type OverwriteDefinition = {
+    [K in keyof OverwriteMap]?: OverwriteHandler<OverwriteMap[K]>;
+};
+type OverwriteHandler<T> = (value: Partial<TransformDefinitions.Types>) => T;
+export declare class Transform<T extends TransformDefinitions.Types = CommonDisplayableConfig> {
+    /**
+     * Apply transform immediately
+     */
+    static immediate<T extends TransformDefinitions.Types>(props: TransformDefinitions.SequenceProps<T>): Transform<T>;
+    /**
+     * Go to the left side of the stage
+     */
+    static left(duration: number, easing?: TransformDefinitions.EasingDefinition): Transform<TransformDefinitions.ImageTransformProps>;
+    /**
+     * Go to the right side of the stage
+     */
+    static right(duration: number, easing?: TransformDefinitions.EasingDefinition): Transform<TransformDefinitions.ImageTransformProps>;
+    /**
+     * Go to the center of the stage
+     */
+    static center(duration: number, easing?: TransformDefinitions.EasingDefinition): Transform<TransformDefinitions.ImageTransformProps>;
+    /**
+     * Create a new transform with the given config. The sequences will be empty.
+     * @param config - The config for the transform.
+     * @returns A new transform with the given config.
+     */
+    static create<T extends TransformDefinitions.Types = CommonDisplayableConfig>(config?: Partial<TransformDefinitions.TransformConfig>): Transform<T>;
+    /**
+     * @example
+     * ```ts
+     * const transform = new Transform<ImageTransformProps>({
+     *   opacity: 1,
+     *   position: "center"
+     * }, {
+     *   duration: 0,
+     *   ease: "linear"
+     * });
+     * ```
+     */
+    constructor(sequences: TransformDefinitions.Sequence<T>[], transformConfig?: Partial<TransformDefinitions.TransformConfig>);
+    constructor(props: TransformDefinitions.SequenceProps<T>, options?: Partial<TransformDefinitions.CommonTransformProps>);
+    /**
+     * Create a new transform that repeats {@link n} x current repeat count times.
+     * @example
+     * ```ts
+     * transform
+     *   .repeat(2)
+     *   .repeat(3)
+     * // repeat 6 times
+     * ```
+     */
+    repeat(n: number): Transform<T>;
+    /**
+     * Copy the current transform.
+     * @returns {Transform<T>} A new transform with the same sequences and config.
+     */
+    copy(): Transform<T>;
+    /**
+     * Commits all staged changes to the transform sequence.
+     * This method will create a new sequence from all pending changes that have been staged via chained methods.
+     * If there are no staged changes, this method will return the current instance without modification.
+     * After committing, the staged changes array will be cleared.
+     * @returns {this} The current Transform i  nstance for method chaining
+     * @example
+     * ```ts
+     * transform
+     *   .position({ x: 100, y: 100 })
+     *   .opacity(1).commit() // will create a new sequence with opacity 1 and position x: 100, y: 100
+     *   .position({ x: 200, y: 200 })
+     *   .opacity(0).commit({ duration: 1000 }) // will create a new sequence with opacity 0 and position x: 200, y: 200 with a duration of 1 second
+     * ```
+     *
+     * **Note**: The staged changes will be committed before animation starts to ensure the latest changes are applied.
+     */
+    commit(options?: Partial<TransformDefinitions.SequenceOptions>): this;
+    /**
+     * Scale the current staging sequence.
+     * @param {number} scale - The scale of the transform.
+     * @returns {this} The current Transform instance for method chaining.
+     */
+    scale(scale: TransformDefinitions.Types["scale"]): this;
+    /**
+     * Rotate the current staging sequence.
+     * @param {number} rotation - The rotation of the transform.
+     * @returns {this} The current Transform instance for method chaining.
+     */
+    rotation(rotation: TransformDefinitions.Types["rotation"]): this;
+    /**
+     * Set the position of the current staging sequence.
+     * @param {number} position - The position of the transform.
+     * @returns {this} The current Transform instance for method chaining.
+     */
+    position(position: TransformDefinitions.Types["position"]): this;
+    /**
+     * Set the opacity of the current staging sequence.
+     * @param {number} opacity - The opacity of the transform.
+     * @returns {this} The current Transform instance for method chaining.
+     */
+    opacity(opacity: TransformDefinitions.Types["opacity"]): this;
+    /**
+     * Set the font color of the current staging sequence.
+     * @param {string} fontColor - The font color of the transform.
+     * @returns {this} The current Transform instance for method chaining.
+     */
+    fontColor(fontColor: TransformDefinitions.Types["fontColor"]): this;
+}
+export {};