@prosekit/core 0.0.11 → 0.0.13

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

@@ -30,12 +30,92 @@ declare type Action = (options: {
     view?: EditorView;
 }) => boolean;
 
+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 }
+
+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;
+
+export declare function collectNodes(content: NodeContent): ProseMirrorNode[];
+
+export declare interface CommandApplier<Args extends any[] = any[]> {
+    (...args: Args): boolean;
+    canApply(...args: Args): boolean;
+}
+
+/** @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 const commandFacet: Facet<CommandCreators, CommandCreators>;
+
+export declare type CommandPayload = CommandCreators;
+
+export declare type Converters = ConverterTuple[];
+
+declare type ConverterTuple = Tuple5<FacetConverter | undefined>;
+
+/** @public */
+declare function createEditor<E extends Extension>({ extension, defaultDoc, defaultSelection, }: EditorOptions<E>): Editor<E>;
+export { createEditor }
+export { createEditor as createEditor_alias_1 }
+
+export declare function createMarkBuilder(getState: () => EditorState | null | undefined, type: MarkType): MarkBuilder;
+
+export declare function createNodeBuilder(getState: () => EditorState | null | undefined, type: NodeType): NodeBuilder;
+
+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 }
+
 /**
  * Add some base commands
  *
  * @public
  */
