@prosekit/core 0.0.7 → 0.0.8

package/dist/_tsup-dts-rollup.d.ts

@@ -0,0 +1,627 @@
+import { Attrs } from '@prosekit/pm/model';
+import { Command } from '@prosekit/pm/state';
+import type { ConditionalExcept } from 'type-fest';
+import type { DirectEditorProps } from '@prosekit/pm/view';
+import type { EditorState } from '@prosekit/pm/state';
+import type { EditorStateConfig } from '@prosekit/pm/state';
+import { EditorView } from '@prosekit/pm/view';
+import type { EmptyObject } from 'type-fest';
+import { InputRule } from '@prosekit/pm/inputrules';
+import type { IsEqual } from 'type-fest';
+import type { MarkSpec } from '@prosekit/pm/model';
+import { MarkType } from '@prosekit/pm/model';
+import type { NodeSpec } from '@prosekit/pm/model';
+import { NodeType } from '@prosekit/pm/model';
+import { NodeViewConstructor } from '@prosekit/pm/view';
+import { Options } from 'tsup';
+import { Plugin as Plugin_2 } from '@prosekit/pm/state';
+import { ProseMirrorNode } from '@prosekit/pm/model';
+import { Schema } from '@prosekit/pm/model';
+import type { SchemaSpec } from '@prosekit/pm/model';
+import type { Simplify } from 'type-fest';
+import { Transaction } from '@prosekit/pm/state';
+import type { UnionToIntersection } from 'type-fest';
+import { UserProjectConfigExport } from 'vitest/dist/config.js';
+
+declare type Action = (options: {
+    tr: Transaction;
+    view?: EditorView;
+}) => boolean;
+
+/**
+ * Add some base commands
+ *
+ * @public
+ */
+declare function addBaseCommands(): Extension<{
+    COMMAND_ARGS: {
+        insertText: [{
+            text: string;
+            from?: number | undefined;
+            to?: number | undefined;
+        }];
+        insertNode: [{
+            node: ProseMirrorNode;
+            pos?: number | undefined;
+        }];
+        wrap: [{
+            nodeType: NodeType;
+            attrs?: Attrs | null | undefined;
+        }];
+        setBlockType: [{
+            nodeType: NodeType;
+            attrs?: Attrs | null | undefined;
+            from?: number | undefined;
+            to?: number | undefined;
+        }];
+        selectAll: [];
+    };
+}>;
+export { addBaseCommands }
+export { addBaseCommands as addBaseCommands_alias_1 }
+
+/** @public */
+declare function addBaseKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { addBaseKeymap }
+export { addBaseKeymap as addBaseKeymap_alias_1 }
+
+declare function addCommands<T extends Record<string, CommandCreator> = Record<string, CommandCreator>>(commands: T): Extension<{
+    COMMAND_ARGS: {
+        [K in keyof T]: Parameters<T[K]>;
+    };
+}>;
+export { addCommands }
+export { addCommands as addCommands_alias_1 }
+
+declare function addDefaultState(options: DefaultStateOptions): Extension;
+export { addDefaultState }
+export { addDefaultState as addDefaultState_alias_1 }
+
+/** @public */
+declare function addDoc(): Extension<    {
+NODES: "doc";
+}>;
+export { addDoc }
+export { addDoc as addDoc_alias_1 }
+
+/**
+ * @public
+ */
+declare function addInputRule(rules: (context: {
+    schema: Schema;
+}) => InputRule[]): Extension;
+export { addInputRule }
+export { addInputRule as addInputRule_alias_1 }
+
+/** @public */
+declare function addKeymap(keymap: Keymap): Extension;
+export { addKeymap }
+export { addKeymap as addKeymap_alias_1 }
+
+declare function addMark(options: AddMarkOptions): Command;
+export { addMark }
+export { addMark as addMark_alias_1 }
+
+declare interface AddMarkOptions {
+    type: string | MarkType;
+    attrs?: Attrs | null;
+    /**
+     * The start position of the mark. By default it will be the start position of current selection.
+     */
+    from?: number;
+    /**
+     * The end position of the mark. By default it will be the end position of current selection.
+     */
+    to?: number;
+}
+export { AddMarkOptions }
+export { AddMarkOptions as AddMarkOptions_alias_1 }
+
+/**
+ * @public
+ */
+declare function addMarkSpec<Mark extends string>(options: MarkSpecOptions<Mark>): Extension<{
+    MARKS: Mark;
+}>;
+export { addMarkSpec }
+export { addMarkSpec as addMarkSpec_alias_1 }
+
+/**
+ * @public
+ */
+declare function addNodeSpec<NodeName extends string>(options: NodeSpecOptions<NodeName>): Extension<{
+    NODES: NodeName;
+}>;
+export { addNodeSpec }
+export { addNodeSpec as addNodeSpec_alias_1 }
+
+declare function addNodeView(options: NodeViewOptions): Extension;
+export { addNodeView }
+export { addNodeView as addNodeView_alias_1 }
+
+/** @public */
+declare function addParagraph(): Extension<    {
+NODES: "paragraph";
+}>;
+export { addParagraph }
+export { addParagraph as addParagraph_alias_1 }
+
+/**
+ * Adds a ProseMirror plugin to the editor.
+ *
+ * @param plugin - The ProseMirror plugin to add, or an array of plugins, or a
+ * function that returns an array of plugins.
+ *
+ * @public
+ */
+declare function addPlugin(plugin: Plugin_2 | Plugin_2[] | ((context: {
+    schema: Schema;
+}) => Plugin_2[])): Extension;
+export { addPlugin }
+export { addPlugin as addPlugin_alias_1 }
+
+/** @public */
+declare function addText(): Extension<    {
+NODES: "text";
+}>;
+export { addText }
+export { addText as addText_alias_1 }
+
+export declare type AnySlot = Slot<any, any>;
+
+export declare function applyAction(operator: Action): Command;
+
+/**
+ * Utility function assert that two types are equal in tests.
+ */
+export declare function assertTypeEqual<T, U>(_val: IsEqual<T, U>): void;
+
+/** @internal */
+declare interface CommandArgs {
+    [name: string]: any[];
+}
+export { CommandArgs }
+export { CommandArgs as CommandArgs_alias_1 }
+
+export declare type CommandCreator<Args extends any[] = any[]> = (...arg: Args) => Command;
+
+export declare interface CommandCreators {
+    [name: string]: CommandCreator;
+}
+
+export declare type CommandDispatcher<Args extends any[] = any[]> = (...arg: Args) => boolean;
+
+export declare const commandSlot: Facet<CommandSlotInput, CommandSlotInput>;
+
+export declare type CommandSlotInput = Record<string, CommandCreator<any>>;
+
+/** @public */
+declare function createEditor<E extends Extension>({ extension, defaultDoc, defaultSelection, }: EditorOptions<E>): Editor<E>;
+export { createEditor }
+export { createEditor as createEditor_alias_1 }
+
+export declare const default_alias: Options | Options[] | ((overrideOptions: Options) => Options | Options[] | Promise<Options | Options[]>);
+
+export declare const default_alias_1: UserProjectConfigExport;
+
+declare interface DefaultStateOptions {
+    /**
+     * A JSON representation of a ProseMirror document.
+     */
+    doc?: NodeJson;
+    /**
+     * A JSON representation of a ProseMirror selection.
+     */
+    selection?: SelectionJson;
+}
+export { DefaultStateOptions }
+export { DefaultStateOptions as DefaultStateOptions_alias_1 }
+
+declare function defineExtension<E extends Extension | Extension[]>(extension: E): SimplifyExtension<E>;
+export { defineExtension }
+export { defineExtension as defineExtension_alias_1 }
+
+/** @public */
+declare class Editor<E extends Extension = any> {
+    private instance;
+    private constructor();
+    private afterMounted;
+    /** @internal */
+    static create(instance: any): Editor<any>;
+    get mounted(): boolean;
+    get view(): EditorView;
+    get schema(): Schema<ExtractNodes<E>, ExtractMarks<E>>;
+    get commands(): ExtractCommandDispatchers<E>;
+    mount(place: HTMLElement | null | undefined | void): void;
+    unmount(): void;
+    use(extension: Extension): VoidFunction;
+    isNodeActive(nodeType: string | NodeType, attrs?: Attrs): boolean;
+    isMarkActive(markType: string | MarkType, attrs?: Attrs): boolean;
+}
+export { Editor }
+export { Editor as Editor_alias_1 }
+
+/** @public */
+declare interface EditorOptions<E extends Extension> {
+    /**
+     * The extension to use when creating the editor.
+     */
+    extension: E;
+    /**
+     * A JSON object representing the starting document to use when creating the
+     * editor.
+     */
+    defaultDoc?: NodeJson;
+    /**
+     * A JSON object representing the starting selection to use when creating the
+     * editor. It's only used when `defaultDoc` is also provided.
+     */
+    defaultSelection?: SelectionJson;
+}
+export { EditorOptions }
+export { EditorOptions as EditorOptions_alias_1 }
+
+declare type EmptyValue = never | undefined | null | EmptyObject;
+
+export declare type ExceptEmptyValue<T> = ConditionalExcept<T, EmptyValue>;
+
+/**
+ * @public
+ */
+declare interface Extension<T extends ExtensionTyping = ExtensionTyping> {
+    extension: Extension | Extension[];
+    priority?: Priority;
+    _type?: T;
+}
+export { Extension }
+export { Extension as Extension_alias_1 }
+
+/**
+ * @internal
+ */
+declare interface ExtensionTyping<Node extends string = string, Mark extends string = string, Commands extends CommandArgs = CommandArgs> {
+    NODES?: Node;
+    MARKS?: Mark;
+    COMMAND_ARGS?: Commands;
+}
+export { ExtensionTyping }
+export { ExtensionTyping as ExtensionTyping_alias_1 }
+
+/**
+ * @internal
+ */
+export declare type ExtractCommandArgs<E extends Extension> = ExtractCommandArgsFromTyping<ExtractTyping<E>>;
+
+export declare type ExtractCommandArgsFromTyping<T extends ExtensionTyping> = ExtractKey<T, 'COMMAND_ARGS'>;
+
+/**
+ * @public
+ */
+declare type ExtractCommandCreators<E extends Extension> = ToCommandCreators<ExtractCommandArgs<E>>;
+export { ExtractCommandCreators }
+export { ExtractCommandCreators as ExtractCommandCreators_alias_1 }
+
+/**
+ * @public
+ */
+declare type ExtractCommandDispatchers<E extends Extension> = ToCommandDispatcher<ExtractCommandArgs<E>>;
+export { ExtractCommandDispatchers }
+export { ExtractCommandDispatchers as ExtractCommandDispatchers_alias_1 }
+
+/**
+ * @intneral
+ */
+export declare type ExtractKey<T, K extends string> = Extract<T, Record<K, any>>[K];
+
+/**
+ * @public
+ */
+declare type ExtractMarks<E extends Extension> = ExtractMarksFromTyping<ExtractTyping<E>>;
+export { ExtractMarks }
+export { ExtractMarks as ExtractMarks_alias_1 }
+
+export declare type ExtractMarksFromTyping<T extends ExtensionTyping> = ExtractKey<T, 'MARKS'>;
+
+/**
+ * @public
+ */
+declare type ExtractNodes<E extends Extension> = ExtractNodesFromTyping<ExtractTyping<E>>;
+export { ExtractNodes }
+export { ExtractNodes as ExtractNodes_alias_1 }
+
+export declare type ExtractNodesFromTyping<T extends ExtensionTyping> = ExtractKey<T, 'NODES'>;
+
+/**
+ * @internal
+ */
+export declare type ExtractTyping<E extends Extension> = E extends Extension<infer T> ? T : never;
+
+/** @public */
+declare class Facet<Input, Output> {
+    /** @internal */
+    readonly index: number;
+    /** @internal */
+    readonly slot: () => Slot<Input, Output>;
+    /** @internal */
+    readonly next: Facet<Output, any> | null;
+    /** @internal */
+    readonly single: boolean;
+    private constructor();
+    static define<Input, Output>({ slot, combine, next, single, }: FacetOptions<Input, Output>): Facet<Input, Output>;
+    /** @internal */
+    static defineSlot<Input>(options: Omit<FacetOptions<Input, Input>, 'next'>): Facet<Input, Input>;
+    extension(inputs: Input[]): FacetExtension<Input, Output>;
+}
+export { Facet }
+export { Facet as Facet_alias_1 }
+
+/** @public */
+declare class FacetExtension<Input, Output> {
+    readonly facet: Facet<Input, Output>;
+    readonly inputs: Input[];
+    extension: Extension;
+    constructor(facet: Facet<Input, Output>, inputs: Input[]);
+}
+export { FacetExtension }
+export { FacetExtension as FacetExtension_alias_1 }
+
+/** @public */
+declare interface FacetOptions<Input, Output> {
+    combine?: (inputs: Input[]) => Output;
+    slot?: () => Slot<Input, Output>;
+    next: Facet<Output, any>;
+    single?: boolean;
+}
+export { FacetOptions }
+export { FacetOptions as FacetOptions_alias_1 }
+
+/** @internal */
+declare function getMarkType(schema: Schema, type: string | MarkType): MarkType;
+export { getMarkType }
+export { getMarkType as getMarkType_alias_1 }
+
+/** @internal */
+declare function getNodeType(schema: Schema, type: string | NodeType): NodeType;
+export { getNodeType }
+export { getNodeType as getNodeType_alias_1 }
+
+declare type Input = unknown;
+
+export declare type Inputs = InputTuple[];
+
+declare type InputTuple = [Input[], Input[], Input[], Input[], Input[]];
+
+export declare function insertNode({ node, pos, }: {
+    node: ProseMirrorNode;
+    pos?: number;
+}): Action;
+
+export declare function isMarkActive(state: EditorState, type: string | MarkType, attrs?: Attrs | null): boolean;
+
+export declare function isNodeActive(state: EditorState, type: string | NodeType, attrs?: Attrs | null): boolean;
+
+/** @public */
+declare interface Keymap {
+    [key: string]: Command;
+}
+export { Keymap }
+export { Keymap as Keymap_alias_1 }
+
+/**
+ * @public
+ */
+declare interface MarkSpecOptions<MarkName extends string = string> extends MarkSpec {
+    name: MarkName;
+}
+export { MarkSpecOptions }
+export { MarkSpecOptions as MarkSpecOptions_alias_1 }
+
+/**
+ * A JSON representation of the prosemirror node.
+ *
+ * @public
+ */
+declare interface NodeJson {
+    type: string;
+    marks?: Array<any>;
+    text?: string;
+    content?: NodeJson[];
+    attrs?: Record<string, any>;
+}
+export { NodeJson }
+export { NodeJson as NodeJson_alias_1 }
+
+/**
+ * @public
+ */
+declare interface NodeSpecOptions<NodeName extends string = string> extends NodeSpec {
+    name: NodeName;
+    topNode?: boolean;
+}
+export { NodeSpecOptions }
+export { NodeSpecOptions as NodeSpecOptions_alias_1 }
+
+declare interface NodeViewOptions {
+    name: string;
+    constructor: NodeViewConstructor;
+}
+export { NodeViewOptions }
+export { NodeViewOptions as NodeViewOptions_alias_1 }
+
+export declare function objectEqual<T>(a: T, b: T): boolean;
+
+/** @internal */
+declare const pluginFacet: Facet<PluginFacetInput, StateConfigCallback>;
+export { pluginFacet }
+export { pluginFacet as pluginFacet_alias_1 }
+
+/** @internal */
+declare type PluginFacetInput = (context: {
+    schema: Schema;
+}) => Plugin_2[];
+export { PluginFacetInput }
+export { PluginFacetInput as PluginFacetInput_alias_1 }
+
+/**
+ * @public
+ */
+declare const enum Priority {
+    lowest = 4,
+    low = 3,
+    default = 2,
+    high = 1,
+    highest = 0
+}
+export { Priority }
+export { Priority as Priority_alias_1 }
+
+/**
+ * Base class for all ProseKit errors.
+ */
+declare class ProseKitError extends Error {
+}
+export { ProseKitError }
+export { ProseKitError as ProseKitError_alias_1 }
+
+export declare const schemaSlot: Facet<SchemaSpec<any, any>, SchemaSpec<any, any>>;
+
+/**
+ * A JSON representation of the prosemirror selection.
+ *
+ * @public
+ */
+declare interface SelectionJson {
+    from: number;
+    to: number;
+    type: string;
+}
+export { SelectionJson }
+export { SelectionJson as SelectionJson_alias_1 }
+
+/**
+ * @internal
+ */
+declare type SimplifyExtension<E extends Extension | Extension[]> = E extends Extension[] ? Extension<ExceptEmptyValue<{
+    NODES: ExtractNodes<E[number]>;
+    MARKS: ExtractMarks<E[number]>;
+    COMMAND_ARGS: SimplifyUnion<ExtractCommandArgs<E[number]>>;
+}>> : E;
+export { SimplifyExtension }
+export { SimplifyExtension as SimplifyExtension_alias_1 }
+
+/**
+ * @intneral
+ */
+declare type SimplifyUnion<T> = Simplify<UnionToIntersection<T>>;
+export { SimplifyUnion }
+export { SimplifyUnion as SimplifyUnion_alias_1 }
+
+export declare interface Slot<Input, Output> {
+    create: (inputs: Input[]) => Output;
+    update: (inputs: Input[]) => Output | null;
+}
+
+export declare type Slots = SlotTuple[];
+
+declare type SlotTuple = [
+AnySlot | undefined,
+AnySlot | undefined,
+AnySlot | undefined,
+AnySlot | undefined,
+AnySlot | undefined
+];
+
+/**
+ * Use topological sort algorithm to sort facets.
+ */
+export declare function sortFacets(unsorted: readonly Facet<any, any>[]): Facet<any, any>[];
+
+declare type StateConfigCallback = (ctx: StateConfigContext) => EditorStateConfig;
+export { StateConfigCallback }
+export { StateConfigCallback as StateConfigCallback_alias_1 }
+
+declare interface StateConfigContext {
+    schema: Schema;
+}
+export { StateConfigContext }
+export { StateConfigContext as StateConfigContext_alias_1 }
+
+/**
+ * A JSON representation of the prosemirror state.
+ *
+ * @public
+ */
+declare interface StateJson {
+    /**
+     * The main `ProseMirror` doc.
+     */
+    doc: NodeJson;
+    /**
+     * The current selection.
+     */
+    selection: SelectionJson;
+}
+export { StateJson }
+export { StateJson as StateJson_alias_1 }
+
+export declare const stateSlot: Facet<StateConfigCallback, StateConfigCallback>;
+
+export declare type ToCommandArgs<T extends CommandCreators> = {
+    [K in keyof T]: Parameters<T[K]>;
+};
+
+export declare type ToCommandCreators<T extends CommandArgs> = {
+    [K in keyof T]: CommandCreator<T[K]>;
+};
+
+export declare type ToCommandDispatcher<T extends CommandArgs> = {
+    [K in keyof T]: CommandDispatcher<T[K]>;
+};
+
+declare function toggleMark(options: ToggleMarkOptions): Command;
+export { toggleMark }
+export { toggleMark as toggleMark_alias_1 }
+
+declare interface ToggleMarkOptions {
+    type: string | MarkType;
+    attrs?: Attrs | null;
+}
+export { ToggleMarkOptions }
+export { ToggleMarkOptions as ToggleMarkOptions_alias_1 }
+
+declare function toggleNode(options: ToggleNodeOptions): Command;
+export { toggleNode }
+export { toggleNode as toggleNode_alias_1 }
+
+declare interface ToggleNodeOptions {
+    type: string | NodeType;
+    attrs?: Attrs | null;
+}
+export { ToggleNodeOptions }
+export { ToggleNodeOptions as ToggleNodeOptions_alias_1 }
+
+export declare function uniqPush<T>(prev: readonly T[], next: readonly T[]): T[];
+
+export declare function uniqRemove<T>(prev: T[], next: T[]): T[];
+
+export declare function updateExtension(prevInputs: Inputs, prevSlots: Slots, extension: Extension, mode: 'add' | 'remove'): {
+    schemaInput: SchemaSpec<any, any> | null;
+    stateInput: StateConfigCallback | null;
+    viewInput: ViewProps | null;
+    commandInput: CommandSlotInput | null;
+};
+
+declare type ViewProps = Omit<DirectEditorProps, 'state'>;
+export { ViewProps }
+export { ViewProps as ViewProps_alias_1 }
+
+export declare const viewSlot: Facet<ViewProps, ViewProps>;
+
+export declare function voidFunction(): void;
+
+/** @public */
+declare function withPriority<T extends Extension>(extension: T, priority: Priority): T;
+export { withPriority }
+export { withPriority as withPriority_alias_1 }
+
+export { }

