@remirror/core/dist-types/extension/extension-types.d.ts

import type { AnyFunction, CommandFunction, ConditionalPick, ConditionalReturnPick, Flavoring, LiteralUnion, NonChainableCommandFunction, ProsemirrorAttributes, StringKey, Transaction, UnionToIntersection } from '@remirror/core-types';
import type { CommandShape, GetCommands, GetHelpers } from '../types';
import type { AnyExtension, AnyMarkExtension, AnyNodeExtension, AnyPlainExtension } from './extension';
export interface ExtensionListProps<Extension extends AnyExtension = AnyExtension> {
    /**
     * The extensions property.
     */
    readonly extensions: readonly Extension[];
}
/**
 * A utility type which maps the passed in extension command in an action that
 * is store in the `manager.store.actions.commandName()`.
 */
export declare type MapToUnchainedCommand<RawCommands extends Record<string, AnyFunction>> = {
    [Command in keyof RawCommands]: CommandShape<Parameters<RawCommands[Command]>>;
};
/**
 * A utility type which maps the chained commands.
 */
export declare type MapToChainedCommand<RawCommands extends Record<string, AnyFunction>> = {
    [Command in keyof RawCommands]: ReturnType<RawCommands[Command]> extends NonChainableCommandFunction ? void : (...args: Parameters<RawCommands[Command]>) => any;
};
/**
 * Utility type which receives an extension and provides the type of actions it
 * makes available.
 *
 * @typeParam Extension - the extensions being used within the editor
 * @typeParam Expanded - auto generated from `Extension`. These are the
 * fully expanded extensions with all sub extensions automatically provided. You
 * never need to provide this type as it is automatically calculated.
 */
export declare type CommandsFromExtensions<Extension extends AnyExtension, Expanded extends AnyExtension = GetExtensions<Extension>> = UnionToIntersection<MapToUnchainedCommand<GetCommands<Expanded> | GetDecoratedCommands<Expanded>>>;
/**
 * This uses a hack available via conditional types and `Distributive
 * conditional types`. When a conditional is used on a union it distributes the
 * types so that the union can avoid the case where:
 *
 * > access is restricted to members that are common to all types in the union
 *
 * A better explanation is available here
 * https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html#distributive-conditional-types
 */
declare type GetDecoratedCommands<Type> = Type extends AnyExtension ? ConditionalPick<Type, AnyFunction<CommandFunction>> : never;
interface UiAnnotation {
    __uiAnnotation?: never;
}
export declare type UiCommandFunction = CommandFunction & UiAnnotation;
declare type GetDecoratedUiCommands<Type> = Type extends AnyExtension ? ConditionalPick<Type, AnyFunction<UiCommandFunction>> : never;
/**
 * Utility type for pulling all the command names from a list.
 *
 * TODO - why doesn't this work.
 */
export declare type UiCommandNames<Extension extends AnyExtension> = StringKey<ConditionalPick<{
    [P in keyof UnionToIntersection<GetDecoratedUiCommands<Extension>>]: keyof UnionToIntersection<GetDecoratedUiCommands<Extension>>[P] extends '__uiAnnotation' ? true : false;
}, true>>;
export interface ChainedCommandProps {
    /**
     * Dispatches the chained commands.
     *
     * ```ts
     * chain.insertText('hello').run();
     * ```
     *
     * This will run all commands in the chain regardless of whether a previous
     * command was not able to be run.
     *
     * If `exitEarly` is set to true the commands will stop running at the first
     * chainable command which doesn't return true.
     */
    run: (options?: {
        exitEarly?: boolean;
    }) => void;
    /**
     * Applies the updates to the transaction without dispatching the transaction.
     *
     * This can be used to update a transaction without applying the update.
     */
    tr: () => Transaction;
    /**
     * Check to see whether the command chain can be run. Returns true when the
     * command can be run.
     *
     * ```ts
     * if (chain.insertText('hello').enabled()) {
     *   doSomething();
     * }
     * ```
     */
    enabled: () => boolean;
}
export declare type ChainedIntersection<Extension extends AnyExtension> = UnionToIntersection<MapToChainedCommand<GetCommands<Extension> | GetDecoratedCommands<Extension>>>;
export declare type ChainedFromExtensions<Extension extends AnyExtension, Chained extends ChainedIntersection<Extension> = ChainedIntersection<Extension>> = _ChainedFromExtensions<Extension, Chained> & ((tr: Transaction) => _ChainedFromExtensions<Extension, Chained>);
declare type _ChainedFromExtensions<Extension extends AnyExtension, Chained extends ChainedIntersection<Extension> = ChainedIntersection<Extension>> = ChainedCommandProps & {
    [Command in keyof Chained]: Chained[Command] extends (...args: any[]) => any ? (...args: Parameters<Chained[Command]>) => ChainedFromExtensions<Extension> : never;
};
/**
 * Utility type for pulling all the command names from a list
 */
