narraleaf-react 0.11.0 → 0.12.1

package/dist/game/nlcore/common/transition.d.ts

@@ -4,4 +4,17 @@ import { MaskTransition } from "../elements/transition/transitions/image/maskTra
 import { Transition } from "../elements/transition/transition";
 import { ImageTransition } from "../elements/transition/transitions/image/imageTransition";
 import { TextTransition } from "../elements/transition/transitions/text/textTransition";
-export { Transition, ImageTransition, TextTransition, Dissolve, FadeIn, MaskTransition, };
+import { SoftWipe } from "../elements/transition/transitions/image/softWipe";
+import { Blinds } from "../elements/transition/transitions/image/blinds";
+import { SoftIris } from "../elements/transition/transitions/image/softIris";
+import { BlurDissolve } from "../elements/transition/transitions/image/blurDissolve";
+import { Push } from "../elements/transition/transitions/image/push";
+import { ThroughColor } from "../elements/transition/transitions/image/throughColor";
+export { Transition, ImageTransition, TextTransition, Dissolve, FadeIn, MaskTransition, SoftWipe, Blinds, SoftIris, BlurDissolve, Push, ThroughColor, };
+export type { SoftWipeOptions } from "../elements/transition/transitions/image/softWipe";
+export type { BlindsOptions } from "../elements/transition/transitions/image/blinds";
+export type { SoftIrisOptions } from "../elements/transition/transitions/image/softIris";
+export type { BlurDissolveOptions } from "../elements/transition/transitions/image/blurDissolve";
+export type { PushOptions } from "../elements/transition/transitions/image/push";
+export type { ThroughColorFadeOptions, ThroughColorWipeOptions, ThroughColorBlindsOptions, ThroughColorIrisOptions, } from "../elements/transition/transitions/image/throughColor";
+export type { BlindsOrientation } from "../elements/transition/transitions/image/transitionMaskUtils";

package/dist/game/nlcore/elements/built-in/DevTools.d.ts

@@ -2,6 +2,7 @@ import { ControlAction } from "../../action/actions/controlAction";
 import { Chained, Proxied } from "../../action/chain";
 import { GameState } from "../../common/game";
 import { LogicAction } from "../../game";
