narraleaf-react 0.2.2 → 0.2.3

package/dist/game/nlcore/action/actions/controlAction.d.ts

@@ -23,7 +23,7 @@ export declare class ControlAction<T extends typeof ControlActionTypes[keyof typ
      * will wait for awaitable actions to resolve
      */
     executeAllActions(state: GameState, action: LogicAction.Actions): Promise<void>;
-    executeSingleAction(state: GameState, action: LogicAction.Actions): Promise<TypedAction<Record<string, any>, string, LogicAction.GameElement> | import("./menuAction").MenuAction<"menu:action"> | ControlAction<"control:action" | "control:do" | "control:doAsync" | "control:any" | "control:all" | "control:allAsync" | "control:repeat" | "control:sleep"> | ContentNode<any> | null>;
+    executeSingleAction(state: GameState, action: LogicAction.Actions): Promise<ContentNode | null>;
     execute(state: GameState, awaitable: Awaitable<any, any>, content: LogicAction.Actions[]): {
         type: any;
         node: ContentNode<any> | null;

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

@@ -1,8 +1,4 @@
-import type { Background, color, HexColor, ImageColor, ImageSrc, NextJSStaticImageData } from "../types";
-import type { Scene } from "../elements/scene";
-import type { Image } from "../elements/displayable/image";
-import { Action } from "../action/action";
-import { Story } from "../elements/story";
+import type { HexColor, ImageColor } from "../types";
 export declare class RGBColor {
     static isHexString(color: any): color is HexColor;
     static fromHex(hex: HexColor): RGBColor;
@@ -15,49 +11,3 @@ export declare class RGBColor {
     toHex(): string;
     toImageColor(): ImageColor;
 }
-export declare class Utils {
-    static RGBColor: typeof RGBColor;
-    static srcToString(src: string | NextJSStaticImageData): string;
-    static staticImageDataToSrc(image: NextJSStaticImageData | string): string;
-    static isStaticImageData(src: any): src is NextJSStaticImageData;
-    static backgroundToSrc(background: Background["background"]): string | null;
-    static isExternalSrc(src: string): boolean;
-    static isImageSrc(src: any): src is ImageSrc;
-    static isImageColor(color: any): color is ImageColor;
-    static isPlainColor(color: any): color is color;
-    static isHexString(color: any): color is HexColor;
-    static toBackgroundSrc(src: ImageSrc): string;
-    static toHex(color: ImageColor): HexColor;
-}
-export declare class UseError<T = Record<string, any>> extends Error {
-    static isUseError(error: any): error is UseError;
-    props: T;
-    constructor(message: string, props: T, name?: string);
-}
-export declare class StaticScriptWarning extends UseError<{
-    stack?: string;
-    info?: any;
-}> {
-    static isWarning(error: any): error is StaticScriptWarning;
-    constructor(message: string, info?: any);
-}
-type ImageState = {
-    isDisposed: boolean;
-    usedExternalSrc: boolean;
-};
-export declare class StaticChecker {
-    private readonly scene;
-    constructor(target: Scene);
-    run(story: Story): Map<Image<import("../elements/displayable/image").TagGroupDefinition | null>, ImageState> | null;
-    private checkAction;
-    private checkImage;
-}
-export declare class RuntimeScriptError extends Error {
-    static toMessage(msg: string | string[], trace?: Action | Action[]): string;
-    static getActionTrace(action: Action): string;
-    constructor(message: string | string[], trace?: Action | Action[]);
-}
-export declare class RuntimeGameError extends Error {
-    constructor(message: string);
-}
-export {};

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

@@ -24,4 +24,5 @@ interface ImageConstructor {
     } : never)): ImageClass<T>;
 }
 declare const Image: ImageConstructor;
-export { Character, Condition, Control, Image, Lambda, Menu, Scene, Script, Sentence, Sound, SoundType, Story, Transform, Word, Text, Pause, Persistent, };
+declare const AbstractImage: typeof ImageClass;
+export { Character, Condition, Control, Image, Lambda, Menu, Scene, Script, Sentence, Sound, SoundType, Story, Transform, Word, Text, Pause, Persistent, AbstractImage, };

package/dist/game/nlcore/elements/character/pause.d.ts

@@ -1,7 +1,6 @@
 export type PauseConfig = {
     duration?: number;
 };