export declare type CommandNames<Extension extends AnyExtension> = StringKey<CommandsFromExtensions<Extension>>;
/**
 * A utility type which maps the passed in extension helpers to a method called
 * with `manager.data.helpers.helperName()`.
 */
export declare type MapHelpers<RawHelpers extends Record<string, AnyFunction>> = {
    [Helper in keyof RawHelpers]: RawHelpers[Helper];
};
/**
 * Utility type which receives an extension and provides the type of helpers it
 * makes available.
 *
 * @typeParam Extension - the extensions being used within the editor
 * @typeParam Expanded - auto generated from `Extension`. These are the
 * fully expanded extensions with all sub extensions automatically provided. You
 * never need to provide this type as it is automatically calculated.
 */
export declare type HelpersFromExtensions<Extension extends AnyExtension, Expanded extends AnyExtension = GetExtensions<Extension>> = UnionToIntersection<MapHelpers<GetHelpers<Expanded> | GetDecoratedHelpers<Expanded>>>;
export declare type HelperAnnotation = Flavoring<'HelperAnnotation'>;
/**
 * An annotation which marks decorated helper methods for an extension.
 */
export declare type Helper<Type> = Type extends null | undefined ? Type : Type & HelperAnnotation;
/**
 * Remove the helper annotation.
 */
declare type RemoveHelper<Type> = Type extends Helper<infer T> ? T : Type;
declare type RemoveHelpers<Type extends Record<string, AnyFunction>> = {
    [Key in keyof Type]: (...args: Parameters<Type[Key]>) => RemoveHelper<ReturnType<Type[Key]>>;
};
/**
 * A function with a return signature annotated as a helper.
 */
export declare type HelperFunction<Type extends HelperAnnotation = HelperAnnotation> = AnyFunction<Type>;
declare type GetDecoratedHelpers<Type> = Type extends object ? RemoveHelpers<ConditionalReturnPick<Type, HelperAnnotation>> : never;
/**
 * Utility type for pulling all the action names from a list
 */
export declare type HelperNames<Extension extends AnyExtension> = StringKey<HelpersFromExtensions<Extension>>;
/**
 * Removes [[`AnyExtension`]] from an extension union. This can be used to make
 * typechecking stricter.
 *
 * @typeParam Extension - The union of extensions to remove [[`AnyExtension`]] from.
 */
export declare type RemoveAny<Extension> = Extension extends Extension ? AnyExtension extends Extension ? never : Extension : never;
/**
 * Get the extension type and the extension type of all sub extensions.
 *
 * This uses recursive conditional types which are only available in
 * `typescript@4.1` https://github.com/microsoft/TypeScript/pull/40002
 *
 * @typeParam Extension - The union of extensions.
 */
export declare type GetExtensions<Extension> = AnyExtension extends Extension ? AnyExtension : Extension extends AnyExtension ? // Now create the union of the provided extension and it's recursively
Extension | GetExtensions<Extension['~E']> : AnyExtension;
/**
 * Extract the function return type if the generic type is a function, otherwise
 *
 * @internal
 *
 * @example
 *
 * ```ts
 * type A = () => string
 * type B = UnpackedReturnType<A>
 * // B = string
 *
 * type C = string
 * type D = UnpackedReturnType<A>
 * // D = string
 * ```
 */