+import { Layer } from "../layer";
 import { DynamicPersistent, Persistent } from "../persistent";
 import { Scene } from "../scene";
 export declare class DevTools {
@@ -13,5 +14,40 @@ export declare class DevTools {
     static wrapAction(action: LogicAction.Actions[] | Proxied<LogicAction.GameElement, Chained<LogicAction.Actions>>): ControlAction;
     static getNamespaceName(persistent: Persistent<any>): string;
     static getCurrentScene(gameState: GameState): Scene | null;
+    /**
+     * Register a displayable into a scene's render tree without emitting a `displayable:init`
+     * action. The element renders immediately at its constructor-config transform state
+     * (visibility is governed by `opacity > 0`).
+     *
+     * Intended for editor hosts that pre-pose a stage: construct elements with their computed
+     * state as constructor config (config state survives `element.reset()` / `newGame()`), then
+     * register them from a `Script` action or after mount.
+     */
+    static registerDisplayable(gameState: GameState, displayable: LogicAction.DisplayableElements, scene?: Scene | null, layer?: Layer | null): void;
+    /**
+     * Assign an explicit element id. Elements reachable from a scene's action tree receive
+     * generated ids (`e-0`, `e-1`, ...) at story construction, but elements registered directly
+     * via {@link registerDisplayable} are outside the tree and would otherwise share the default
+     * id — colliding as React keys. Editor hosts should give those elements unique ids
+     * (use a distinct prefix so they never collide with generated ids).
+     */
+    static setElementId(element: LogicAction.GameElement, id: string): void;
+    /**
+     * Read a displayable's current transform-state props (position/opacity/zoom/rotation/scale/
+     * effects...). Returns a shallow copy. Intended for editor hosts capturing a live pose
+     * (e.g. prefilling a motion editor with an element's current stage state).
+     */
+    static getDisplayableTransformProps(displayable: LogicAction.DisplayableElements): Record<string, unknown>;
+    /**
+     * Overwrite a displayable's transform-state props with no animation and push the result to
+     * the DOM immediately when the element is mounted. With `merge: false` the previous state is
+     * discarded entirely; by default the given props are merged over the current state.
+     *
+     * Throws if the transform state is locked by an in-flight transform — editor hosts should
+     * only inject while the stage is idle.
+     */
+    static setDisplayableTransformProps(gameState: GameState, displayable: LogicAction.DisplayableElements, props: Record<string, unknown>, options?: {
+        merge?: boolean;
+    }): void;
     static DynamicPersistent: typeof DynamicPersistent;
 }

package/dist/game/nlcore/elements/transition/transitions/image/blinds.d.ts

@@ -0,0 +1,28 @@
+import { TransitionAnimationType, TransitionTask } from "../../../../elements/transition/type";
+import { TransformDefinitions } from "../../../../elements/transform/type";
+import { ImageTransition } from "../../../../elements/transition/transitions/image/imageTransition";
+import { BlindsOrientation } from "../../../../elements/transition/transitions/image/transitionMaskUtils";
+type AnimationType = [TransitionAnimationType.Number];
+export type BlindsOptions = {
+    /** Duration in milliseconds. */
+    duration: number;
+    /** Slat orientation. @default "horizontal" */
+    orientation?: BlindsOrientation;
+    /** Number of slats. @default 8 */
+    slats?: number;
+    easing?: TransformDefinitions.EasingDefinition;
+};
+/**
+ * Venetian "blinds": the target image is revealed over the previous one through
+ * a set of hard-edged slats that widen until they cover the frame.
+ */
+export declare class Blinds extends ImageTransition<AnimationType> {
+    private duration;
+    private orientation;
+    private slats;
+    private easing?;
+    constructor(options: BlindsOptions);
+    createTask(): TransitionTask<HTMLImageElement, AnimationType>;
+    copy(): Blinds;
+}
+export {};

package/dist/game/nlcore/elements/transition/transitions/image/blurDissolve.d.ts

@@ -0,0 +1,24 @@
+import { TransitionAnimationType, TransitionTask } from "../../../../elements/transition/type";
+import { TransformDefinitions } from "../../../../elements/transform/type";
+import { ImageTransition } from "../../../../elements/transition/transitions/image/imageTransition";
+type AnimationType = [TransitionAnimationType.Number];
+export type BlurDissolveOptions = {
+    /** Duration in milliseconds. */
+    duration: number;
+    /** Peak blur radius applied at the crossover, in pixels. @default 16 */
+    blur?: number;
+    easing?: TransformDefinitions.EasingDefinition;
+};
+/**
+ * A blur dissolve: the previous image blurs out and fades while the target one
+ * sharpens in — the dreamy crossfade used for flashbacks / dream states.
+ */
+export declare class BlurDissolve extends ImageTransition<AnimationType> {
+    private duration;
+    private blur;
+    private easing?;
+    constructor(options: BlurDissolveOptions);
+    createTask(): TransitionTask<HTMLImageElement, AnimationType>;
+    copy(): BlurDissolve;
+}
+export {};

package/dist/game/nlcore/elements/transition/transitions/image/push.d.ts

@@ -0,0 +1,31 @@
+import { TransitionAnimationType, TransitionTask } from "../../../../elements/transition/type";
+import { TransformDefinitions } from "../../../../elements/transform/type";
+import { ImageTransition } from "../../../../elements/transition/transitions/image/imageTransition";
+type AnimationType = [TransitionAnimationType.Number];
+export type PushOptions = {
+    /** Duration in milliseconds. */
+    duration: number;
+    /** Direction the previous image travels toward. @default "left" */
+    direction?: TransformDefinitions.WipeDirection;
+    easing?: TransformDefinitions.EasingDefinition;
+};
+/**
+ * A push / slide: the target image slides in from one edge while the previous
+ * image slides out the opposite way, as if the camera panned.
+ *
+ * The offset is applied via the independent CSS `translate` property (not
+ * `transform`) in viewport units. That composes additively with the layer's
+ * base positioning instead of overriding it, and is the identity at offset `0`,
+ * so neither image jumps at the start/end of the slide.
+ */
+export declare class Push extends ImageTransition<AnimationType> {
+    private duration;
+    private direction;
+    private easing?;
+    constructor(options: PushOptions);
+    private axisUnit;
+    private translate;
+    createTask(): TransitionTask<HTMLImageElement, AnimationType>;
+    copy(): Push;
+}
+export {};

package/dist/game/nlcore/elements/transition/transitions/image/softIris.d.ts

@@ -0,0 +1,28 @@
+import { TransitionAnimationType, TransitionTask } from "../../../../elements/transition/type";
+import { TransformDefinitions } from "../../../../elements/transform/type";
+import { ImageTransition } from "../../../../elements/transition/transitions/image/imageTransition";
+type AnimationType = [TransitionAnimationType.Number];
+export type SoftIrisOptions = {
+    /** Duration in milliseconds. */
+    duration: number;
+    /** Centre of the iris, as a CSS position. @default "50% 50%" */
+    center?: string;
+    /** Width of the soft (feathered) edge band, in percent. @default 12 */
+    feather?: number;
+    easing?: TransformDefinitions.EasingDefinition;
+};
+/**
+ * A soft, feathered iris: the target image is revealed over the previous one
+ * through an expanding `radial-gradient` circle with a feathered edge — the
+ * soft-edged counterpart of {@link MaskTransition.circle}.
+ */
+export declare class SoftIris extends ImageTransition<AnimationType> {
+    private duration;
+    private center;
+    private feather;
+    private easing?;
+    constructor(options: SoftIrisOptions);
+    createTask(): TransitionTask<HTMLImageElement, AnimationType>;
+    copy(): SoftIris;
+}
+export {};

package/dist/game/nlcore/elements/transition/transitions/image/softWipe.d.ts

@@ -0,0 +1,28 @@
+import { TransitionAnimationType, TransitionTask } from "../../../../elements/transition/type";
+import { TransformDefinitions } from "../../../../elements/transform/type";
+import { ImageTransition } from "../../../../elements/transition/transitions/image/imageTransition";
+type AnimationType = [TransitionAnimationType.Number];
+export type SoftWipeOptions = {
+    /** Duration in milliseconds. */
+    duration: number;
+    /** Direction the wipe travels toward. @default "left" */
+    direction?: TransformDefinitions.WipeDirection;
+    /** Width of the soft (feathered) edge band, in percent. @default 12 */
+    feather?: number;
+    easing?: TransformDefinitions.EasingDefinition;
+};
+/**
+ * A soft, feathered directional wipe. The target image is revealed over the
+ * previous one through a moving `linear-gradient` alpha mask, giving a gradual
+ * erase rather than the hard geometric cut of {@link MaskTransition.wipe}.
+ */
+export declare class SoftWipe extends ImageTransition<AnimationType> {
+    private duration;
+    private direction;
+    private feather;
+    private easing?;
+    constructor(options: SoftWipeOptions);
+    createTask(): TransitionTask<HTMLImageElement, AnimationType>;
+    copy(): SoftWipe;
+}
+export {};

package/dist/game/nlcore/elements/transition/transitions/image/throughColor.d.ts

@@ -0,0 +1,67 @@
+import { TransitionAnimationType, TransitionTask } from "../../../../elements/transition/type";
+import { TransformDefinitions } from "../../../../elements/transform/type";
+import { ImageTransition } from "../../../../elements/transition/transitions/image/imageTransition";
+import { BlindsOrientation } from "../../../../elements/transition/transitions/image/transitionMaskUtils";
+type AnimationType = [TransitionAnimationType.Number];
+type ThroughColorBaseOptions = {
+    /** Duration in milliseconds. */
+    duration: number;
+    /** Hold colour. @default "#000000" */
+    color?: string;
+    /** Fraction (0–1) of the duration spent fully covered by the colour. @default 0.3 */
+    hold?: number;
+    easing?: TransformDefinitions.EasingDefinition;
+};
+export type ThroughColorFadeOptions = ThroughColorBaseOptions;
+export type ThroughColorWipeOptions = ThroughColorBaseOptions & {
+    /** Direction the feathered edge travels toward. @default "left" */
+    direction?: TransformDefinitions.WipeDirection;
+    /** Width of the soft edge band, in percent. @default 12 */
+    feather?: number;
+};
+export type ThroughColorBlindsOptions = ThroughColorBaseOptions & {
+    /** Slat orientation. @default "horizontal" */
+    orientation?: BlindsOrientation;
+    /** Number of slats. @default 8 */
+    slats?: number;
+};
+export type ThroughColorIrisOptions = ThroughColorBaseOptions & {
+    /** Centre of the iris, as a CSS position. @default "50% 50%" */
+    center?: string;
+    /** Width of the soft edge band, in percent. @default 12 */
+    feather?: number;
+};
+/**
+ * The "through colour" engine. A colour overlay covers the frame using the
+ * chosen pattern, holds a solid-colour frame, then uncovers to reveal the
+ * target image — so the target never appears until *after* the colour hold. The
+ * previous/target images simply swap opacity at the midpoint, unseen behind the
+ * fully-covered frame.
+ *
+ * Created through its static factories (mirroring {@link MaskTransition}):
+ * - {@link ThroughColor.fade}   — the overlay fades in/out (fade-to-black/white; `hold: 0` = flash).
+ * - {@link ThroughColor.wipe}   — a feathered directional edge (soft wipe through the colour).
+ * - {@link ThroughColor.blinds} — venetian slats (blinds through the colour).
+ * - {@link ThroughColor.iris}   — a circle closing from the rim in (iris to the colour).
+ */
+export declare class ThroughColor extends ImageTransition<AnimationType> {
+    private duration;
+    private color;
+    private hold;
+    private coverMask;
+    private easing?;
+    private constructor();
+    /** Fade the frame to a solid colour, hold, then fade to the target. */
+    static fade(options: ThroughColorFadeOptions): ThroughColor;
+    /** Cover the frame with a feathered directional edge, hold, then uncover. */
+    static wipe(options: ThroughColorWipeOptions): ThroughColor;
+    /** Cover the frame with venetian slats, hold, then uncover. */
+    static blinds(options: ThroughColorBlindsOptions): ThroughColor;
+    /** Close a circle over the frame from the rim in, hold, then open it. */
+    static iris(options: ThroughColorIrisOptions): ThroughColor;
+    /** Style for the colour overlay at a given coverage (0 = clear, 1 = fully covered). */
+    private coverStyle;
+    createTask(): TransitionTask<HTMLImageElement, AnimationType>;
+    copy(): ThroughColor;
+}
+export {};

package/dist/game/nlcore/elements/transition/transitions/image/transitionMaskUtils.d.ts

@@ -0,0 +1,30 @@
+import { CSSProps } from "../../../../elements/transition/type";
+import { TransformDefinitions } from "../../../../elements/transform/type";
+/**
+ * Shared, side-effect-free helpers for the mask/gradient driven image
+ * transitions ({@link SoftWipe}, {@link Blinds}, {@link SoftIris},
+ * {@link ThroughColor}). Kept internal — not exported from the package barrel.
+ */
+/** Orientation of {@link Blinds} slats / {@link ThroughColor} blinds pattern. */
+export type BlindsOrientation = "horizontal" | "vertical";
+/** Clamp a value into the `[0, 1]` range. */
+export declare function clamp01(value: number): number;
+/** The `mask-image` triplet, mirrored to the `-webkit-` prefix for WebKit. */
+export declare function maskStyle(image: string): CSSProps;
+/** Full-bleed positioning for a synthetic colour overlay layer. */
+export declare function overlayBase(color: string): CSSProps;
+/** CSS gradient direction keyword for a wipe travelling toward `direction`. */
+export declare function wipeGradientDir(direction: TransformDefinitions.WipeDirection): string;
+/** Gradient axis for blinds slats of a given orientation. */
+export declare function blindsAxis(orientation: BlindsOrientation): string;
+/**
+ * Feathered linear wipe mask. `progress` 0 → fully hidden, 1 → fully covered;
+ * the opaque edge sweeps with a soft transition band of width `feather` (%).
+ */
+export declare function linearWipeMask(direction: TransformDefinitions.WipeDirection, feather: number, progress: number): string;
+/** Venetian slats mask. `progress` 0 → open (hidden), 1 → shut (covered). */
+export declare function blindsCoverMask(orientation: BlindsOrientation, slats: number, progress: number): string;
+/** Iris that *covers* from the rim inward. `progress` 0 → hidden, 1 → covered. */
+export declare function irisCoverMask(center: string, feather: number, progress: number): string;
+/** Iris that *reveals* from the centre out. `progress` 0 → hidden, 1 → shown. */
+export declare function irisRevealMask(center: string, feather: number, progress: number): string;