@prosekit/core 0.4.1 → 0.5.0

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

@@ -30,7 +30,7 @@ import { Plugin as Plugin_2 } from '@prosekit/pm/state';
 import { ProseMirrorFragment } from '@prosekit/pm/model';
 import { ProseMirrorNode } from '@prosekit/pm/model';
 import { Schema } from '@prosekit/pm/model';
-import type { SchemaSpec } from '@prosekit/pm/model';
+import { SchemaSpec } from '@prosekit/pm/model';
 import { Selection as Selection_2 } from '@prosekit/pm/state';
 import { Selection as Selection_3 } from 'prosemirror-state';
 import type { Simplify } from 'type-fest';
@@ -72,6 +72,23 @@ export { addMark as addMark_alias_1 }
 
 export declare function applyAction(operator: Action): Command;
 
+/**
+ * @internal
+ */
+export declare function arrayRemove<T>(array: T[], item: T): void;
+
+/**
+ * @internal
+ */
+export declare function arraySubstract<T>(a: T[], b: T[]): T[];
+
+/**
+ * @internal
+ */
+declare function assert(condition: unknown, message?: string): asserts condition;
+export { assert }
+export { assert as assert_alias_1 }
+
 /**
  * Utility function assert that two types are equal in tests.
  */
@@ -79,26 +96,27 @@ export declare function assertTypeEqual<T, U>(_val: IsEqual<T, U>): void;
 
 export declare function attrsMatch(nodeOrMark: ProseMirrorNode | Mark, attrs: Attrs): boolean;
 
+/**
+ * @internal
+ */
 export declare abstract class BaseExtension<T extends ExtensionTyping = ExtensionTyping> implements Extension<T> {
     extension: Extension | Extension[];
     priority?: Priority;
     _type?: T;
+    private trees;
     /**
      * @internal
-     *
-     * Whether this extension has payload that can be converted to a schema.
-     *
-     * Notice that this does not mean that the extension has a schema. For
-     * example, a `FacetExtension` with a `schemaFacet` will return `true` for
-     * this property, but will return `null` for `schema`.
      */
-    abstract hasSchema: boolean;
+    abstract createTree(priority: Priority): FacetNode;
+    /**
+     * @internal
+     */
+    getTree(priority?: Priority): FacetNode;
     /**
      * @internal
-     *
-     * The schema that this extension represents.
      */
-    abstract schema: Schema | null;
+    findFacetOutput<I, O>(facet: Facet<I, O>): Tuple5<O | null> | null;
+    get schema(): Schema | null;
 }
 
 /**
@@ -127,6 +145,16 @@ declare interface BaseNodeViewOptions {
 export { BaseNodeViewOptions }
 export { BaseNodeViewOptions as BaseNodeViewOptions_alias_1 }
 
+export declare function baseToggleMark(markType: MarkType, attrs?: Attrs | null, options?: {
+    removeWhenPresent: boolean;
+}): Command;
+
+export declare function cache<T>(fn: () => T): () => T;
+
+declare const canUseRegexLookbehind: () => boolean;
+export { canUseRegexLookbehind }
+export { canUseRegexLookbehind as canUseRegexLookbehind_alias_1 }
+
 declare type ClickHandler = (view: EditorView, pos: number, event: MouseEvent) => boolean | void;
 export { ClickHandler }
 export { ClickHandler as ClickHandler_alias_1 }
@@ -170,14 +198,10 @@ export declare interface CommandCreators {
     [name: string]: CommandCreator;
 }
 
-export declare const commandFacet: Facet<CommandCreators, CommandCreators>;
+export declare const commandFacet: Facet<CommandCreators, RootPayload>;
 
 export declare type CommandPayload = CommandCreators;
 
-export declare type Converters = ConverterTuple[];
-
-declare type ConverterTuple = Tuple5<FacetConverter | undefined>;
-
 /**
  * @public
  */