-declare function addBaseCommands(): Extension<{
+declare function defineBaseCommands(): Extension<{
     COMMAND_ARGS: {
         insertText: [{
             text: string;
@@ -59,115 +139,100 @@ declare function addBaseCommands(): Extension<{
         selectAll: [];
     };
 }>;
-export { addBaseCommands }
-export { addBaseCommands as addBaseCommands_alias_1 }
+export { defineBaseCommands }
+export { defineBaseCommands as defineBaseCommands_alias_1 }
 
 /** @public */
-declare function addBaseKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
-export { addBaseKeymap }
-export { addBaseKeymap as addBaseKeymap_alias_1 }
+declare function defineBaseKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+export { defineBaseKeymap }
+export { defineBaseKeymap as defineBaseKeymap_alias_1 }
 
-declare function addCommands<T extends Record<string, CommandCreator> = Record<string, CommandCreator>>(commands: T): Extension<{
+declare function defineCommands<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 }
+export { defineCommands }
+export { defineCommands as defineCommands_alias_1 }
 
-declare function addDefaultState(options: DefaultStateOptions): Extension;
-export { addDefaultState }
-export { addDefaultState as addDefaultState_alias_1 }
+declare function defineDefaultState(options: DefaultStateOptions): Extension;
+export { defineDefaultState }
+export { defineDefaultState as defineDefaultState_alias_1 }
 
 /** @public */
-declare function addDoc(): Extension<    {
+declare function defineDoc(): Extension<    {
 NODES: "doc";
 }>;
-export { addDoc }
-export { addDoc as addDoc_alias_1 }
+export { defineDoc }
+export { defineDoc as defineDoc_alias_1 }
 
 /**
  * @internal
  */
-declare function addEventHandler(options: {
+declare function defineEventHandler(options: {
     update?: VoidFunction;
-}): FacetExtension<VoidFunction, PluginFacetInput>;
-export { addEventHandler }
-export { addEventHandler as addEventHandler_alias_1 }
+}): FacetExtension<VoidFunction, PluginPayload>;
+export { defineEventHandler }
+export { defineEventHandler as defineEventHandler_alias_1 }
 
 /**
  * Add undo/redo history to the editor.
  */
-declare function addHistory(): Extension<    {
+declare function defineHistory(): Extension<    {
 COMMAND_ARGS: {
 undo: [];
 redo: [];
 };
 }>;
-export { addHistory }
-export { addHistory as addHistory_alias_1 }
+export { defineHistory }
+export { defineHistory as defineHistory_alias_1 }
 
 /**
  * @public
  */
-declare function addInputRule(rules: (context: {
+declare function defineInputRule(rules: (context: {
     schema: Schema;
 }) => InputRule[]): Extension;
-export { addInputRule }
-export { addInputRule as addInputRule_alias_1 }
+export { defineInputRule }
+export { defineInputRule as defineInputRule_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 }
+declare function defineKeymap(keymap: Keymap): Extension;
+export { defineKeymap }
+export { defineKeymap as defineKeymap_alias_1 }
 
 /**
  * @public
  */
-declare function addMarkSpec<Mark extends string>(options: MarkSpecOptions<Mark>): Extension<{
+declare function defineMarkSpec<Mark extends string>(options: MarkSpecOptions<Mark>): Extension<{
     MARKS: Mark;
 }>;
-export { addMarkSpec }
-export { addMarkSpec as addMarkSpec_alias_1 }
+export { defineMarkSpec }
+export { defineMarkSpec as defineMarkSpec_alias_1 }
 
 /**
  * @public
  */
-declare function addNodeSpec<NodeName extends string>(options: NodeSpecOptions<NodeName>): Extension<{
+declare function defineNodeSpec<NodeName extends string>(options: NodeSpecOptions<NodeName>): Extension<{
     NODES: NodeName;
 }>;
-export { addNodeSpec }
-export { addNodeSpec as addNodeSpec_alias_1 }
+export { defineNodeSpec }
+export { defineNodeSpec as defineNodeSpec_alias_1 }
+
+declare function defineNodeView(options: NodeViewOptions): Extension;
+export { defineNodeView }
+export { defineNodeView as defineNodeView_alias_1 }
 
-declare function addNodeView(options: NodeViewOptions): Extension;
-export { addNodeView }
-export { addNodeView as addNodeView_alias_1 }
+declare function defineNodeViewEffect(options: NodeViewEffectOptions): Extension;
+export { defineNodeViewEffect }
+export { defineNodeViewEffect as defineNodeViewEffect_alias_1 }
 
 /** @public */
-declare function addParagraph(): Extension<    {
+declare function defineParagraph(): Extension<    {
 NODES: "paragraph";
 }>;
-export { addParagraph }
-export { addParagraph as addParagraph_alias_1 }
+export { defineParagraph }
+export { defineParagraph as defineParagraph_alias_1 }
 
 /**
  * Adds a ProseMirror plugin to the editor.
@@ -177,81 +242,18 @@ export { addParagraph as addParagraph_alias_1 }
  *
  * @public
  */
-declare function addPlugin(plugin: Plugin_2 | Plugin_2[] | ((context: {
+declare function definePlugin(plugin: Plugin_2 | Plugin_2[] | ((context: {
     schema: Schema;
 }) => Plugin_2[])): Extension;
-export { addPlugin }
-export { addPlugin as addPlugin_alias_1 }
+export { definePlugin }
+export { definePlugin as definePlugin_alias_1 }
 
 /** @public */
-declare function addText(): Extension<    {
+declare function defineText(): 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;
-
-export declare function collectNodes(content: NodeContent): ProseMirrorNode[];
-
-export declare interface CommandApplier<Args extends any[] = any[]> {
-    (...args: Args): boolean;
-    canApply(...args: Args): boolean;
-}
-
-/** @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 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 function createMarkBuilder(getState: () => EditorState | null | undefined, type: MarkType): MarkBuilder;
-
-export declare function createNodeBuilder(getState: () => EditorState | null | undefined, type: NodeType): NodeBuilder;
-
-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 }
+export { defineText }
+export { defineText as defineText_alias_1 }
 
 /** @public */
 declare class Editor<E extends Extension = any> {
@@ -301,7 +303,7 @@ declare interface EditorOptions<E extends Extension> {
 export { EditorOptions }
 export { EditorOptions as EditorOptions_alias_1 }
 
-declare type EmptyValue = never | undefined | null | EmptyObject;
+declare type EmptyValue = undefined | null | EmptyObject;
 
 export declare type ExceptEmptyValue<T> = ConditionalExcept<T, EmptyValue>;
 
@@ -381,40 +383,45 @@ declare class Facet<Input, Output> {
     /** @internal */
     readonly index: number;
     /** @internal */
-    readonly slot: () => Slot<Input, Output>;
+    readonly converter: () => FacetConverter<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>;
+    static define<Input, Output>({ converter: converter, convert: convert, next, }: 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>;
+    static defineRootFacet<Input>(options: Omit<FacetOptions<Input, Input>, 'next'>): Facet<Input, Input>;
+    extension(payloads: Input[]): FacetExtension<Input, Output>;
 }
 export { Facet }
 export { Facet as Facet_alias_1 }
 
+/** @public */
+export declare interface FacetConverter<Input = any, Output = any> {
+    create: (inputs: Input[]) => Output;
+    update: (inputs: Input[]) => Output | null;
+}
+
 /** @public */
 declare class FacetExtension<Input, Output> {
     readonly facet: Facet<Input, Output>;
-    readonly inputs: Input[];
+    readonly payloads: Input[];
     extension: Extension;
-    constructor(facet: Facet<Input, Output>, inputs: Input[]);
+    constructor(facet: Facet<Input, Output>, payloads: Input[]);
 }
 export { FacetExtension }
 export { FacetExtension as FacetExtension_alias_1 }
 
 /** @public */
 declare interface FacetOptions<Input, Output> {
-    combine?: (inputs: Input[]) => Output;
-    slot?: () => Slot<Input, Output>;
+    convert?: (payloads: Input[]) => Output;
+    converter?: () => FacetConverter<Input, Output>;
     next: Facet<Output, any>;
-    single?: boolean;
 }
 export { FacetOptions }
 export { FacetOptions as FacetOptions_alias_1 }
 
+export declare function getFacetCount(): number;
+
 /** @internal */
 declare function getMarkType(schema: Schema, type: string | MarkType): MarkType;
 export { getMarkType }
@@ -425,12 +432,6 @@ 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;
@@ -503,6 +504,18 @@ declare interface NodeSpecOptions<NodeName extends string = string> extends Node
 export { NodeSpecOptions }
 export { NodeSpecOptions as NodeSpecOptions_alias_1 }
 
+declare type NodeViewEffectOptions = {
+    group: string;
+    name: string;
+    args: unknown;
+} | {
+    group: string;
+    name?: undefined;
+    factory: (args: unknown) => NodeViewConstructor;
+};
+export { NodeViewEffectOptions }
+export { NodeViewEffectOptions as NodeViewEffectOptions_alias_1 }
+
 declare interface NodeViewOptions {
     name: string;
     constructor: NodeViewConstructor;
@@ -512,17 +525,23 @@ export { NodeViewOptions as NodeViewOptions_alias_1 }
 
 export declare function objectEqual<T>(a: T, b: T): boolean;
 
+declare type Payload = unknown;
+
+export declare type Payloads = PayloadTuple[];
+
+declare type PayloadTuple = Tuple5<Payload[]>;
+
 /** @internal */
-declare const pluginFacet: Facet<PluginFacetInput, StateConfigCallback>;
+declare const pluginFacet: Facet<PluginPayload, StatePayload>;
 export { pluginFacet }
 export { pluginFacet as pluginFacet_alias_1 }
 
 /** @internal */
-declare type PluginFacetInput = (context: {
+declare type PluginPayload = (context: {
     schema: Schema;
 }) => Plugin_2[];
-export { PluginFacetInput }
-export { PluginFacetInput as PluginFacetInput_alias_1 }
+export { PluginPayload }
+export { PluginPayload as PluginPayload_alias_1 }
 
 /**
  * @public
@@ -545,7 +564,9 @@ declare class ProseKitError extends Error {
 export { ProseKitError }
 export { ProseKitError as ProseKitError_alias_1 }
 
-export declare const schemaSlot: Facet<SchemaSpec<any, any>, SchemaSpec<any, any>>;
+export declare const schemaFacet: Facet<SchemaPayload, SchemaPayload>;
+
+export declare type SchemaPayload = SchemaSpec;
 
 /**
  * A JSON representation of the prosemirror selection.
@@ -578,35 +599,7 @@ 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 }
+export declare const stateFacet: Facet<StatePayload, StatePayload>;
 
 /**
  * A JSON representation of the prosemirror state.
@@ -626,7 +619,9 @@ declare interface StateJson {
 export { StateJson }
 export { StateJson as StateJson_alias_1 }
 
-export declare const stateSlot: Facet<StateConfigCallback, StateConfigCallback>;
+export declare type StatePayload = (ctx: {
+    schema: Schema;
+}) => EditorStateConfig;
 
 export declare type ToCommandApplier<T extends CommandArgs> = {
     [K in keyof T]: CommandApplier<T[K]>;
@@ -662,22 +657,26 @@ declare interface ToggleNodeOptions {
 export { ToggleNodeOptions }
 export { ToggleNodeOptions as ToggleNodeOptions_alias_1 }
 
+declare type Tuple5<T> = [T, T, T, T, T];
+
+declare function union<E extends Extension | Extension[]>(extension: E): SimplifyExtension<E>;
+export { union }
+export { union as union_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;
+export declare function updateExtension(prevInputs: Payloads, prevConverters: Converters, extension: Extension, mode: 'add' | 'remove'): {
+    schemaInput: SchemaPayload | null;
+    stateInput: StatePayload | null;
+    viewInput: ViewPayload | null;
+    commandInput: CommandCreators | null;
 };
 
-declare type ViewProps = Omit<DirectEditorProps, 'state'>;
-export { ViewProps }
-export { ViewProps as ViewProps_alias_1 }
+export declare const viewFacet: Facet<ViewPayload, ViewPayload>;
 
-export declare const viewSlot: Facet<ViewProps, ViewProps>;
+export declare type ViewPayload = Omit<DirectEditorProps, 'state'>;
 
 export declare function voidFunction(): void;
 

package/dist/prosekit-core.d.ts

@@ -10,31 +10,33 @@ 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 { union } 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 { defineBaseCommands } from './_tsup-dts-rollup';
+export { defineCommands } from './_tsup-dts-rollup';
+export { defineDefaultState } from './_tsup-dts-rollup';
 export { DefaultStateOptions } from './_tsup-dts-rollup';
-export { addDoc } from './_tsup-dts-rollup';
-export { addEventHandler } from './_tsup-dts-rollup';
-export { addHistory } from './_tsup-dts-rollup';
-export { addInputRule } from './_tsup-dts-rollup';
-export { addBaseKeymap } from './_tsup-dts-rollup';
-export { addKeymap } from './_tsup-dts-rollup';
+export { defineDoc } from './_tsup-dts-rollup';
+export { defineEventHandler } from './_tsup-dts-rollup';
+export { defineHistory } from './_tsup-dts-rollup';
+export { defineInputRule } from './_tsup-dts-rollup';
+export { defineBaseKeymap } from './_tsup-dts-rollup';
+export { defineKeymap } from './_tsup-dts-rollup';
 export { Keymap } from './_tsup-dts-rollup';
-export { addMarkSpec } from './_tsup-dts-rollup';
+export { defineMarkSpec } from './_tsup-dts-rollup';
 export { MarkSpecOptions } from './_tsup-dts-rollup';
-export { addNodeSpec } from './_tsup-dts-rollup';
+export { defineNodeSpec } from './_tsup-dts-rollup';
 export { NodeSpecOptions } from './_tsup-dts-rollup';
-export { addNodeView } from './_tsup-dts-rollup';
+export { defineNodeView } from './_tsup-dts-rollup';
 export { NodeViewOptions } from './_tsup-dts-rollup';
-export { addParagraph } from './_tsup-dts-rollup';
-export { addPlugin } from './_tsup-dts-rollup';
+export { defineNodeViewEffect } from './_tsup-dts-rollup';
+export { NodeViewEffectOptions } from './_tsup-dts-rollup';
+export { defineParagraph } from './_tsup-dts-rollup';
+export { definePlugin } from './_tsup-dts-rollup';
 export { pluginFacet } from './_tsup-dts-rollup';
-export { PluginFacetInput } from './_tsup-dts-rollup';
-export { addText } from './_tsup-dts-rollup';
+export { PluginPayload } from './_tsup-dts-rollup';
+export { defineText } from './_tsup-dts-rollup';
 export { CommandArgs } from './_tsup-dts-rollup';
 export { Extension } from './_tsup-dts-rollup';
 export { ExtractCommandAppliers } from './_tsup-dts-rollup';
@@ -50,6 +52,3 @@ 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';