@momoyu-ink/kit 0.4.2 → 0.5.1

package/dist/jsx-dev-runtime--ZXLAgUi.d.mts

@@ -0,0 +1,600 @@
+import 'react/jsx-runtime';
+import 'react/jsx-dev-runtime';
+import { ReactNode, ClassAttributes } from 'react';
+
+/**
+ * Settings for audio playback, including delay, start position, volume, etc.
+ */
+type AudioSettings = {
+    /**
+     * Optional delay time in seconds before the audio starts playing.
+     */
+    delayTime?: number;
+    /**
+     * The position in seconds where the audio should start playing.
+     */
+    startPosition?: number;
+    /**
+     * Whether the sound should be played in reverse.
+     */
+    reverse?: boolean;
+    /**
+     * Loop region defined by a start and end time in seconds. `-1` for end means loop to the end of the audio.
+     */
+    loopRegion?: [number, number];
+    /**
+     * Volume of the audio, ranges from 0.0 (silence) to 1.0 (normal volume),
+     * values greater than 1.0 can be used for amplification.
+     */
+    volume?: number;
+    /**
+     * Playback rate of the audio, where 1.0 is normal speed.
+     */
+    playbackRate?: number;
+    /**
+     * Panning value from -1.0 (left) to 1.0 (right), with 0.0 being center.
+     */
+    panning?: number;
+    /**
+     * Whether the audio should start playing automatically after loading.
+     */
+    autoPlay?: boolean;
+    /**
+     * Optional fade time in milliseconds for audio transitions.
+     */
+    fadeTime?: number;
+};
+
+type AudioCommand = {
+    subCommand: 'load';
+    name: string;
+    src: string;
+    settings?: AudioSettings;
+} | {
+    subCommand: 'release';
+    name: string;
+    fadeTime?: number;
+} | {
+    subCommand: 'play';
+    name: string;
+    fadeTime?: number;
+    waitForEnd?: boolean;
+} | {
+    subCommand: 'stop';
+    name: string;
+    fadeTime?: number;
+} | {
+    subCommand: 'pause';
+    name: string;
+    fadeTime?: number;
+} | {
+    subCommand: 'resume';
+    name: string;
+    fadeTime?: number;
+} | {
+    subCommand: 'setVolume';
+    name: string;
+    volume: number;
+    fadeTime?: number;
+} | {
+    subCommand: 'seekBy';
+    name: string;
+    time: number;
+} | {
+    subCommand: 'seekTo';
+    name: string;
+    time: number;
+} | {
+    subCommand: 'setPlaybackRate';
+    name: string;
+    rate: number;
+} | {
+    subCommand: 'setLoopRegion';
+    name: string;
+    start: number;
+    end: number;
+} | {
+    subCommand: 'setPanning';
+    name: string;
+    panning: number;
+};
+
+type EffectParams = {
+    duration: number;
+    startDelay: number;
+    weakMagnitude: number;
+    strongMagnitude: number;
+};
+
+type GamepadCommand = {
+    subCommand: 'getGamepads';
+} | {
+    subCommand: 'playEffect';
+    index: number;
+    effect: string;
+    params: EffectParams;
+};
+
+type JsonValue = number | string | boolean | Array<JsonValue> | {
+    [key in string]: JsonValue;
+} | null;
+
+type ScenarioCommand = {
+    subCommand: 'addStory';
+    name: string;
+} | {
+    subCommand: 'removeStory';
+    name: string;
+} | {
+    subCommand: 'hasStory';
+    name: string;
+} | {
+    subCommand: 'getStoryList';
+} | {
+    subCommand: 'startStory';
+    /**
+     * The name of the story to start
+     */
+    name: string;
+    /**
+     * The entry point to start from
+     */
+    entry?: string;
+} | {
+    subCommand: 'terminateStory';
+} | {
+    subCommand: 'nextLine';
+} | {
+    subCommand: 'setWaiting';
+    /**
+     * waiting time in milliseconds
+     * use f64 to avoid conversion issues with JavaScript numbers
+     */
+    time: number;
+    /**
+     * whether the waiting can be skipped by user input
+     */
+    skippable: boolean;
+} | {
+    subCommand: 'setVariable';
+    name: string;
+    value: JsonValue;
+} | {
+    subCommand: 'getVariable';
+    name: string;
+} | {
+    subCommand: 'setVariables';
+    variables: {
+        [key in string]: JsonValue;
+    };
+} | {
+    subCommand: 'getVariables';
+} | {
+    subCommand: 'setPermanentVariable';
+    key: string;
+    value: JsonValue;
+} | {
+    subCommand: 'getPermanentVariable';
+    key: string;
+} | {
+    subCommand: 'setPermanentVariables';
+    variables: {
+        [key in string]: JsonValue;
+    };
+} | {
+    subCommand: 'getPermanentVariables';
+} | {
+    subCommand: 'clearPermanentVariables';
+} | {
+    subCommand: 'saveGame';
+    name: string;
+    extra?: JsonValue;
+} | {
+    subCommand: 'record';
+    meta: {
+        [key in string]: JsonValue;
+    };
+} | {
+    subCommand: 'getRecords';
+    offset?: number;
+    limit?: number;
+} | {
+    subCommand: 'jumpToRecord';
+    recordId: string;
+} | {
+    subCommand: 'loadGame';
+    name: string;
+    /**
+     * if true, will overwrite the current game session with the loaded one,
+     * otherwise an error will be returned if the current session is not empty
+     */
+    overwrite: boolean;
+} | {
+    subCommand: 'resetGame';
+} | {
+    subCommand: 'removeGame';
+    name: string;
+} | {
+    subCommand: 'getGameList';
+    /**
+     * matches the name of the game session
+     */
+    pattern?: string;
+};
+
+type WindowState = 'idle' | 'maximized' | 'minimized' | 'fullscreen';
+
+type SystemCommand = {
+    subCommand: 'setWindowSize';
+    width: number;
+    height: number;
+    factor?: number;
+} | {
+    subCommand: 'setWindowState';
+    state: WindowState;
+} | {
+    subCommand: 'setTitle';
+    title: string;
+} | {
+    subCommand: 'getWindowState';
+} | {
+    subCommand: 'getWindowInnerPosition';
+} | {
+    subCommand: 'getWindowInnerSize';
+} | {
+    subCommand: 'getStageSize';
+} | {
+    subCommand: 'takeSnapshot';
+    width?: number;
+    height?: number;
+    keepAspectRatio?: boolean;
+} | {
+    subCommand: 'getParams';
+} | {
+    subCommand: 'quit';
+};
+
+type TextCommand = {
+    subCommand: 'setText';
+    text: string;
+    instant?: boolean;
+} | {
+    subCommand: 'finishPrinting';
+} | {
+    subCommand: 'getCursorPosition';
+};
+
+declare function getStageSize(): {
+    width: number;
+    height: number;
+    scaleFactor: number;
+};
+type MakeNullOptional<T> = T extends any ? {
+    [K in keyof T as null extends T[K] ? never : K]: T[K];
+} & {
+    [K in keyof T as null extends T[K] ? K : never]?: T[K];
+} : never;
+
+type _Command = AudioCommand | TextCommand | GamepadCommand | ScenarioCommand | SystemCommand;
+type Command = MakeNullOptional<_Command>;
+type MaybePromise = any;
+
+interface MoyuEvent<T extends Record<string, unknown> = Record<string, unknown>> {
+    name: string;
+    body: T;
+}
+interface BubbleEvent {
+    targetId: number;
+    bubbleTargetIds: number[];
+    currentTargetId: number;
+    stopPropagation: () => void;
+    preventDefault: () => void;
+    defaultPrevented: boolean;
+    bubbles: boolean;
+}
+declare function createBubbleEvent<T extends BubbleEvent>(body: Record<string, any> & {
+    bubbleTargetIds: number[];
+}, targetId: number): T;
+
+declare class Node {
+    nodeId: number;
+    label?: string;
+    props: Record<string, any>;
+    listeners: Record<string, (evt?: BubbleEvent | Record<string, any>) => any>;
+    static create(label: string, type: string, props: Record<string, any>): Node;
+    static rootNode(): Node;
+    addChild(child: Node): void;
+    insertChild(_index: number, child: Node): void;
+    insertChildBefore(beforeChild: Node, child: Node): void;
+    removeChild(child: Node): void;
+    updateProps(props: Record<string, any>): void;
+    executeCommand(payload: Command): any;
+}
+
+type KeyboardEventKind = 'KeyDown' | 'KeyUp' | 'KeyPress';
+
+/**
+ * KeyboardEvent objects describe a user interaction with the keyboard; each event describes a single interaction between the user and a key (or combination of a key with modifier keys) on the keyboard.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/KeyboardEvent)
+ */
+interface KeyboardEvent extends BubbleEvent {
+    readonly kind: KeyboardEventKind;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/KeyboardEvent/altKey) */
+    readonly altKey: boolean;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/KeyboardEvent/code) */
+    readonly code: string;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/KeyboardEvent/ctrlKey) */
+    readonly ctrlKey: boolean;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/KeyboardEvent/isComposing) */
+    readonly isComposing: boolean;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/KeyboardEvent/key) */
+    readonly key: string;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/KeyboardEvent/location) */
+    readonly location: number;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/KeyboardEvent/metaKey) */
+    readonly metaKey: boolean;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/KeyboardEvent/repeat) */
+    readonly repeat: boolean;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/KeyboardEvent/shiftKey) */
+    readonly shiftKey: boolean;
+    /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/KeyboardEvent/getModifierState)
+     *
+     * Not implemented yet
+     */
+    getModifierState(keyArg: string): boolean;
+    readonly DOM_KEY_LOCATION_STANDARD: 0x00;
+    readonly DOM_KEY_LOCATION_LEFT: 0x01;
+    readonly DOM_KEY_LOCATION_RIGHT: 0x02;
+    readonly DOM_KEY_LOCATION_NUMPAD: 0x03;
+}
+
+type MouseEventKind = 'MouseEnter' | 'MouseLeave' | 'MouseDown' | 'MouseUp' | 'MouseMove' | 'Click' | 'DoubleClick' | 'ContextMenu';
+
+interface MouseEvent extends BubbleEvent {
+    kind: MouseEventKind;
+    targetId: number;
+    currentTargetId: number;
+    targetLabel?: string;
+    currentTargetLabel?: string;
+    clientX: number;
+    clientY: number;
+    screenX: number;
+    screenY: number;
+    offsetX: number;
+    offsetY: number;
+}
+
+type TouchEventKind = 'TouchStart' | 'TouchMove' | 'TouchEnd' | 'TouchCancel';
+
+interface TouchEvent extends BubbleEvent {
+    kind: TouchEventKind;
+    targetId: number;
+    currentTargetId: number;
+    targetLabel: string;
+    currentTargetLabel: string;
+    clientX: number;
+    clientY: number;
+    screenX: number;
+    screenY: number;
+    offsetX: number;
+    offsetY: number;
+    identifier: number;
+}
+
+type MoyuCursor = 'hidden' | 'default' | 'context-menu' | 'help' | 'pointer' | 'progress' | 'wait' | 'cell' | 'crosshair' | 'text' | 'vertical-text' | 'alias' | 'copy' | 'move' | 'no-drop' | 'not-allowed' | 'grab' | 'grabbing' | 'e-resize' | 'n-resize' | 'ne-resize' | 'nw-resize' | 's-resize' | 'se-resize' | 'sw-resize' | 'w-resize' | 'ew-resize' | 'ns-resize' | 'nesw-resize' | 'nwse-resize' | 'col-resize' | 'row-resize' | 'all-scroll' | 'zoom-in' | 'zoom-out' | 'dnd-ask' | 'all-resize';
+
+type NodeProps = {
+    label?: string;
+    anchor?: [number, number];
+    pivot?: [number, number];
+    x?: number;
+    y?: number;
+    scale?: number;
+    scaleX?: number;
+    scaleY?: number;
+    rotation?: number;
+    skew?: number;
+    skewX?: number;
+    skewY?: number;
+    visible?: boolean;
+    tint?: string;
+    opacity?: number;
+    interactive?: boolean;
+    cursor?: MoyuCursor;
+};
+
+type ClipProps = {
+    width?: number;
+    height?: number;
+};
+
+/**
+ * 滤镜配置（可序列化，用于 JS 互操作）
+ */
+type FilterKind = {
+    type: 'blur-perfect';
+    radius: number;
+} | {
+    type: 'blur';
+    radius: number;
+    continuous?: boolean;
+} | {
+    type: 'brightness';
+    amount: number;
+} | {
+    type: 'contrast';
+    amount: number;
+} | {
+    type: 'saturation';
+    amount: number;
+} | {
+    type: 'hue-rotate';
+    degrees: number;
+} | {
+    type: 'grayscale';
+    amount: number;
+} | {
+    type: 'sepia';
+    amount: number;
+} | {
+    type: 'invert';
+    amount: number;
+} | {
+    type: 'unknown';
+};
+
+type FilterProps = {
+    filters?: Array<FilterKind>;
+};
+
+type BackdropProps = {
+    filters?: Array<FilterKind>;
+    width?: number;
+    height?: number;
+};
+
+type NineSliceMode = 'stretch' | 'repeat' | 'mirror' | 'blank';
+
+type SpriteMode = 'normal' | 'nineslice';
+
+type SpriteProps = {
+    src: string | null;
+    mode?: SpriteMode;
+    area?: [number, number, number, number];
+    bounds?: [number, number, number, number];
+    nineSliceMode?: NineSliceMode;
+    targetWidth?: number;
+    targetHeight?: number;
+};
+
+/**
+ * Text print mode
+ */
+type TextPrintMode = 'instant' | 'typewriter' | 'printer';
+
+/**
+ * To be compatible with react-spring inside JS runtime, we have to flatten the struct.
+ * FIXME: But `#[serde(flatten)]` works not quite well when there are more than one `#[serde(flatten)]` in a struct.
+ * So we do it manually.
+ */
+type TextProps = {
+    text?: string;
+    printMode?: TextPrintMode;
+    printSpeed?: number;
+    /**
+     * the writing direction of the text in the box,
+     * only `Horizontal` (right-to-left) or `Vertical` (top-to-bottom) is valid.
+     */
+    direction?: 'horizontal' | 'vertical';
+    /**
+     * the width of box.
+     */
+    boxWidth?: number;
+    /**
+     * the height of box.
+     */
+    boxHeight?: number;
+    /**
+     * the size of the glyph grid which each character be fit to, usually equals to `font_size`.
+     */
+    glyphGridSize?: number;
+    fontSize?: number;
+    fillColor?: string;
+    lineHeight?: number;
+    indent?: number;
+    stroke?: boolean;
+    shadow?: boolean;
+    strokeColor?: string;
+    strokeWidth?: number;
+    shadowColor?: string;
+    shadowOffsetX?: number;
+    shadowOffsetY?: number;
+    shadowBlur?: number;
+    shadowWidth?: number;
+};
+
+type AnimationFormat = 'apng' | 'webp';
+
+type AnimationProps = {
+    src: string | null;
+    area?: [number, number, number, number];
+    format?: AnimationFormat;
+};
+
+type VideoProps = {
+    src: string | null;
+    loop?: boolean;
+    autoPlay?: boolean;
+    volume?: number;
+    muted?: boolean;
+};
+
+type Tuple2 = [number, number];
+type Tuple3 = [number, number, number];
+type Tuple4 = [number, number, number, number];
+type DetailedMoyuProps<E extends MoyuNodeAttributes> = ClassAttributes<Node> & E;
+type MoyuEventHandler<T extends BubbleEvent> = (event: T) => void;
+interface MoyuListenerAttributes {
+    onClick?: MoyuEventHandler<MouseEvent>;
+    onMouseEnter?: MoyuEventHandler<MouseEvent>;
+    onMouseLeave?: MoyuEventHandler<MouseEvent>;
+    onMouseDown?: MoyuEventHandler<MouseEvent>;
+    onMouseUp?: MoyuEventHandler<MouseEvent>;
+    onMouseMove?: MoyuEventHandler<MouseEvent>;
+    onKeyDown?: MoyuEventHandler<KeyboardEvent>;
+    onKeyUp?: MoyuEventHandler<KeyboardEvent>;
+    onKeyPress?: MoyuEventHandler<KeyboardEvent>;
+    onTouchStart?: MoyuEventHandler<TouchEvent>;
+    onTouchMove?: MoyuEventHandler<TouchEvent>;
+    onTouchEnd?: MoyuEventHandler<TouchEvent>;
+    onTouchCancel?: MoyuEventHandler<TouchEvent>;
+}
+type MoyuNodeAttributes = MoyuListenerAttributes & NodeProps & {
+    children?: ReactNode;
+};
+type MoyuContainerAttributes = MoyuNodeAttributes;
+type MoyuClipAttributes = ClipProps & MoyuNodeAttributes;
+type MoyuFilterAttributes = FilterProps & MoyuNodeAttributes;
+type MoyuBackdropAttributes = BackdropProps & MoyuNodeAttributes;
+type MoyuAnimationAttributes = AnimationProps & MoyuNodeAttributes;
+type MoyuVideoAttributes = VideoProps & MoyuNodeAttributes & {
+    onEnded?: () => void;
+    onStateChange?: (state: string) => void;
+};
+type MoyuSpriteAttributes = SpriteProps & MoyuNodeAttributes;
+type MoyuTextAttributes = TextProps & MoyuNodeAttributes & {
+    onStart?: () => void;
+    onFinish?: () => void;
+    onProgress?: (progress: number) => void;
+};
+declare namespace JSX {
+    type ElementType = string | React.JSXElementConstructor<any>;
+    interface Element extends React.ReactElement<any, any> {
+    }
+    interface ElementClass extends React.Component<any> {
+        render(): React.ReactNode;
+    }
+    interface ElementAttributesProperty {
+        props: {};
+    }
+    interface ElementChildrenAttribute {
+        children: {};
+    }
+    interface IntrinsicAttributes extends React.Attributes {
+    }
+    interface IntrinsicClassAttributes<T> extends React.ClassAttributes<T> {
+    }
+    interface IntrinsicElements {
+        container: DetailedMoyuProps<MoyuContainerAttributes>;
+        sprite: DetailedMoyuProps<MoyuSpriteAttributes>;
+        text: DetailedMoyuProps<MoyuTextAttributes>;
+        clip: DetailedMoyuProps<MoyuClipAttributes>;
+        filter: DetailedMoyuProps<MoyuFilterAttributes>;
+        backdrop: DetailedMoyuProps<MoyuBackdropAttributes>;
+        animation: DetailedMoyuProps<MoyuAnimationAttributes>;
+        video: DetailedMoyuProps<MoyuVideoAttributes>;
+    }
+}
+
+export { type AudioCommand as A, type BubbleEvent as B, type Command as C, type DetailedMoyuProps as D, type EffectParams as E, type GamepadCommand as G, JSX as J, type KeyboardEvent as K, type MouseEvent as M, Node as N, type ScenarioCommand as S, type TextCommand as T, type WindowState as W, type MoyuEvent as a, type MaybePromise as b, type AudioSettings as c, type KeyboardEventKind as d, type MakeNullOptional as e, type MouseEventKind as f, type MoyuAnimationAttributes as g, type MoyuBackdropAttributes as h, type MoyuClipAttributes as i, type MoyuContainerAttributes as j, type MoyuEventHandler as k, type MoyuFilterAttributes as l, type MoyuListenerAttributes as m, type MoyuNodeAttributes as n, type MoyuSpriteAttributes as o, type MoyuTextAttributes as p, type MoyuVideoAttributes as q, type SystemCommand as r, type TouchEvent as s, type TouchEventKind as t, type Tuple2 as u, type Tuple3 as v, type Tuple4 as w, createBubbleEvent as x, getStageSize as y };