typewrite-simple/dist/index.d.ts


declare const EVENT_NAMES: {
    readonly TYPE_CHARACTER: "TYPE_CHARACTER";
    readonly REMOVE_CHARACTER: "REMOVE_CHARACTER";
    readonly REMOVE_ALL: "REMOVE_ALL";
    readonly REMOVE_LAST_VISIBLE_NODE: "REMOVE_LAST_VISIBLE_NODE";
    readonly PAUSE_FOR: "PAUSE_FOR";
    readonly CALL_FUNCTION: "CALL_FUNCTION";
    readonly ADD_HTML_TAG_ELEMENT: "ADD_HTML_TAG_ELEMENT";
    readonly REMOVE_HTML_TAG_ELEMENT: "REMOVE_HTML_TAG_ELEMENT";
    readonly CHANGE_DELETE_SPEED: "CHANGE_DELETE_SPEED";
    readonly CHANGE_DELAY: "CHANGE_DELAY";
    readonly CHANGE_CURSOR: "CHANGE_CURSOR";
    readonly PASTE_STRING: "PASTE_STRING";
};

type IEventName = keyof typeof EVENT_NAMES;
type IEventArgs = Record<string, any>;
interface IEventQueue {
    eventName: IEventName;
    eventArgs: IEventArgs;
}
type ISpeed = 'natural' | number;
interface IState {
    cursorAnimation: null;
    lastFrameTime: null | number;
    pauseUntil: null | number;
    eventQueue: IEventQueue[];
    eventLoop: null | number;
    eventLoopPaused: boolean;
    reverseCalledEvents: IEventQueue[];
    calledEvents: IEventQueue[];
    visibleNodes: any[];
    initialOptions: null | IOptions;
    elements: {
        container: null | HTMLElement;
        wrapper: HTMLElement;
        cursor: HTMLElement;
    };
}
type IFn = (...args: any[]) => any;
interface TypewriteState {
    elements: {
        container: HTMLDivElement;
        cursor: HTMLSpanElement;
        wrapper: HTMLSpanElement;
    };
}
type IMessage = {
    currentEvent: IEventQueue;
    state: IState;
    delay: number;
};
interface IOptions {
    strings?: string | string[];
    cursor?: string;
    delay?: ISpeed;
    pauseFor?: number;
    deleteSpeed?: ISpeed;
    loop?: boolean;
    autoStart?: boolean;
    devMode?: boolean;
    skipAddStyles?: boolean;
    wrapperClassName?: string;
    cursorClassName?: string;
    stringSplitter?: null | IFn;
    onCreateTextNode?: null | IFn;
    onRemoveNode?: null | IFn;
    onStep?: null | ((currentEvent: IEventQueue) => any);
}
declare class Typewrite {
    state: IState;
    options: IOptions;
    constructor(container: string | HTMLElement, options: IOptions);
    init(): void;
    /**
     * Replace all child nodes of provided element with
     * state wrapper element used for typewrite effect
     */
    setupWrapperElement: () => void;
    /**
     * Start typewrite effect
     */
    start: () => Typewrite;
    /**
     * Pause the event loop
     */
    pause: () => Typewrite;
    /**
     * Destroy current running instance
     */
    stop: () => Typewrite;
    /**
     * Add pause event to queue for ms provided
     *
     * @param {Number} ms Time in ms to pause for
     * @return {Typewrite}
     */
    pauseFor: (ms: number) => Typewrite;
    /**
     * Start typewrite effect by typing
     * out all strings provided
     *
     * @return {Typewrite}
     */
    typeOutAllStrings: () => Typewrite;
    /**
     * Adds string characters to event queue for typing
     *
     * @param {String} string String to type
     * @param {HTMLElement} node Node to add character inside of
     * @return {Typewrite}
     */
    typeString: (string: string, node?: null | HTMLElement) => Typewrite;
    /**
     * Adds entire strings to event queue for paste effect
     *
     * @param {String} string String to paste
     * @param {HTMLElement} node Node to add string inside of
     * @return {Typewrite}
     */
    pasteString: (string: string, node?: null | HTMLElement) => Typewrite;
    /**
     * Type out a string which is wrapper around HTML tag
     *
     * @param {String} string String to type
     * @param {HTMLElement} parentNode Node to add inner nodes to
     * @return {Typewrite}
     */
    typeOutHTMLString: (string: string, parentNode?: null | HTMLElement, pasteEffect?: boolean) => Typewrite;
    /**
     * Add delete all characters to event queue
     * @param {ISpeed} speed to delete all visibles nodes, can be number or 'natural'
     * @return {Typewrite}
     */
    deleteAll: (speed?: ISpeed) => Typewrite;
    /**
     * Change delete speed
     *
     * @param {Number} speed Speed to use for deleting characters
     * @return {Typewrite}
     */
    changeDeleteSpeed: (speed: number) => Typewrite;
    /**
     * Change delay when typing
     *
     * @param {Number} delay Delay when typing out characters
     * @return {Typewrite}
     */
    changeDelay: (delay: number) => Typewrite;
    /**
     * Change cursor
     * @param {String} cursor /string to represent as cursor
     * @return {Typewrite}
     */
    changeCursor: (cursor: string) => Typewrite;
    /**
     * Add delete character to event queue for amount of characters provided
     *
     * @param {Number} amount Number of characters to remove
     * @return {Typewrite}
     */
    deleteChars: (amount: number) => Typewrite;
    /**
     * Add an event item to call a callback function
     *
     * @param {cb}      cb        Callback function to call
     * @param {Object}  thisArg   thisArg to use when calling function
     * @return {Typewrite}
     */
    callFunction: (cb: (state: TypewriteState) => void, thisArg?: Record<string, any>) => Typewrite;
    /**
     * Add type character event for each character
     *
     * @param {Array} characters Array of characters
     * @param {HTMLElement} node Node to add character inside of
     * @return {Typewrite}
     */
    typeCharacters: (characters: string[], node?: null | HTMLElement) => Typewrite;
    /**
     * Add remove character event for each character
     *
     * @param {Array} characters Array of characters
     * @return {Typewrite}
     */
    removeCharacters: (characters: string[]) => Typewrite;
    /**
     * Add an event to the event queue
     *
     * @param {String}  eventName Name of the event
     * @param {Object}  eventArgs Arguments to pass to event callback
     * @param {Boolean} prepend   Prepend to begining of event queue
     * @return {Typewrite}
     */
    addEventToQueue: (eventName: IEventName, eventArgs?: null | IEventArgs, prepend?: boolean) => Typewrite;
    /**
     * Add an event to reverse called events used for looping
     *
     * @param {String}  eventName Name of the event
     * @param {Object}  eventArgs Arguments to pass to event callback
     * @param {Boolean} prepend   Prepend to begining of event queue
     * @return {Typewrite}
     */
    addReverseCalledEvent: (eventName: IEventName, eventArgs: IEventArgs, prepend?: boolean) => Typewrite;
    /**
     * Add an event to correct state property
     *
     * @param {String}  eventName Name of the event
     * @param {Object}  eventArgs Arguments to pass to event callback
     * @param {Boolean} prepend   Prepend to begining of event queue
     * @param {String}  property  Property name of state object
     * @return {Typewrite}
     */
    addEventToStateProperty: (eventName: IEventName, eventArgs?: null | IEventArgs, prepend?: boolean, property?: "eventQueue" | "reverseCalledEvents") => Typewrite;
    /**
     * Run the event loop and do anything inside of the queue
     */
    runEventLoop: () => void;
    /**
     * Log a message in development mode
     *
     * @param {IMessage} message Message or item to console.log
     */
    logInDevMode(message: IMessage): void;
    /**
     * Clear all characters to event queue
     *
     * @return {Typewrite}
     */
    clearEventQueue: () => Typewrite;
}

export { Typewrite as default };
export type { IEventArgs, IEventName, IEventQueue, IMessage, ISpeed, IState, TypewriteState };