package/dist/prosekit-core.d.ts

@@ -1,320 +1,53 @@
-import { MarkType, Attrs, NodeType, Schema, ProseMirrorNode, MarkSpec, NodeSpec } from '@prosekit/pm/model';
-import { Command, EditorStateConfig, Plugin } from '@prosekit/pm/state';
-import { EditorView, NodeViewConstructor, DirectEditorProps } from '@prosekit/pm/view';
-import { ConditionalExcept, EmptyObject, Simplify, UnionToIntersection } from 'type-fest';
-import { InputRule } from '@prosekit/pm/inputrules';
-
-interface ToggleMarkOptions {
-    type: string | MarkType;
-    attrs?: Attrs | null;
-}
-declare function toggleMark(options: ToggleMarkOptions): Command;
-
-interface ToggleNodeOptions {
-    type: string | NodeType;
-    attrs?: Attrs | null;
-}
-declare function toggleNode(options: ToggleNodeOptions): Command;
-
-interface AddMarkOptions {
-    type: string | MarkType;
-    attrs?: Attrs | null;
-    /**
-     * The start position of the mark. By default it will be the start position of current selection.
-     */
-    from?: number;
-    /**
-     * The end position of the mark. By default it will be the end position of current selection.
-     */
-    to?: number;
-}
-declare function addMark(options: AddMarkOptions): Command;
-
-type CommandDispatcher<Args extends any[] = any[]> = (...arg: Args) => boolean;
-type CommandCreator<Args extends any[] = any[]> = (...arg: Args) => Command;
-/** @internal */
-interface CommandArgs {
-    [name: string]: any[];
-}
-type ToCommandCreators<T extends CommandArgs> = {
-    [K in keyof T]: CommandCreator<T[K]>;
-};
-type ToCommandDispatcher<T extends CommandArgs> = {
-    [K in keyof T]: CommandDispatcher<T[K]>;
-};
-
-type EmptyValue = never | undefined | null | EmptyObject;
-type ExceptEmptyValue<T> = ConditionalExcept<T, EmptyValue>;
-
-/**
- * @intneral
- */
-type ExtractKey<T, K extends string> = Extract<T, Record<K, any>>[K];
-
-/**
- * @internal
- */
-interface ExtensionTyping<Node extends string = string, Mark extends string = string, Commands extends CommandArgs = CommandArgs> {
-    NODES?: Node;
-    MARKS?: Mark;
-    COMMAND_ARGS?: Commands;
-}
-type ExtractNodesFromTyping<T extends ExtensionTyping> = ExtractKey<T, 'NODES'>;
-type ExtractMarksFromTyping<T extends ExtensionTyping> = ExtractKey<T, 'MARKS'>;
-type ExtractCommandArgsFromTyping<T extends ExtensionTyping> = ExtractKey<T, 'COMMAND_ARGS'>;
-
-/**
- * @public
- */
-declare const enum Priority {
-    lowest = 4,
-    low = 3,
-    default = 2,
-    high = 1,
-    highest = 0
-}
-
-/**
- * @intneral
- */
-type SimplifyUnion<T> = Simplify<UnionToIntersection<T>>;
-
-/**
- * @public
- */
-interface Extension<T extends ExtensionTyping = ExtensionTyping> {
-    extension: Extension | Extension[];
-    priority?: Priority;
-    _type?: T;
-}
-/**
- * @internal
- */
-type ExtractTyping<E extends Extension> = E extends Extension<infer T> ? T : never;
-/**
- * @public
- */
-type ExtractNodes<E extends Extension> = ExtractNodesFromTyping<ExtractTyping<E>>;
-/**
- * @public
- */
-type ExtractMarks<E extends Extension> = ExtractMarksFromTyping<ExtractTyping<E>>;
-/**
- * @internal
- */
-type ExtractCommandArgs<E extends Extension> = ExtractCommandArgsFromTyping<ExtractTyping<E>>;
-/**
- * @public
- */
-type ExtractCommandCreators<E extends Extension> = ToCommandCreators<ExtractCommandArgs<E>>;
-/**
- * @public
- */
-type ExtractCommandDispatchers<E extends Extension> = ToCommandDispatcher<ExtractCommandArgs<E>>;
-/**
- * @internal
- */
-type SimplifyExtension<E extends Extension | Extension[]> = E extends Extension[] ? Extension<ExceptEmptyValue<{
-    NODES: ExtractNodes<E[number]>;
-    MARKS: ExtractMarks<E[number]>;
-    COMMAND_ARGS: SimplifyUnion<ExtractCommandArgs<E[number]>>;
-}>> : E;
-
-/** @public */
-interface EditorOptions<E extends Extension> {
-    extension: E;
-}
-/** @public */
-declare function createEditor<E extends Extension>({ extension, }: EditorOptions<E>): Editor<E>;
-/** @public */
-declare class Editor<E extends Extension = any> {
-    private instance;
-    private constructor();
-    private afterMounted;
-    /** @internal */
-    static create(instance: any): Editor<any>;
-    get mounted(): boolean;
-    get view(): EditorView;
-    get schema(): Schema<ExtractNodes<E>, ExtractMarks<E>>;
-    get commands(): ExtractCommandDispatchers<E>;
-    mount(place: HTMLElement | null | undefined | void): void;
-    unmount(): void;
-    use(extension: Extension): VoidFunction;
-    isNodeActive(nodeType: string | NodeType, attrs?: Attrs): boolean;
-    isMarkActive(markType: string | MarkType, attrs?: Attrs): boolean;
-}
-
-interface Slot<Input, Output> {
-    create: (inputs: Input[]) => Output;
-    update: (inputs: Input[]) => Output | null;
-}
-
-/** @public */
-interface FacetOptions<Input, Output> {
-    combine?: (inputs: Input[]) => Output;
-    slot?: () => Slot<Input, Output>;
-    next: Facet<Output, any>;
-    single?: boolean;
-}
-/** @public */
-declare class Facet<Input, Output> {
-    /** @internal */
-    readonly index: number;
-    /** @internal */
-    readonly slot: () => Slot<Input, Output>;
-    /** @internal */
-    readonly next: Facet<Output, any> | null;
-    /** @internal */
-    readonly single: boolean;
-    private constructor();
-    static define<Input, Output>({ slot, combine, next, single, }: FacetOptions<Input, Output>): Facet<Input, Output>;
-    /** @internal */
-    static defineSlot<Input>(options: Omit<FacetOptions<Input, Input>, 'next'>): Facet<Input, Input>;
-    extension(inputs: Input[]): FacetExtension<Input, Output>;
-}
-/** @public */
-declare class FacetExtension<Input, Output> {
-    readonly facet: Facet<Input, Output>;
-    readonly inputs: Input[];
-    extension: Extension;
-    constructor(facet: Facet<Input, Output>, inputs: Input[]);
-}
-
-declare function defineExtension<E extends Extension | Extension[]>(extension: E): SimplifyExtension<E>;
-
-/** @public */
-declare function withPriority<T extends Extension>(extension: T, priority: Priority): T;
-
-/**
- * Base class for all ProseKit errors.
- */
-declare class ProseKitError extends Error {
-}
-
-declare function addCommands<T extends Record<string, CommandCreator> = Record<string, CommandCreator>>(commands: T): Extension<{
-    COMMAND_ARGS: {
-        [K in keyof T]: Parameters<T[K]>;
-    };
-}>;
-/**
- * Add some base commands
- *
- * @public
- */
-declare function addBaseCommands(): Extension<{
-    COMMAND_ARGS: {
-        insertText: [{
-            text: string;
-            from?: number | undefined;
-            to?: number | undefined;
-        }];
-        insertNode: [{
-            node: ProseMirrorNode;
-            pos?: number | undefined;
-        }];
-        wrap: [{
-            nodeType: NodeType;
-            attrs?: Attrs | null | undefined;
-        }];
-        setBlockType: [{
-            nodeType: NodeType;
-            attrs?: Attrs | null | undefined;
-            from?: number | undefined;
-            to?: number | undefined;
-        }];
-        selectAll: [];
-    };
-}>;
-
-/** @public */
-declare function addDoc(): Extension<{
-    NODES: "doc";
-}>;
-
-/**
- * @public
- */
-declare function addInputRule(rules: (context: {
-    schema: Schema;
-}) => InputRule[]): Extension;
-
-/** @public */
-interface Keymap {
-    [key: string]: Command;
-}
-/** @public */
-declare function addKeymap(keymap: Keymap): Extension;
-/** @public */
-declare function addBaseKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
-
-/**
- * @public
- */
-interface MarkSpecOptions<MarkName extends string = string> extends MarkSpec {
-    name: MarkName;
-}
-/**
- * @public
- */
-declare function addMarkSpec<Mark extends string>(options: MarkSpecOptions<Mark>): Extension<{
-    MARKS: Mark;
-}>;
-
-/**
- * @public
- */
-interface NodeSpecOptions<NodeName extends string = string> extends NodeSpec {
-    name: NodeName;
-    topNode?: boolean;
-}
-/**
- * @public
- */
-declare function addNodeSpec<NodeName extends string>(options: NodeSpecOptions<NodeName>): Extension<{
-    NODES: NodeName;
-}>;
-
-interface NodeViewOptions {
-    name: string;
-    constructor: NodeViewConstructor;
-}
-declare function addNodeView(options: NodeViewOptions): Extension;
-
-/** @public */
-declare function addParagraph(): Extension<{
-    NODES: "paragraph";
-}>;
-
-interface StateConfigContext {
-    schema: Schema;
-}
-type StateConfigCallback = (ctx: StateConfigContext) => EditorStateConfig;
-type ViewProps = Omit<DirectEditorProps, 'state'>;
-
-/** @public */
-interface PluginOptions {
-    plugins: Plugin[] | ((context: {
-        schema: Schema;
-    }) => Plugin[]);
-}
-/** @public */
-declare function addPlugin({ plugins }: PluginOptions): Extension;
-/** @internal */
-type PluginFacetInput = (context: {
-    schema: Schema;
-}) => Plugin[];
-/** @internal */
-declare const pluginFacet: Facet<PluginFacetInput, StateConfigCallback>;
-
-/** @public */
-declare function addText(): Extension<{
-    NODES: "text";
-}>;
-
-/** @internal */
-declare function getMarkType(schema: Schema, type: string | MarkType): MarkType;
-
-/** @internal */
-declare function getNodeType(schema: Schema, type: string | NodeType): NodeType;
-
-export { AddMarkOptions, CommandArgs, Editor, EditorOptions, Extension, ExtensionTyping, ExtractCommandCreators, ExtractCommandDispatchers, ExtractMarks, ExtractNodes, Facet, FacetExtension, FacetOptions, Keymap, MarkSpecOptions, NodeSpecOptions, NodeViewOptions, PluginFacetInput, PluginOptions, Priority, ProseKitError, SimplifyExtension, SimplifyUnion, StateConfigCallback, StateConfigContext, ToggleMarkOptions, ToggleNodeOptions, ViewProps, addBaseCommands, addBaseKeymap, addCommands, addDoc, addInputRule, addKeymap, addMark, addMarkSpec, addNodeSpec, addNodeView, addParagraph, addPlugin, addText, createEditor, defineExtension, getMarkType, getNodeType, pluginFacet, toggleMark, toggleNode, withPriority };
+export { addMark } from './_tsup-dts-rollup';
+export { AddMarkOptions } from './_tsup-dts-rollup';
+export { toggleMark } from './_tsup-dts-rollup';
+export { ToggleMarkOptions } from './_tsup-dts-rollup';
+export { toggleNode } from './_tsup-dts-rollup';
+export { ToggleNodeOptions } from './_tsup-dts-rollup';
+export { Editor } from './_tsup-dts-rollup';
+export { createEditor } from './_tsup-dts-rollup';
+export { EditorOptions } from './_tsup-dts-rollup';
+export { Facet } from './_tsup-dts-rollup';
+export { FacetExtension } from './_tsup-dts-rollup';
+export { FacetOptions } from './_tsup-dts-rollup';
+export { defineExtension } from './_tsup-dts-rollup';
+export { withPriority } from './_tsup-dts-rollup';
+export { ProseKitError_alias_1 as ProseKitError } from './_tsup-dts-rollup';
+export { addBaseCommands } from './_tsup-dts-rollup';
+export { addCommands } from './_tsup-dts-rollup';
+export { addDefaultState } from './_tsup-dts-rollup';
+export { DefaultStateOptions } from './_tsup-dts-rollup';
+export { addDoc } from './_tsup-dts-rollup';
+export { addInputRule } from './_tsup-dts-rollup';
+export { addBaseKeymap } from './_tsup-dts-rollup';
+export { addKeymap } from './_tsup-dts-rollup';
+export { Keymap } from './_tsup-dts-rollup';
+export { addMarkSpec } from './_tsup-dts-rollup';
+export { MarkSpecOptions } from './_tsup-dts-rollup';
+export { addNodeSpec } from './_tsup-dts-rollup';
+export { NodeSpecOptions } from './_tsup-dts-rollup';
+export { addNodeView } from './_tsup-dts-rollup';
+export { NodeViewOptions } from './_tsup-dts-rollup';
+export { addParagraph } from './_tsup-dts-rollup';
+export { addPlugin } from './_tsup-dts-rollup';
+export { pluginFacet } from './_tsup-dts-rollup';
+export { PluginFacetInput } from './_tsup-dts-rollup';
+export { addText } from './_tsup-dts-rollup';
+export { CommandArgs } from './_tsup-dts-rollup';
+export { Extension } from './_tsup-dts-rollup';
+export { ExtractCommandCreators } from './_tsup-dts-rollup';
+export { ExtractCommandDispatchers } from './_tsup-dts-rollup';
+export { ExtractMarks } from './_tsup-dts-rollup';
+export { ExtractNodes } from './_tsup-dts-rollup';
+export { SimplifyExtension } from './_tsup-dts-rollup';
+export { ExtensionTyping } from './_tsup-dts-rollup';
+export { NodeJson } from './_tsup-dts-rollup';
+export { SelectionJson } from './_tsup-dts-rollup';
+export { StateJson } from './_tsup-dts-rollup';
+export { Priority } from './_tsup-dts-rollup';
+export { SimplifyUnion } from './_tsup-dts-rollup';
+export { getMarkType } from './_tsup-dts-rollup';
+export { getNodeType } from './_tsup-dts-rollup';
+export { StateConfigContext } from './_tsup-dts-rollup';
+export { StateConfigCallback } from './_tsup-dts-rollup';
+export { ViewProps } from './_tsup-dts-rollup';

