@novely/core 0.0.0-alpha.2 → 0.0.0-alpha.3

package/dist/index.d.ts

@@ -0,0 +1,229 @@
+import { BaseTranslationStrings, SetupT9N } from '@novely/t9n';
+export { BaseTranslationStrings } from '@novely/t9n';
+
+type Name<Keys extends string = string> = string | Record<Keys, string>;
+type Emotions<Keys extends string = string> = Record<Keys, string | {
+    body: Record<'left' | 'right', string>;
+    head: string;
+}>;
+type Character<LanguageKeys extends string = string> = {
+    name: Name<LanguageKeys>;
+    color: string;
+    emotions: Emotions;
+};
+
+type Thenable<T> = T | Promise<T>;
+type PathItem = [null, number | string] | ['choice' & Record<never, never>, number] | ['condition' & Record<never, never>, string];
+type Path = PathItem[];
+/**
+ * Значения, которые можно сохранить в `state`.
+ */
+type StateValues = null | string | number | boolean | StateValues[] | {
+    [name: string]: StateValues;
+};
+type State = Record<string, StateValues>;
+type SaveDate = number;
+type SaveType = "manual" | "auto";
+type SaveMeta = [SaveDate, SaveType];
+type Save = [Path, State, SaveMeta];
+type Lang = string;
+type StorageMeta = [Lang];
+type StorageData = {
+    saves: Save[];
+    meta: StorageMeta;
+};
+type Stack = {
+    value: Save;
+    back(): void;
+    push(value: Save): void;
+    clear(): void;
+};
+
+type ValidAction = [keyof DefaultActionProxyProvider, Parameters<DefaultActionProxyProvider[keyof DefaultActionProxyProvider]>];
+type Story = Record<string, ValidAction[]>;
+type DialogContent = string | ((lang: string, obj: Record<string, unknown>) => string);
+type ChoiceContent = string | ((lang: string, obj: Record<string, unknown>) => string);
+type CustomHandlerGetResultDataFunction = {
+    (): Record<string, unknown>;
+    (data: Record<string, unknown>): void;
+};
+type CustomHandlerGetResultSkipClearOnGoingBackFunction = {
+    (): boolean;
+    (value: boolean): void;
+};
+type CustomHandlerGetResult = {
+    delete: () => void;
+    /**
+     * Данные
+     */
+    data: CustomHandlerGetResultDataFunction;
+    /**
+     * Элемент слоя
+     */
+    element: HTMLDivElement;
+    /**
+     * Будет ли запускаться очистка при проходе назад
+     */
+    skipClearOnGoingBack: CustomHandlerGetResultSkipClearOnGoingBackFunction;
+    /**
+     * Устанавливает обработчик очистки
+     */
+    clear: (fn: () => void) => void;
+};
+type CustomHandlerFunction = (get: (id: string) => CustomHandlerGetResult, goingBack: boolean, resolve: () => void) => Thenable<void>;
+type CustomHandler = CustomHandlerFunction & {
+    callOnlyLatest?: boolean;
+    requireUserAction?: boolean;
+};
+type ActionProxyProvider<Characters extends Record<string, Character>> = {
+    choice: (...choices: ([ChoiceContent, ValidAction[]] | [ChoiceContent, ValidAction[], () => boolean])[]) => ValidAction;
+    clear: () => ValidAction;
+    condition: <T extends string>(condition: () => T, variants: Record<T, ValidAction[]>) => ValidAction;
+    dialog: {
+        <C extends keyof Characters>(person: C, content: DialogContent, emotion?: keyof Characters[C]['emotions']): ValidAction;
+        (person: undefined, content: DialogContent, emotion?: undefined): ValidAction;
+        (person: string, content: DialogContent, emotion?: undefined): ValidAction;
+    };
+    end: () => ValidAction;
+    showBackground: (background: string) => ValidAction;
+    playMusic: (audio: string) => ValidAction;
+    stopMusic: (audio: string) => ValidAction;
+    jump: (scene: string) => ValidAction;
+    showCharacter: {
+        <C extends keyof Characters>(character: C, emotion: keyof Characters[C]['emotions'], className?: string, style?: string): ValidAction;
+    };
+    hideCharacter: {
+        <C extends keyof Characters>(character: C, className?: string, style?: string, duration?: number): ValidAction;
+    };
+    wait: (time: number) => ValidAction;
+    function: (fn: () => Thenable<void>) => ValidAction;
+    input: (question: string, onInput: (meta: {
+        input: HTMLInputElement;
+        error: (error: string) => void;
+        event: InputEvent & {
+            currentTarget: HTMLInputElement;
+        };
+    }) => void, setup?: (input: HTMLInputElement) => void) => ValidAction;
+    custom: (handler: CustomHandler) => ValidAction;
+    vibrate: (...pattern: number[]) => ValidAction;
+    next: () => ValidAction;
+};
+type DefaultActionProxyProvider = ActionProxyProvider<Record<string, Character>>;
+type GetActionParameters<T extends Capitalize<keyof DefaultActionProxyProvider>> = Parameters<DefaultActionProxyProvider[Uncapitalize<T>]>;
+
+interface LocalStorageStorageSettings {
+    key: string;
+}
+interface Storage {
+    get: () => Promise<StorageData>;
+    set: (data: StorageData) => Promise<void>;
+}
+declare const localStorageStorage: (options: LocalStorageStorageSettings) => Storage;
+
+type Stored<T> = {
+    subscribe: (cb: (value: T) => void) => () => void;
+    update: (fn: (prev: T) => T) => void;
+    get: () => T;
+};
+
+interface CharacterHandle {
+    canvas: HTMLCanvasElement;
+    ctx: CanvasRenderingContext2D;
+    withEmotion: (emotion: string) => () => void;
+    append: (className?: string, style?: string) => void;
+    remove: (className?: string, style?: string, duration?: number) => (resolve: () => void) => void;
+    emotions: Record<string, HTMLImageElement | Record<"head" | "left" | "right", HTMLImageElement>>;
+}
+interface AudioHandle {
+    element: HTMLAudioElement;
+    stop: () => void;
+    pause: () => void;
+    play: () => void;
+}
+interface RendererStore {
+    characters: Record<string, CharacterHandle>;
+    audio: Partial<Record<"music", AudioHandle>>;
+}
+type Renderer = {
+    character: (character: string) => CharacterHandle;
+    background: (background: string) => void;
+    dialog: (content: string, character?: string, emotion?: string) => (resolve: () => void) => void;
+    choices: (choices: ([string, ValidAction[]] | [string, ValidAction[], () => boolean])[]) => (resolve: (selected: number) => void) => void;
+    input: (question: string, onInput: Parameters<DefaultActionProxyProvider['input']>[1], setup?: Parameters<DefaultActionProxyProvider['input']>[2]) => (resolve: () => void) => void;
+    music: (source: string, method: keyof RendererStore['audio']) => AudioHandle;
+    clear: (goingBack: boolean) => (resolve: () => void) => void;
+    custom: (fn: Parameters<DefaultActionProxyProvider['custom']>[0], goingBack: boolean, push: () => void) => Thenable<void>;
+    store: RendererStore;
+    ui: {
+        /**
+         * Показывает экран, скрывает другие
+         */
+        showScreen(name: "mainmenu" | "game" | "saves" | "settings" | 'loading'): void;
+    };
+};
+type RendererInit = {
+    characters: Record<string, Character>;
+    storage: Storage;
+    set: (save: Save) => Promise<void>;
+    restore: (save?: Save) => Promise<void>;
+    save: (override?: boolean, type?: Save[2][1]) => Promise<void>;
+    newGame: () => void;
+    stack: Stack;
+    languages: string[];
+    /**
+     * Translation function
+     */
+    t: (key: BaseTranslationStrings, lang: string) => string;
+    /**
+     * Store that tracks data updates
+     */
+    $: Stored<StorageData>;
+};
+
+interface NovelyInit<Languages extends string, Characters extends Record<string, Character<Languages>>, Inter extends ReturnType<SetupT9N<Languages>>> {
+    /**
+     * An array of languages supported by the game.
+     */
+    languages: Languages[];
+    /**
+     * An object containing the characters in the game.
+     */
+    characters: Characters;
+    /**
+     * An object that provides access to the game's storage system.
+     */
+    storage: Storage;
+    /**
+     * A function that returns a Renderer object used to display the game's content
+     */
+    renderer: (characters: RendererInit) => Renderer;
+    /**
+     * An optional property that specifies the initial screen to display when the game starts
+     */
+    initialScreen?: "mainmenu" | "game" | "saves" | "settings";
+    /**
+     * An object containing the translation functions used in the game
+     */
+    t9n: Inter;
+    /**
+     * An optional property that specifies whether to preload assets when the game starts
+     */
+    assetsPreload?: boolean;
+    /**
+     * An optional property that specifies whether the game should use a single save.
+     */
+    singleSave?: boolean;
+}
+type Novely = <Languages extends string, Characters extends Record<string, Character<Languages>>, Inter extends ReturnType<SetupT9N<Languages>>>(init: NovelyInit<Languages, Characters, Inter>) => {
+    withStory: (s: Story) => void;
+    action: ActionProxyProvider<Characters>;
+    render: () => void;
+    state: {
+        (value: State | ((prev: State) => State)): void;
+        (): State;
+    };
+    t: Inter['t'];
+};
+declare const novely: Novely;
+
+export { ActionProxyProvider, AudioHandle, Character, CharacterHandle, CustomHandler, CustomHandlerGetResult, CustomHandlerGetResultDataFunction, CustomHandlerGetResultSkipClearOnGoingBackFunction, DefaultActionProxyProvider, Emotions, GetActionParameters, Path, Renderer, RendererInit, RendererStore, Storage, StorageData, Stored, Story, Thenable, ValidAction, localStorageStorage, novely };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@novely/core",
   "description": "Novely - powerful visual novel engine for creating interactive stories and games with branching narratives and rich multimedia content.",
-  "version": "0.0.0-alpha.2",
+  "version": "0.0.0-alpha.3",
   "type": "module",
   "sideEffects": false,
   "types": "./dist/index.d.ts",