-export type PausingShortcut = typeof Pause;
 export type Pausing = Pause | PausingShortcut;
 export declare class Pause {
     static wait(duration: number): Pause;

package/dist/game/nlcore/elements/character/sentence.d.ts

@@ -1,29 +1,7 @@
 import { Sound } from "../../elements/sound";
-import type { Character } from "../../elements/character";
-import { Word } from "../../elements/character/word";
-import { Color, Font } from "../../types";
-import type { ScriptCtx } from "../../elements/script";
-import { Pausing } from "../../elements/character/pause";
-export type SentenceConfig = {
-    pause?: boolean | number;
-    voice: Sound | null;
-    character: Character | null;
-    voiceId: string | number | null;
-} & Color & Font;
-export type SentenceDataRaw = {
-    state: SentenceState;
-};
-export type SentenceState = {
-    display: boolean;
-};
 export type SentenceUserConfig = Partial<Omit<SentenceConfig, "voice"> & {
     voice: Sound | string | null | undefined;
 }>;
-export type DynamicWord = (ctx: ScriptCtx) => DynamicWordResult;
-export type DynamicWordResult = string | Word | Pausing | (string | Word | Pausing)[];
-export type StaticWord<T extends string | DynamicWord | Pausing = string | DynamicWord | Pausing> = string | Pausing | Word<T>;
-export type SingleWord = StaticWord | DynamicWord;
-export type SentencePrompt = SingleWord[] | SingleWord;
 export declare class Sentence {
     constructor(text: SentencePrompt, config?: SentenceUserConfig);
     copy(): Sentence;

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

@@ -5,12 +5,6 @@ import { Actionable } from "../action/actionable";
 import { Chained, Proxied } from "../action/chain";
 import { Sentence, SentencePrompt, SentenceUserConfig, SingleWord } from "../elements/character/sentence";
 export type CharacterConfig = {} & Color;
-export type CharacterStateData = {
-    name: string;
-};
-export type CharacterState = {
-    name: string;
-};
 export declare class Character extends Actionable<CharacterStateData, Character> {
     constructor(name: string | null, config?: DeepPartial<CharacterConfig>);
     /**

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

@@ -4,19 +4,6 @@ import { Chained, ChainedActions, Proxied } from "../action/chain";
 import { LambdaHandler } from "../elements/type";
 export declare class Lambda<T = any> {
 }
-export type ConditionData = {
-    If: {
-        condition: Lambda | null;
-        action: LogicAction.Actions[] | null;
-    };
-    ElseIf: {
-        condition: Lambda | null;
-        action: (LogicAction.Actions[]) | null;
-    }[];
-    Else: {
-        action: (LogicAction.Actions[]) | null;
-    };
-};
 export declare class Condition<Closed extends true | false = false> extends Actionable {
     /**
      * @chainable

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

@@ -1,8 +1,6 @@
 import { Actionable } from "../action/actionable";
-import { LogicAction } from "../action/logicAction";
 import { Awaitable } from "../../../util/data";
-import { Chained, ChainedActions, Proxied } from "../action/chain";
-type ChainedControl = Proxied<Control, Chained<LogicAction.Actions>>;
+import { ChainedActions } from "../action/chain";
 export declare class Control extends Actionable {
     /**
      * Execute actions in order, waiting for each action to complete
@@ -76,4 +74,3 @@ export declare class Control extends Actionable {
      */
     sleep(duration: number | Awaitable<any> | Promise<any>): ChainedControl;
 }
-export {};

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

@@ -1,38 +1 @@
-import { Actionable } from "../../action/actionable";
-import { EventfulDisplayable } from "../../types";
-import { Transform } from "../../elements/transform/transform";
-import { Values } from "../../../../util/data";
-import { ITransition } from "../../elements/transition/type";
-import { DisplayableAction } from "../../action/actions/displayableAction";
-import { DisplayableActionTypes } from "../../action/actionTypes";
-import { Chained, Proxied } from "../../action/chain";
-import { LogicAction } from "../../action/logicAction";
-export type DisplayableEventTypes = {
-    "event:displayable.applyTransition": [ITransition];
-    "event:displayable.applyTransform": [Transform];
-    "event:displayable.init": [];
-};
-export declare abstract class Displayable<StateData extends Record<string, any>, Self extends Actionable> extends Actionable<StateData, Self> implements EventfulDisplayable {
-    abstract toDisplayableTransform(): Transform;
-    /**
-     * Move the layer up
-     * @chainable
-     */
-    layerMoveUp(): Proxied<Self, Chained<LogicAction.Actions>>;
-    /**
-     * Move the layer down
-     * @chainable
-     */
-    layerMoveDown(): Proxied<Self, Chained<LogicAction.Actions>>;
-    /**
-     * Move the layer to the top
-     * @chainable
-     */
-    layerMoveTop(): Proxied<Self, Chained<LogicAction.Actions>>;
-    /**
-     * Move the layer to the bottom
-     * @chainable
-     */
-    layerMoveBottom(): Proxied<Self, Chained<LogicAction.Actions>>;
-    protected constructLayerAction<T extends Values<typeof DisplayableActionTypes>>(chain: Proxied<Self, Chained<LogicAction.Actions>>, type: T): DisplayableAction;
-}
+export {};

package/dist/game/nlcore/elements/displayable/image.d.ts

@@ -1,33 +1,15 @@
 import type { TransformDefinitions } from "../../elements/transform/type";
 import { Transform } from "../transform/transform";
-import { CommonDisplayable, EventfulDisplayable, StaticImageData } from "../../types";
+import { EventfulDisplayable, StaticImageData } from "../../types";
 import { LogicAction } from "../../game";
 import { IImageTransition } from "../../elements/transition/type";
 import { FlexibleTuple, SelectElementFromEach } from "../../../../util/data";
 import { Chained, Proxied } from "../../action/chain";
-import { Displayable, DisplayableEventTypes } from "../../elements/displayable/displayable";
-export type ImageConfig = {
-    display: boolean;
-    wearables: Image[];
-    isWearable?: boolean;
-    name?: string;
-    /**
-     * If set to false, the image won't be initialized unless you call `init` method
-     */
-    autoInit: boolean;
-} & CommonDisplayable;
-export type ImageDataRaw = {
-    state: Record<string, any>;
-};
-export type ImageEventTypes = {
-    "event:wearable.create": [Image];
-} & DisplayableEventTypes;
+import { Displayable } from "../../elements/displayable/displayable";
 export type TagDefinitions<T extends TagGroupDefinition | null> = T extends TagGroupDefinition ? {
     groups: T;
     defaults: SelectElementFromEach<T>;
 } : never;
-export type TagGroupDefinition = string[][];
-export type TagSrcResolver<T extends TagGroupDefinition> = (...tags: SelectElementFromEach<T>) => string;
 export type RichImageUserConfig<T extends TagGroupDefinition | null> = ImageConfig & {} & (T extends null ? {
     src: string | StaticImageData;
     tag?: never;
@@ -35,8 +17,6 @@ export type RichImageUserConfig<T extends TagGroupDefinition | null> = ImageConf
     src: TagSrcResolver<T>;
     tag: TagDefinitions<T>;
 } : never);
-export type RichImageConfig<T extends TagGroupDefinition | null> = RichImageUserConfig<T> & {};
-export type StaticRichConfig = RichImageUserConfig<TagGroupDefinition | null>;
 export declare class Image<Tags extends TagGroupDefinition | null = TagGroupDefinition | null> extends Displayable<ImageDataRaw, Image> implements EventfulDisplayable {
     constructor(config?: Partial<RichImageUserConfig<Tags>>, tagDefinition?: TagDefinitions<Tags>);
     /**
@@ -125,6 +105,16 @@ export declare class Image<Tags extends TagGroupDefinition | null = TagGroupDefi
     hide(): Proxied<Image, Chained<LogicAction.Actions>>;
     hide(transform: Transform<TransformDefinitions.ImageTransformProps>): Proxied<Image, Chained<LogicAction.Actions>>;
     hide(transform: Partial<TransformDefinitions.CommonTransformProps>): Proxied<Image, Chained<LogicAction.Actions>>;
+    /**
+     * Alia of {@link Image.setAppearance}
+     * @chainable
+     */
+    setTags(tags: Tags extends TagGroupDefinition ? FlexibleTuple<SelectElementFromEach<Tags>> : string[], transition?: IImageTransition): Proxied<Image, Chained<LogicAction.Actions>>;
+    /**
+     * Set Image Position
+     * @chainable
+     */
+    setPosition(position: TransformDefinitions.ImageTransformProps["position"], duration?: number, easing?: TransformDefinitions.EasingDefinition): Proxied<Image, Chained<LogicAction.Actions>>;
     /**
      * Add a wearable to the image
      * @param children - Wearable image or images

package/dist/game/nlcore/elements/displayable/text.d.ts

@@ -5,7 +5,6 @@ import { LogicAction } from "../../action/logicAction";
 import { Transform } from "../../elements/transform/transform";
 import type { TransformDefinitions } from "../../elements/transform/type";
 import { ITextTransition } from "../../elements/transition/type";
-import { DisplayableEventTypes } from "../../elements/displayable/displayable";
 export type TextConfig = {
     alignX: "left" | "center" | "right";
     alignY: "top" | "center" | "bottom";
@@ -15,13 +14,6 @@ export type TextConfig = {
     display: boolean;
     text: string;
 } & CommonDisplayable;
-export type TextDataRaw = {
-    state: Record<string, any>;
-};
-export type TextEventTypes = {
-    "event:text.show": [Transform];
-    "event:text.hide": [Transform];
-} & DisplayableEventTypes;
 export declare class Text extends Actionable<TextDataRaw, Text> implements EventfulDisplayable {
     constructor(config: Partial<TextConfig>);
     constructor(text: string, config?: Partial<TextConfig>);

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

@@ -3,14 +3,11 @@ import { Actionable } from "../action/actionable";
 import { Chained, Proxied } from "../action/chain";
 import { Sentence, SentencePrompt } from "../elements/character/sentence";
 import Actions = LogicAction.Actions;
-import GameElement = LogicAction.GameElement;
 export type MenuConfig = {};
 export type MenuChoice = {
     action: ChainedActions;
     prompt: SentencePrompt | Sentence;
 };
-type ChainedAction = Proxied<GameElement, Chained<LogicAction.Actions>>;
-type ChainedActions = (ChainedAction | ChainedAction[] | Actions | Actions[])[];
 export type Choice = {
     action: Actions[];
     prompt: Sentence;
@@ -34,4 +31,3 @@ export declare class Menu extends Actionable<any, Menu> {
     choose(prompt: Sentence, action: ChainedActions): Proxied<Menu, Chained<LogicAction.Actions>>;
     choose(prompt: SentencePrompt, action: ChainedActions): Proxied<Menu, Chained<LogicAction.Actions>>;
 }
-export {};

package/dist/game/nlcore/elements/persistent/type.d.ts

@@ -1,21 +1,3 @@
 export type StorableData<K extends string = string> = {
     [key in K]: number | boolean | string | StorableData | StorableData[] | undefined | null | Date;
 };
-export type BaseStorableType = number | boolean | string | undefined | null | Date;
-export type UnserializableStorableType = Date;
-export type BaseStorableTypeName = "any" | "date";
-export type StorableType = BaseStorableType | Record<string, BaseStorableType> | Array<BaseStorableType>;
-export type WrappedStorableData<T extends StorableType = any> = {
-    type: BaseStorableTypeName;
-    data: T;
-};
-export type StorableTypeSerializer<T, U extends StorableType = any> = (value: T) => WrappedStorableData<U>;
-export type BaseStorableSerializeHandlers = {
-    [K in BaseStorableTypeName]: K extends "any" ? StorableTypeSerializer<Exclude<BaseStorableType, UnserializableStorableType>> : K extends "date" ? StorableTypeSerializer<Date> : never;
-};
-export type BaseStorableDeserializeHandlers = {
-    [K in BaseStorableTypeName]: K extends "any" ? (data: WrappedStorableData<Exclude<BaseStorableType, UnserializableStorableType>>) => Exclude<BaseStorableType, UnserializableStorableType> : K extends "date" ? (data: WrappedStorableData<Date>) => Date : never;
-};
-export type NameSpaceContent<T extends string | number | symbol> = {
-    [K in T]?: StorableType;
-};

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

@@ -1,19 +1,9 @@
 import { Actionable } from "../action/actionable";
-import { StorableType } from "../elements/persistent/type";
-import { Chained, Proxied } from "../action/chain";
-import { LogicAction } from "../game";
-import { BooleanKeys, StringKeyOf } from "../../../util/data";
+import { BooleanValueKeyOf, StringKeyOf } from "../../../util/data";
 import { Lambda } from "../elements/condition";
 import { Word } from "../elements/character/word";
 import { DynamicWord, DynamicWordResult } from "../elements/character/sentence";
 import { LambdaHandler } from "../elements/type";
-type PersistentContent = {
-    [K in string]: StorableType;
-};
-type ChainedPersistent<T extends PersistentContent> = Proxied<Persistent<T>, Chained<LogicAction.Actions>>;
-type DynamicPersistentData = {
-    [K in string]: StorableType;
-};
 export declare class Persistent<T extends PersistentContent> extends Actionable<null> {
     constructor(namespace: string, defaultContent: T);
     /**
@@ -32,11 +22,11 @@ export declare class Persistent<T extends PersistentContent> extends Actionable<
     /**
      * Determine whether the value is true, can be used in {@link Condition}
      */
-    isTrue<K extends Extract<keyof T, BooleanKeys<T>>>(key: K): Lambda<boolean>;
+    isTrue<K extends Extract<keyof T, BooleanValueKeyOf<T>>>(key: K): Lambda<boolean>;
     /**
      * Determine whether the value is false, can be used in {@link Condition}
      */
-    isFalse<K extends Extract<keyof T, BooleanKeys<T>>>(key: K): Lambda<boolean>;
+    isFalse<K extends Extract<keyof T, BooleanValueKeyOf<T>>>(key: K): Lambda<boolean>;
     /**
      * Determine whether the value isn't null or undefined, can be used in {@link Condition}
      */
@@ -79,4 +69,3 @@ export declare class Persistent<T extends PersistentContent> extends Actionable<
  */
 export declare class DynamicPersistent extends Persistent<DynamicPersistentData> {
 }
-export {};

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

@@ -1,28 +1,14 @@
 import { Constructable } from "../action/constructable";
 import { Awaitable } from "../../../util/data";
-import { color, EventfulDisplayable, ImageColor, ImageSrc, StaticImageData } from "../types";
+import { EventfulDisplayable, ImageColor, ImageSrc } from "../types";
 import { LogicAction } from "../action/logicAction";
 import { Transform } from "../elements/transform/transform";
-import { IImageTransition, ITransition } from "../elements/transition/type";
-import { Sound, SoundDataRaw, VoiceIdMap, VoiceSrcGenerator } from "../elements/sound";
+import { IImageTransition } from "../elements/transition/type";
+import { Sound, VoiceIdMap, VoiceSrcGenerator } from "../elements/sound";
 import { TransformDefinitions } from "../elements/transform/type";
-import { ImageDataRaw, VirtualImageProxy } from "../elements/displayable/image";
 import { Persistent } from "../common/core";
-import { Chained, Proxied } from "../action/chain";
-import { RGBColor } from "../common/Utils";
 import Actions = LogicAction.Actions;
 import ImageTransformProps = TransformDefinitions.ImageTransformProps;
-import GameElement = LogicAction.GameElement;
-export type UserImageInput = ImageSrc | RGBColor | ImageColor;
-export type SceneConfig = {
-    invertY: boolean;
-    invertX: boolean;
-    backgroundMusic: Sound | null;
-    backgroundMusicFade: number;
-    voices: VoiceIdMap | VoiceSrcGenerator | null;
-} & {
-    background: ImageSrc | ImageColor | null;
-};
 export interface ISceneConfig {
     invertY: boolean;
     invertX: boolean;
@@ -31,35 +17,10 @@ export interface ISceneConfig {
     voices?: VoiceIdMap | VoiceSrcGenerator;
     background?: ImageSrc | ImageColor;
 }
-export type SceneState = {
-    backgroundImageProxy: VirtualImageProxy;
-};
 export type JumpConfig = {
     transition: IImageTransition;
     unloadScene: boolean;
 };
-type ChainableAction = Proxied<GameElement, Chained<LogicAction.Actions>> | Actions;
-type ChainedScene = Proxied<Scene, Chained<LogicAction.Actions>>;
-export type SceneDataRaw = {
-    state: {
-        backgroundMusic?: SoundDataRaw | null;
-        background?: color | StaticImageData | null;
-    };
-    backgroundImageState?: ImageDataRaw | null;
-};
-export type SceneEventTypes = {
-    "event:scene.remove": [];
-    "event:scene.load": [];
-    "event:scene.unload": [];
-    "event:scene.mount": [];
-    "event:scene.unmount": [];
-    "event:scene.preUnmount": [];
-    "event:scene.imageLoaded": [];
-    "event:scene.setBackgroundMusic": [Sound | null, number];
-    "event:displayable.applyTransition": [ITransition];
-    "event:displayable.applyTransform": [Transform];
-    "event:displayable.init": [];
-};
 export declare class Scene extends Constructable<Actions, Scene> implements EventfulDisplayable {
     readonly local: Persistent<any>;
     constructor(name: string, config?: Partial<ISceneConfig>);
@@ -127,4 +88,3 @@ export declare class Scene extends Constructable<Actions, Scene> implements Even
      */
     requestImagePreload(src: ImageSrc): void;
 }
-export {};

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

@@ -10,7 +10,6 @@ export interface ScriptCtx {
     storable: Storable;
 }
 type ScriptRun = (ctx: ScriptCtx) => ScriptCleaner | void;
-export type ScriptCleaner = () => void;
 export declare class Script extends Actionable<object> {
     constructor(handler: ScriptRun);
 }

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

@@ -9,11 +9,6 @@ export declare enum SoundType {
     voice = "voice",
     backgroundMusic = "backgroundMusic"
 }
-export type SoundDataRaw = {
-    config: SoundConfig;
-};
-export type VoiceIdMap = Record<string | number, string | Sound>;
-export type VoiceSrcGenerator = (id: string | number) => string | Sound;
 export type SoundConfig = {
     /**
      * Sound type

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

@@ -3,8 +3,6 @@ import { Scene } from "../elements/scene";
 import { SceneAction } from "../action/actions/sceneAction";
 import { Persistent } from "../elements/persistent";
 export type StoryConfig = {};
-export type ElementStateRaw = Record<string, any>;
-export type NodeChildIdMap = Map<string, string>;
 export declare class Story extends Constructable<SceneAction<"scene:action">, Story> {
     constructor(name: string, config?: StoryConfig);
     /**

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

@@ -1,4 +1,3 @@
-import { CSSProps } from "../../elements/transition/type";
 export declare enum CommonPositionType {
     Left = "left",
     Center = "center",
@@ -12,51 +11,8 @@ export declare const CommonPositions: {
 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 D2Position<X = any, Y = any> = {
-    x: UnknownAble<X>;
-    y: UnknownAble<Y>;
-    xoffset: UnknownAble<number>;
-    yoffset: UnknownAble<number>;
-};
-export type RawPosition = CommonPositionType | (Coord2DPosition & {
-    xalign?: never;
-    yalign?: never;
-}) | (AlignPosition & {
-    x?: never;
-    y?: never;
-});
-export type Unknown = typeof PositionUtils.Unknown;
-export type UnknownAble<T> = T | Unknown;
-export declare class PositionUtils {
-    static readonly Unknown: unique symbol;
-    static isUnknown(arg: any): arg is typeof PositionUtils.Unknown;
-    static wrap(def: CSSProps): CSSProps;
-    static D2PositionToCSS(pos: D2Position, invertX?: boolean, invertY?: boolean): CSSProps;
-    static calc(pos: number | string, offset?: UnknownAble<number>): string;
-    static toCoord2D(pos: IPosition | D2Position): Coord2D;
-    static orUnknown<T>(arg: T | UnknownAble<T> | undefined): T | Unknown;
-    static mergePosition(a: IPosition, b: IPosition): Coord2D;
-    static serializePosition(pos: IPosition): D2Position;
-    static isRawCommonPositionType(arg: any): arg is CommonPositionType;
-    static isRawCoord2DPosition(arg: any): arg is Coord2DPosition;
-    static isRawAlignPosition(arg: any): arg is AlignPosition;
-    static isRawPosition(arg: any): arg is RawPosition;
-    static isPosition(arg: any): arg is IPosition;
-    static rawPositionToCoord2D(arg: any): Coord2D;
-    static tryParsePosition(arg: any): IPosition;
-}
+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;
@@ -123,3 +79,4 @@ export declare class Align implements IPosition {
     });
     toCSS(): D2Position;
 }
+export {};

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

@@ -18,6 +18,10 @@ export type TransformersMap = {
     "fontColor": color;
 };
 export declare class Transform<T extends TransformDefinitions.Types = object> {
+    /**
+     * Apply transform immediately
+     */
+    static immediate<T extends TransformDefinitions.Types>(props: SequenceProps<T>): Transform<T>;
     /**
      * Go to the left side of the stage
      */

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

@@ -1,18 +1,9 @@
 import { color, CommonDisplayable } from "../../types";
 import { DeepPartial } from "../../../../util/data";
-import type { AnimationPlaybackControls, AnimationScope, AnimationSequence, DOMKeyframesDefinition, DynamicAnimationOptions, ElementOrSelector, MotionValue, ValueAnimationTransition } from "framer-motion";
 export declare namespace TransformDefinitions {
     type BezierDefinition = [number, number, number, number];
     type CustomEasingFunction = (t: number) => number;
     type EasingDefinition = CustomEasingFunction | BezierDefinition | "linear" | "easeIn" | "easeOut" | "easeInOut" | "circIn" | "circOut" | "circInOut" | "backIn" | "backOut" | "backInOut" | "anticipate";
-    type GenericKeyframesTarget<V> = [null, ...V[]] | V[];
-    type FramerAnimationScope<T> = AnimationScope<T>;
-    type FramerAnimate = {
-        <V>(from: V, to: V | GenericKeyframesTarget<V>, options?: ValueAnimationTransition<V> | undefined): AnimationPlaybackControls;
-        <V_1>(value: MotionValue<V_1>, keyframes: V_1 | GenericKeyframesTarget<V_1>, options?: ValueAnimationTransition<V_1> | undefined): AnimationPlaybackControls;
-        (value: ElementOrSelector, keyframes: DOMKeyframesDefinition, options?: DynamicAnimationOptions | undefined): AnimationPlaybackControls;
-        (sequence: AnimationSequence, options?: SequenceOptions | undefined): AnimationPlaybackControls;
-    };
     type CommonTransformProps = {
         duration: number;
         ease: EasingDefinition;

package/dist/game/nlcore/elements/transition/type.d.ts

@@ -1,14 +1,4 @@
-import React from "react";
-import type { DOMKeyframesDefinition } from "framer-motion";
 import { ImageColor, ImageSrc } from "../../types";
-export type ElementProp<T extends Element = Element, U extends React.HTMLAttributes<T> = React.HTMLAttributes<T>> = React.JSX.IntrinsicAttributes & React.ClassAttributes<T> & React.HTMLAttributes<T> & U;
-export type ImgElementProp = ElementProp<HTMLImageElement, React.ImgHTMLAttributes<HTMLImageElement>>;
-export type SpanElementProp = ElementProp<HTMLSpanElement, React.HTMLAttributes<HTMLSpanElement>>;
-export type DivElementProp = ElementProp<HTMLDivElement, React.HTMLAttributes<HTMLDivElement>>;
-export type CSSElementProp<T extends React.CSSProperties | DOMKeyframesDefinition> = ElementProp & {
-    style: T;
-};
-export type CSSProps = React.CSSProperties;
 export interface ITransition<T extends ElementProp = Record<string, any>> {
     start(onComplete?: () => void): void;
     toElementProps(): T[];
@@ -21,11 +11,6 @@ export interface IImageTransition<T extends ElementProp = ImgElementProp> extend
 export interface ITextTransition<T extends ElementProp = SpanElementProp> extends ITransition<T> {
     copy(): ITextTransition<T>;
 }
-export type EventTypes<T extends any[]> = {
-    "start": [null];
-    "update": T;
-    "end": [null];
-};
 export declare const TransitionEventTypes: {
     [K in keyof EventTypes<any>]: K;
 };

package/dist/game/nlcore/game/liveGame.d.ts

@@ -4,38 +4,6 @@ import { GameState } from "../../player/gameState";
 import { Storable } from "../elements/persistent/storable";
 import { Game } from "../game";
 import { LiveGameEventHandler, LiveGameEventToken } from "../types";
-import { Character } from "../elements/character";
-import { Sentence } from "../elements/character/sentence";
-type LiveGameEvent = {
-    "event:character.prompt": [
-        {
-            /**
-             * The character who says the sentence
-             */
-            character: Character | null;
-            /**
-             * The sentence said by the character
-             */
-            sentence: Sentence;
-            /**
-             * The text of the sentence
-             */
-            text: string;
-        }
-    ];
-    "event:menu.choose": [
-        {
-            /**
-             * The sentence selected by the player
-             */
-            sentence: Sentence;
-            /**
-             * The text of the sentence
-             */
-            text: string;
-        }
-    ];
-};
 export declare class LiveGame {
     static DefaultNamespaces: {
         game: {};
@@ -81,4 +49,3 @@ export declare class LiveGame {
     newGame(): this;
     getGameState(): GameState | undefined;
 }
-export {};