@@ -189,6 +213,8 @@ export declare function createMarkBuilder(getState: () => EditorState | null | u
 
 export declare function createNodeBuilder(getState: () => EditorState | null | undefined, type: NodeType): NodeBuilder;
 
+export declare function deepEquals<T>(a: T, b: T): boolean;
+
 export declare const default_alias: Options | Options[] | ((overrideOptions: Options) => Options | Options[] | Promise<Options | Options[]>);
 
 export declare const default_alias_1: {
@@ -258,7 +284,7 @@ declare function defineBaseCommands(): Extension<{
             to?: number | undefined;
         }];
         setNodeAttrs: [options: {
-            type: string | NodeType_2;
+            type: string | NodeType_2 | string[] | NodeType_2[];
             attrs: Attrs_2;
             pos?: number | undefined;
         }];
@@ -380,6 +406,40 @@ declare function defineDropHandler(handler: DropHandler): Extension<ExtensionTyp
 export { defineDropHandler }
 export { defineDropHandler as defineDropHandler_alias_1 }
 
+/**
+ * @internal
+ */
+declare function defineFacet<Input, Output>(options: {
+    /**
+     * The parent facet in the tree.
+     */
+    parent: Facet<Output, any>;
+    /**
+     * Set this to true if you only want to keep one facet payload. For example,
+     * this facet corresponds to a ProseMirror plugin with a key.
+     */
+    singleton?: boolean;
+    /**
+     * A reducer is a function that accepts an array of input and produce a single
+     * output.
+     */
+    reducer?: FacetReducer<Input, Output>;
+    /**
+     * A callback function that returns a reducer. This is useful if you want to
+     * store something in the closure.
+     */
+    reduce?: () => FacetReducer<Input, Output>;
+}): Facet<Input, Output>;
+export { defineFacet }
+export { defineFacet as defineFacet_alias_1 }
+
+/**
+ * @internal
+ */
+declare function defineFacetPayload<Input>(facet: Facet<Input, any>, payloads: Input[]): Extension;
+export { defineFacetPayload }
+export { defineFacetPayload as defineFacetPayload_alias_1 }
+
 /**
  * Registers a event handler that is called when the editor gains or loses focus.
  *
@@ -874,9 +934,11 @@ export declare type ExtractNodesFromTyping<T extends ExtensionTyping> = ExtractK
 export declare type ExtractTyping<E extends Extension> = E extends Extension<infer T> ? T : never;
 
 /**
- * @public
+ * @internal
  */
 declare class Facet<Input, Output> {
+    private _reducer?;
+    private _reduce?;
     /**
      * @internal
      */
@@ -884,61 +946,61 @@ declare class Facet<Input, Output> {
     /**
      * @internal
      */
-    readonly converter: () => FacetConverter<Input, Output>;
-    /**
-     * @internal
-     */
-    readonly next: Facet<Output, any> | null;
+    readonly parent: Facet<Output, any> | null;
     /**
      * @internal
      */
     readonly singleton: boolean;
     /**
+     * A index path to retrieve the current facet in a tree from the root.
+     *
      * @internal
      */
-    isSchema: boolean;
-    private constructor();
-    static define<Input, Output>({ converter, convert, next, singleton, }: FacetOptions<Input, Output>): Facet<Input, Output>;
+    readonly path: number[];
     /**
      * @internal
      */
-    static defineRootFacet<Input>(options: Omit<FacetOptions<Input, Input>, 'next'>): Facet<Input, Input>;
-    extension(payloads: Input[]): Extension;
+    constructor(parent: Facet<Output, any> | null, singleton: boolean, _reducer?: FacetReducer<Input, Output> | undefined, _reduce?: (() => FacetReducer<Input, Output>) | undefined);
+    get reducer(): FacetReducer<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
+ * @internal
  */
 export declare class FacetExtensionImpl<Input, Output> extends BaseExtension {
     readonly facet: Facet<Input, Output>;
     readonly payloads: Input[];
     extension: Extension;
-    hasSchema: boolean;
-    schema: null;
+    /**
+     * @internal
+     */
     constructor(facet: Facet<Input, Output>, payloads: Input[]);
+    /**
+     * @internal
+     */
+    createTree(priority: Priority): FacetNode<any, any>;
+}
+
+export declare class FacetNode<I = any, O = any> {
+    readonly facet: Facet<I, O>;
+    readonly inputs: Tuple5<I[] | null>;
+    readonly children: Map<number, FacetNode>;
+    reducers: Tuple5<FacetReducer<I, O> | null>;
+    output: Tuple5<O | null> | null;
+    constructor(facet: Facet<I, O>, inputs?: Tuple5<I[] | null>, children?: Map<number, FacetNode>);
+    private calcOutput;
+    getOutput(): Tuple5<O | null>;
+    getSingletonOutput(): O | null;
+    getRootOutput(): RootOutput;
+    isRoot(): boolean;
 }
 
 /**
- * @public
+ * @internal
  */
-declare interface FacetOptions<Input, Output> {
-    convert?: (payloads: Input[]) => Output;
-    converter?: () => FacetConverter<Input, Output>;
-    next: Facet<Output, any>;
-    singleton?: boolean;
-}
-export { FacetOptions }
-export { FacetOptions as FacetOptions_alias_1 }
+export declare type FacetReducer<Input, Output> = (input: Input[]) => Output;
 
 export declare function findBrowserDocument(options?: {
     document?: Document;
@@ -969,8 +1031,6 @@ export declare function getBrowserWindow(options?: {
 
 export declare function getCustomSelection(state: EditorState, from?: number | null, to?: number | null): Selection_3;
 
-export declare function getFacetCount(): number;
-
 /**
  * Returns a unique id in the current process that can be used in various places.
  *
@@ -994,6 +1054,11 @@ declare function getNodeType(schema: Schema, type: string | NodeType): NodeType;
 export { getNodeType }
 export { getNodeType as getNodeType_alias_1 }
 
+/**
+ * @internal
+ */
+export declare function getNodeTypes(schema: Schema, types: string | NodeType | string[] | NodeType[]): NodeType[];
+
 export declare type GroupedEntries<T extends Record<string, any>> = {
     [K in keyof T]?: T[K][];
 };
@@ -1066,6 +1131,13 @@ declare function isAllSelection(sel: Selection_2): sel is AllSelection;
 export { isAllSelection }
 export { isAllSelection as isAllSelection_alias_1 }
 
+/**
+ * @private
+ */
+declare const isApple: boolean;
+export { isApple }
+export { isApple as isApple_alias_1 }
+
 export declare function isElement(value: unknown): value is Element;
 
 /**
@@ -1077,8 +1149,6 @@ declare function isInCodeBlock(selection: Selection_2): boolean | undefined;
 export { isInCodeBlock }
 export { isInCodeBlock as isInCodeBlock_alias_1 }
 
-export declare const isMac: boolean;
-
 /**
  * @internal
  */
@@ -1086,10 +1156,22 @@ declare function isMark(mark: unknown): mark is Mark;
 export { isMark }
 export { isMark as isMark_alias_1 }
 
+/**
+ * Returns true if the given mark is missing in some part of the range.
+ * Returns false if the entire range has the given mark.
+ *
+ * @internal
+ */
+declare function isMarkAbsent(node: ProseMirrorNode, from: number, to: number, markType: MarkType, attrs?: Attrs | null): boolean;
+export { isMarkAbsent }
+export { isMarkAbsent as isMarkAbsent_alias_1 }
+
 /**
  * @internal
  */
-export declare function isMarkActive(state: EditorState, type: string | MarkType, attrs?: Attrs | null): boolean;
+declare function isMarkActive(state: EditorState, type: string | MarkType, attrs?: Attrs | null): boolean;
+export { isMarkActive }
+export { isMarkActive as isMarkActive_alias_1 }
 
 export declare function isNodeActive(state: EditorState, type: string | NodeType, attrs?: Attrs | null): boolean;
 
@@ -1233,6 +1315,13 @@ declare interface MarkSpecOptions<MarkName extends string = string> extends Mark
 export { MarkSpecOptions }
 export { MarkSpecOptions as MarkSpecOptions_alias_1 }
 
+/**
+ * @internal
+ */
+declare function maybeRun<T, R = T extends (...args: any[]) => void ? ReturnType<T> : T>(value: T, ...args: T extends (...args: any[]) => void ? Parameters<T> : never): R;
+export { maybeRun }
+export { maybeRun as maybeRun_alias_1 }
+
 /**
  * A function that is called when the editor view is mounted.
  *
@@ -1262,8 +1351,19 @@ declare interface NodeAttrOptions {
      * of a type that has them is created.
      */
     default?: any;
+    /**
+     * Whether the attribute should be kept when the node is split. Set it to
+     * `true` if you want to inherit the attribute from the previous node when
+     * splitting the node by pressing `Enter`.
+     *
+     * @default undefined
+     */
+    splittable?: boolean;
     /**
      * Returns the attribute key and value to be set on the DOM node.
+     *
+     * If the `key` is `"style"`, the value is a string of CSS properties and will
+     * be prepended to the existing `style` attribute on the DOM node.
      */
     toDOM?: (value: any) => [key: string, value: string] | null | void;
     /**
@@ -1386,11 +1486,10 @@ declare type PasteHandler = (view: EditorView, event: ClipboardEvent, slice: Sli
 export { PasteHandler }
 export { PasteHandler as PasteHandler_alias_1 }
 
-declare type Payload = unknown;
-
-export declare type Payloads = PayloadTuple[];
-
-declare type PayloadTuple = Tuple5<Payload[]>;
+/**
+ * @internal
+ */
+export declare type Payloads<T> = Tuple5<T[]>;
 
 /**
  * @internal
@@ -1402,9 +1501,9 @@ export { pluginFacet as pluginFacet_alias_1 }
 /**
  * @internal
  */
-declare type PluginPayload = (context: {
+declare type PluginPayload = Plugin_2 | Plugin_2[] | ((context: {
     schema: Schema;
-}) => Plugin_2 | Plugin_2[];
+}) => Plugin_2 | Plugin_2[]);
 export { PluginPayload }
 export { PluginPayload as PluginPayload_alias_1 }
 
@@ -1414,11 +1513,11 @@ export { PluginPayload as PluginPayload_alias_1 }
  * @public
  */
 declare enum Priority {
-    lowest = 4,
-    low = 3,
+    lowest = 0,
+    low = 1,
     default = 2,
-    high = 1,
-    highest = 0
+    high = 3,
+    highest = 4
 }
 export { Priority }
 export { Priority as Priority_alias_1 }
@@ -1459,9 +1558,27 @@ declare function removeMark(options: {
 export { removeMark }
 export { removeMark as removeMark_alias_1 }
 
-export declare const schemaFacet: Facet<SchemaPayload, SchemaPayload>;
+export declare const rootFacet: Facet<RootPayload, RootOutput>;
+
+export declare type RootOutput = {
+    schema?: Schema | null;
+    commands?: CommandCreators;
+    state?: EditorStateConfig;
+    view?: Omit<DirectEditorProps, 'state'>;
+};
+
+export declare type RootPayload = {
+    schema?: Schema | null;
+    commands?: CommandCreators;
+    state?: (ctx: {
+        schema: Schema;
+    }) => EditorStateConfig;
+    view?: Omit<DirectEditorProps, 'state'>;
+};
+
+export declare const schemaFacet: Facet<SchemaSpec<any, any>, RootPayload>;
 
-export declare type SchemaPayload = SchemaSpec;
+export declare const schemaSpecFacet: Facet<SchemaSpec<any, any>, SchemaSpec<any, any>>;
 
 declare type ScrollToSelectionHandler = (view: EditorView) => boolean;
 export { ScrollToSelectionHandler }
@@ -1513,7 +1630,7 @@ declare function setNodeAttrs(options: {
      *
      * If current node is not of this type, the command will do nothing.
      */
-    type: string | NodeType;
+    type: string | NodeType | string[] | NodeType[];
     /**
      * The attributes to set.
      */
@@ -1552,7 +1669,14 @@ declare type SimplifyUnion<T> = Simplify<UnionToIntersection<T>>;
 export { SimplifyUnion }
 export { SimplifyUnion as SimplifyUnion_alias_1 }
 
-export declare const stateFacet: Facet<StatePayload, StatePayload>;
+export declare function splitBlockAs(splitNode?: (node: ProseMirrorNode, deflt: NodeType | null, atEnd: boolean) => {
+    type: NodeType;
+    attrs?: Attrs;
+} | null): Command;
+
+export declare const splitBlockEnter: Command;
+
+export declare const stateFacet: Facet<StatePayload, RootPayload>;
 
 /**
  * Parse a JSON object to a ProseMirror state.
@@ -1585,6 +1709,8 @@ export declare type StatePayload = (ctx: {
     schema: Schema;
 }) => EditorStateConfig;
 
+export declare function subtractFacetNode<I, O>(a: FacetNode<I, O>, b: FacetNode<I, O>): FacetNode<I, O>;
+
 declare type TextInputHandler = (view: EditorView, from: number, to: number, text: string) => boolean | void;
 export { TextInputHandler }
 export { TextInputHandler as TextInputHandler_alias_1 }
@@ -1626,6 +1752,8 @@ declare function toggleNode({ type, attrs, }: {
 export { toggleNode }
 export { toggleNode as toggleNode_alias_1 }
 
+export declare function toReversed<T>(arr: T[]): T[];
+
 declare type TripleClickHandler = (view: EditorView, pos: number, event: MouseEvent) => boolean | void;
 export { TripleClickHandler }
 export { TripleClickHandler as TripleClickHandler_alias_1 }
@@ -1634,7 +1762,10 @@ declare type TripleClickOnHandler = (view: EditorView, pos: number, node: Node_3
 export { TripleClickOnHandler }
 export { TripleClickOnHandler as TripleClickOnHandler_alias_1 }
 
-declare type Tuple5<T> = [T, T, T, T, T];
+/**
+ * @internal
+ */
+export declare type Tuple5<T> = [T, T, T, T, T];
 
 /**
  * Merge multiple extensions into one.
@@ -1647,13 +1778,18 @@ export { union as union_alias_1 }
 
 export declare class UnionExtensionImpl<T extends ExtensionTyping = ExtensionTyping> extends BaseExtension<T> implements Extension<T> {
     extension: BaseExtension[];
-    private _schema;
-    private hasSchemaCount;
+    /**
+     * @internal
+     */
     constructor(extension?: BaseExtension[]);
-    get hasSchema(): boolean;
-    get schema(): Schema | null;
+    /**
+     * @internal
+     */
+    createTree(priority: Priority): FacetNode;
 }
 
+export declare function unionFacetNode<I, O>(a: FacetNode<I, O>, b: FacetNode<I, O>): FacetNode<I, O>;
+
 export declare function uniqPush<T>(prev: readonly T[], next: readonly T[]): T[];
 
 export declare function uniqRemove<T>(prev: T[], next: T[]): T[];
@@ -1667,13 +1803,6 @@ declare type UnmountHandler = () => void;
 export { UnmountHandler }
 export { UnmountHandler as UnmountHandler_alias_1 }
 
-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;
-};
-
 /**
  * A function that is called when the editor state is updated.
  *
@@ -1686,7 +1815,7 @@ declare type UpdateHandler = (view: EditorView, prevState: EditorState) => void;
 export { UpdateHandler }
 export { UpdateHandler as UpdateHandler_alias_1 }
 
-export declare const viewFacet: Facet<ViewPayload, ViewPayload>;
+export declare const viewFacet: Facet<ViewPayload, RootPayload>;
 
 export declare type ViewPayload = Omit<DirectEditorProps, 'state'>;
 
@@ -1717,4 +1846,6 @@ export declare function wrap({ nodeType, attrs, }: {
     attrs?: Attrs | null;
 }): Command;
 
+export declare function zip<T, P>(a: T[], b: P[]): [T, P][];
+
 export { }

package/dist/prosekit-core.d.ts

@@ -77,8 +77,9 @@ export { definePlugin } from './_tsup-dts-rollup';
 export { pluginFacet } from './_tsup-dts-rollup';
 export { PluginPayload } from './_tsup-dts-rollup';
 export { defineText } from './_tsup-dts-rollup';
+export { defineFacet } from './_tsup-dts-rollup';
 export { Facet } from './_tsup-dts-rollup';
-export { FacetOptions } from './_tsup-dts-rollup';
+export { defineFacetPayload } from './_tsup-dts-rollup';
 export { BaseNodeViewOptions } from './_tsup-dts-rollup';
 export { CommandArgs } from './_tsup-dts-rollup';
 export { Extension } from './_tsup-dts-rollup';
@@ -93,12 +94,18 @@ 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 { assert } from './_tsup-dts-rollup';
+export { canUseRegexLookbehind } from './_tsup-dts-rollup';
 export { clsx } from './_tsup-dts-rollup';
 export { defaultBlockAt } from './_tsup-dts-rollup';
+export { isApple } from './_tsup-dts-rollup';
 export { _getId } from './_tsup-dts-rollup';
 export { getMarkType } from './_tsup-dts-rollup';
 export { getNodeType } from './_tsup-dts-rollup';
 export { isInCodeBlock } from './_tsup-dts-rollup';
+export { isMarkAbsent } from './_tsup-dts-rollup';
+export { isMarkActive } from './_tsup-dts-rollup';
+export { maybeRun } from './_tsup-dts-rollup';
 export { elementFromJSON } from './_tsup-dts-rollup';
 export { elementFromNode } from './_tsup-dts-rollup';
 export { htmlFromJSON } from './_tsup-dts-rollup';