declare type UnpackedReturnType<MaybeFunction> = MaybeFunction extends (...args: any[]) => infer Returned ? Returned : MaybeFunction;
/**
 * Get the union extension type from an array of extensions or from a function that returns an array of extension.
 *
 * @example
 *
 * ```ts
 * const extensions = [new BoldExtension(), new ItalicExtension()];
 * type Extension = UnpackedExtension<typeof extensions>
 * // Extension = BoldExtension | ItalicExtension
 * ```
 *
 * @example
 *
 * ```ts
 * const extensions = () => [new BoldExtension(), new ItalicExtension()];
 * type Extension = UnpackedExtension<typeof extensions>
 * // Extension = BoldExtension | ItalicExtension
 * ```
 */
export declare type UnpackedExtension<Extension extends AnyExtension[] | (() => AnyExtension[])> = UnpackedReturnType<Extension>[number];
/**
 * The type which gets the active methods from the provided extensions.
 */
export declare type ActiveFromExtensions<Extension extends AnyExtension> = Record<GetNodeNameUnion<Extension> extends never ? string : GetNodeNameUnion<Extension>, (attrs?: ProsemirrorAttributes) => boolean> & Record<GetMarkNameUnion<Extension> extends never ? string : GetMarkNameUnion<Extension>, (attrs?: ProsemirrorAttributes) => boolean>;
/**
 * The type which gets the attributes for the provided node or mark. It returns
 * undefined if the node / mark is not active.
 */
export declare type AttrsFromExtensions<Extension extends AnyExtension> = Record<GetNodeNameUnion<Extension> extends never ? string : GetNodeNameUnion<Extension>, (attrs?: ProsemirrorAttributes) => ProsemirrorAttributes | undefined> & Record<GetMarkNameUnion<Extension> extends never ? string : GetMarkNameUnion<Extension>, (attrs?: ProsemirrorAttributes) => ProsemirrorAttributes | undefined>;
/**
 * Get the names of all available extensions.
 */
export declare type GetNameUnion<Extension extends AnyExtension> = GetExtensions<Extension>['name'];
/**
 * A utility type for retrieving the name of an extension only when it's a plain
 * extension.
 *
 * @typeParam Extension - the extensions being used within the editor
 * @typeParam Expanded - auto generated from `Extension`. These are the
 * fully expanded extensions with all sub extensions automatically provided. You
 * never need to provide this type as it is automatically calculated.
 */
export declare type GetPlainNameUnion<Extension extends AnyExtension, Expanded extends AnyExtension = GetExtensions<Extension>> = Expanded extends AnyPlainExtension ? Expanded['name'] : never;
/**
 * A utility type for retrieving the name of an extension only when it's a mark
 * extension.
 *
 * @typeParam Extension - the extensions being used within the editor
 * @typeParam Expanded - auto generated from `Extension`. These are the
 * fully expanded extensions with all sub extensions automatically provided. You
 * never need to provide this type as it is automatically calculated.
 */
export declare type GetMarkNameUnion<Extension extends AnyExtension, Expanded extends AnyExtension = GetExtensions<Extension>> = Expanded extends AnyMarkExtension ? Expanded['name'] : never;
/**
 * A utility type for retrieving the name of an extension only when it's a node
 * extension.
 *
 * @typeParam Extension - the extensions being used within the editor
 * @typeParam Expanded - auto generated from `Extension`. These are the
 * fully expanded extensions with all sub extensions automatically provided. You
 * never need to provide this type as it is automatically calculated.
 */
export declare type GetNodeNameUnion<Extension extends AnyExtension, Expanded extends AnyExtension = GetExtensions<Extension>> = Expanded extends AnyNodeExtension ? Expanded['name'] : never;
declare global {
    namespace Remirror {
        /**
         * A utility type for all the globally available extension names. This is
         * mainly used to provide autocompletion.
         */
        type NameUnion = LiteralUnion<GetNameUnion<Extensions>, string>;
        /**
         * A utility type for all the globally available plain extension names. This
         * is mainly used to provide autocompletion.
         */
        type PlainNameUnion = LiteralUnion<GetPlainNameUnion<Extensions>, string>;
        /**
         * A utility type for all the globally available node extension names. This
         * is mainly used to provide autocompletion.
         */
        type NodeNameUnion = LiteralUnion<GetNodeNameUnion<Extensions>, string>;
        /**
         * A utility type for all the globally available mark extension names. This
         * is mainly used to provide autocompletion.
         */
        type MarkNameUnion = LiteralUnion<GetMarkNameUnion<Extensions>, string>;
    }
}
export {};