@dvcol/neo-svelte/dist/text/typewriter.utils.d.ts

Neomorphic ui library for svelte 5

export declare const KeyboardLayouts: {
    readonly Qwerty: "qwerty";
    readonly Azerty: "azerty";
};
export type KeyboardLayout = (typeof KeyboardLayouts)[keyof typeof KeyboardLayouts];
export interface TypeWriterRandomOptions {
    /**
     * Should generate typos
     */
    enabled?: boolean;
    /**
     * How often to generate a typo
     *
     * @default 0.2 (20% chance)
     */
    odds?: number;
    /**
     * Modulo to generate a typo
     *
     * @default 5 (every 5 characters)
     */
    modulo?: number;
}
export type TypeWriterTypoOptions = TypeWriterRandomOptions & {
    /**
     * The keyboard layout to use for typos
     *
     * @default KeyboardLayouts.Qwerty
     */
    layout?: KeyboardLayout;
};
export type TypeWriterPauseOptions = TypeWriterRandomOptions & {
    /**
     * Which mode to use for sleep value
     */
    mode?: 'write' | 'delete';
    /**
     * Duration of the pause
     *
     * @default { write: 600, delete: 400 }
     */
    speed?: TypeWriterSpeed;
    /**
     * Regex to match characters to pause on.
     *
     * @default /\s|[.,;:!?]/ (whitespace and punctuation)
     */
    regex?: RegExp;
    /**
     * Whether to pause between loops and iterations
     *
     * @default 2000
     */
    iterations?: boolean | number;
    /**
     * Abort controller to exit early
     */
    controller?: AbortController;
};
export interface TypeWriterSpeed {
    write: number | number[];
    delete: number | number[];
}
export interface TypeWriterLine {
    text: string;
    display?: string;
    mode?: 'write' | 'delete' | 'loop';
    speed?: TypeWriterSpeed;
    pause?: TypeWriterPauseOptions;
    typo?: TypeWriterTypoOptions;
}
export interface TypeWriterContext {
    line: number;
    text: string;
    display?: string;
    mode?: 'write' | 'delete';
}
export interface TypewriterOptions<T extends (string | TypeWriterLine)[] = (string | TypeWriterLine)[]> {
    /**
     * The lines to iterate over
     */
    lines: T;
    /**
     * The current display text
     */
    display?: string;
    /**
     * The animation mode (write, delete, loop)
     *
     * @default 'write'
     */
    mode?: TypeWriterLine['mode'];
    /**
     * The speed of the typewriter (ms between characters)
     *
     * @default { write: 120, delete: 80 }
     */
    speed?: number | TypeWriterLine['speed'];
    /**
     * Optional pause options to semi-randomly pause between words or characters
     *
     * @default { enabled: false, odds: 0.1, modulo: 1, speed: { write: 600, delete: 400 } }
     */
    pause?: boolean | TypeWriterPauseOptions;
    /**
     * Optional typo options to semi-randomly generate typos in the text
     *
     * @default { enabled: false, odds: 0.1, modulo: 6, layout: KeyboardLayouts.Qwerty, speed: { write: 120, delete: 80 } }
     */
    typo?: boolean | TypeWriterTypoOptions;
    /**
     * Number of iterations to run the typewriter (0 for infinite)
     *
     * @default 1
     */
    iterations?: number;
    /**
     * Abort controller to exit early
     */
    controller?: AbortController;
    /**
     * Event handlers that fire when a new iteration starts (or when a loop change direction)
     *
     * @param context
     */
    onStart?: (context: TypeWriterContext & {
        iteration: number;
    }) => void;
    /**
     * Event handlers that fire when a new iteration ends (or when a loop change direction)
     * @param context
     */
    onEnd?: (context: TypeWriterContext & {
        iteration: number;
    }) => void;
    /**
     * Event handlers that fire when a new character is typed
     * @param context
     */
    onType?: (context: TypeWriterContext) => void;
    /**
     * Event handlers that fire when a typo is generated
     * @param context
     */
    onTypo?: (context: TypeWriterContext) => void;
    /**
     * Event handlers that fire when a pause is generated
     * @param context
     */
    onPause?: (context: TypeWriterContext) => void;
    /**
     * Event handlers that fire when the typewriter is aborted via the controller.
     * @param controller
     */
    onAbort?: (controller: AbortController) => void;
}
export declare function typewriter<T extends (string | TypeWriterLine)[]>({ lines, iterations, controller, ...options }: TypewriterOptions<T>): Promise<string | undefined>;