package/dist/prosekit-core.js

@@ -1,5 +1,4 @@
-// src/commands/toggle-mark.ts
-import { toggleMark as baseToggleMark } from "@prosekit/pm/commands";
+// src/commands/add-mark.ts
 import "@prosekit/pm/model";
 import "@prosekit/pm/state";
 
@@ -22,7 +21,25 @@ function getMarkType(schema, type) {
   return type;
 }
 
+// src/commands/add-mark.ts
+function addMark(options) {
+  return (state, dispatch) => {
+    var _a, _b;
+    const mark = getMarkType(state.schema, options.type).create(options.attrs);
+    const from = (_a = options.from) != null ? _a : state.selection.from;
+    const to = (_b = options.to) != null ? _b : state.selection.to;
+    if (from > to) {
+      return false;
+    }
+    dispatch == null ? void 0 : dispatch(state.tr.addMark(from, to, mark));
+    return true;
+  };
+}
+
 // src/commands/toggle-mark.ts
+import { toggleMark as baseToggleMark } from "@prosekit/pm/commands";
+import "@prosekit/pm/model";
+import "@prosekit/pm/state";
 function toggleMark(options) {
   return (state, dispatch, view) => {
     return baseToggleMark(
@@ -109,23 +126,6 @@ function toggleNode(options) {
   };
 }
 
-// src/commands/add-mark.ts
-import "@prosekit/pm/model";
-import "@prosekit/pm/state";
-function addMark(options) {
-  return (state, dispatch) => {
-    var _a, _b;
-    const mark = getMarkType(state.schema, options.type).create(options.attrs);
-    const from = (_a = options.from) != null ? _a : state.selection.from;
-    const to = (_b = options.to) != null ? _b : state.selection.to;
-    if (from > to) {
-      return false;
-    }
-    dispatch == null ? void 0 : dispatch(state.tr.addMark(from, to, mark));
-    return true;
-  };
-}
-
 // src/editor/editor.ts
 import { Schema as Schema3 } from "@prosekit/pm/model";
 import { EditorState } from "@prosekit/pm/state";
@@ -487,11 +487,20 @@ function updateExtension(prevInputs, prevSlots, extension, mode) {
 
 // src/editor/editor.ts
 function createEditor({
-  extension
+  extension,
+  defaultDoc,
+  defaultSelection
 }) {
-  const instance = new EditorInstance(extension);
-  const editor = Editor.create(instance);
-  return editor;
+  if (defaultDoc) {
+    extension = defineExtension([
+      extension,
+      addDefaultState({
+        doc: defaultDoc,
+        selection: defaultSelection
+      })
+    ]);
+  }
+  return Editor.create(new EditorInstance(extension));
 }
 var EditorInstance = class {
   constructor(extension) {
@@ -740,6 +749,23 @@ function addBaseCommands() {
   });
 }
 
+// src/extensions/default-state.ts
+import { Selection } from "@prosekit/pm/state";
+function addDefaultState(options) {
+  return stateSlot.extension([
+    ({ schema }) => {
+      const config = {};
+      if (options.doc) {
+        config.doc = schema.nodeFromJSON(options.doc);
+        if (options.selection) {
+          config.selection = Selection.fromJSON(config.doc, options.selection);
+        }
+      }
+      return config;
+    }
+  ]);
+}
+
 // src/extensions/node-spec.ts
 function addNodeSpec(options) {
   return nodeSpecFacet.extension([options]);
@@ -777,15 +803,18 @@ import "@prosekit/pm/state";
 
 // src/extensions/plugin.ts
 import "@prosekit/pm/model";
-import "@prosekit/pm/state";
-function addPlugin({ plugins }) {
-  if (typeof plugins === "function") {
-    return pluginFacet.extension([plugins]);
-  } else if (Array.isArray(plugins)) {
-    return pluginFacet.extension([() => plugins]);
-  } else {
-    throw new TypeError("plugins must be a function or an array");
+import { Plugin as Plugin2 } from "@prosekit/pm/state";
+function addPlugin(plugin) {
+  if (plugin instanceof Plugin2) {
+    return pluginFacet.extension([() => [plugin]]);
+  }
+  if (Array.isArray(plugin) && plugin.every((p) => p instanceof Plugin2)) {
+    return pluginFacet.extension([() => plugin]);
+  }
+  if (typeof plugin === "function") {
+    return pluginFacet.extension([plugin]);
   }
+  throw new TypeError("Invalid plugin");
 }
 var pluginFacet = Facet.define({
   combine: (callbacks) => {
@@ -814,7 +843,7 @@ var inputRuleFacet = Facet.define({
 // src/extensions/keymap.ts
 import { baseKeymap, chainCommands } from "@prosekit/pm/commands";
 import { keydownHandler } from "@prosekit/pm/keymap";
-import { Plugin as Plugin3, PluginKey } from "@prosekit/pm/state";
+import { Plugin as Plugin4, PluginKey } from "@prosekit/pm/state";
 function addKeymap(keymap) {
   return keymapFacet.extension([keymap]);
 }
@@ -829,7 +858,7 @@ var keymapFacet = Facet.define({
         return handler(view, event);
       return false;
     };
-    const plugin = new Plugin3({
+    const plugin = new Plugin4({
       key: keymapPluginKey,
       props: { handleKeyDown: handlerWrapper }
     });
@@ -884,7 +913,7 @@ var markSpecFacet = Facet.define({
 });
 
 // src/extensions/node-view.ts
-import { Plugin as Plugin4 } from "@prosekit/pm/state";
+import { Plugin as Plugin5 } from "@prosekit/pm/state";
 import "@prosekit/pm/view";
 function addNodeView(options) {
   return nodeViewFacet.extension([options]);
@@ -897,7 +926,7 @@ var nodeViewFacet = Facet.define({
         nodeViews[input.name] = input.constructor;
       }
     }
-    return () => [new Plugin4({ props: { nodeViews } })];
+    return () => [new Plugin5({ props: { nodeViews } })];
   },
   next: pluginFacet
 });
@@ -931,6 +960,7 @@ export {
   addBaseCommands,
   addBaseKeymap,
   addCommands,
+  addDefaultState,
   addDoc,
   addInputRule,
   addKeymap,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@prosekit/core",
   "type": "module",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "private": false,
   "author": {
     "name": "ocavue",
@@ -40,13 +40,13 @@
   "dependencies": {
     "@prosekit/pm": "^0.0.3",
     "orderedmap": "^2.1.1",
-    "type-fest": "^4.2.0"
+    "type-fest": "^4.3.1"
   },
   "devDependencies": {
     "@prosekit/dev": "*",
     "tsup": "^7.2.0",
-    "typescript": "^5.1.6",
-    "vitest": "^0.34.1"
+    "typescript": "^5.2.2",
+    "vitest": "^0.34.3"
   },
   "scripts": {
     "build:tsup": "tsup",

package/src/index.ts

@@ -1,12 +1,16 @@
+export { addMark, type AddMarkOptions } from './commands/add-mark'
 export { toggleMark, type ToggleMarkOptions } from './commands/toggle-mark'
 export { toggleNode, type ToggleNodeOptions } from './commands/toggle-node'
-export { addMark, type AddMarkOptions } from './commands/add-mark'
 export { Editor, createEditor, type EditorOptions } from './editor/editor'
 export { Facet, FacetExtension, type FacetOptions } from './editor/facet'
 export { defineExtension } from './editor/type-utils'
 export { withPriority } from './editor/with-priority'
 export { ProseKitError } from './error'
 export { addBaseCommands, addCommands } from './extensions/command'
+export {
+  addDefaultState,
+  type DefaultStateOptions,
+} from './extensions/default-state'
 export { addDoc } from './extensions/doc'
 export { addInputRule } from './extensions/input-rules'
 export { addBaseKeymap, addKeymap, type Keymap } from './extensions/keymap'
@@ -16,9 +20,8 @@ export { addNodeView, type NodeViewOptions } from './extensions/node-view'
 export { addParagraph } from './extensions/paragraph'
 export {
   addPlugin,
-  type PluginOptions,
-  type PluginFacetInput,
   pluginFacet,
+  type PluginFacetInput,
 } from './extensions/plugin'
 export { addText } from './extensions/text'
 export { type CommandArgs as CommandArgs } from './types/command'
@@ -32,6 +35,7 @@ export {
   type SimplifyExtension,
 } from './types/extension'
 export { type ExtensionTyping } from './types/extension-typing'
+export type { NodeJson, SelectionJson, StateJson } from './types/model'
 export { Priority } from './types/priority'
 export { type SimplifyUnion } from './types/simplify-union'
 export { getMarkType } from './utils/get-mark-type'