@prosekit/core 0.0.12 → 0.0.14

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

@@ -1,4 +1,5 @@
 import { Attrs } from '@prosekit/pm/model';
+import { Attrs as Attrs_2 } from 'prosemirror-model';
 import { Command } from '@prosekit/pm/state';
 import type { ConditionalExcept } from 'type-fest';
 import type { DirectEditorProps } from '@prosekit/pm/view';
@@ -11,8 +12,10 @@ import type { IsEqual } from 'type-fest';
 import { Mark } from '@prosekit/pm/model';
 import type { MarkSpec } from '@prosekit/pm/model';
 import { MarkType } from '@prosekit/pm/model';
+import { Node as Node_2 } from 'prosemirror-model';
 import type { NodeSpec } from '@prosekit/pm/model';
 import { NodeType } from '@prosekit/pm/model';
+import { NodeType as NodeType_2 } from 'prosemirror-model';
 import { NodeViewConstructor } from '@prosekit/pm/view';
 import { Options } from 'tsup';
 import { Plugin as Plugin_2 } from '@prosekit/pm/state';
@@ -30,11 +33,7 @@ declare type Action = (options: {
     view?: EditorView;
 }) => boolean;
 
-declare function addMark(options: AddMarkOptions): Command;
-export { addMark }
-export { addMark as addMark_alias_1 }
-
-declare interface AddMarkOptions {
+declare function addMark(options: {
     type: string | MarkType;
     attrs?: Attrs | null;
     /**
@@ -45,11 +44,9 @@ declare interface AddMarkOptions {
      * 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 type AnySlot = Slot<any, any>;
+}): Command;
+export { addMark }
+export { addMark as addMark_alias_1 }
 
 export declare function applyAction(operator: Action): Command;
 
@@ -78,9 +75,13 @@ export declare interface CommandCreators {
     [name: string]: CommandCreator;
 }
 
-export declare const commandSlot: Facet<CommandSlotInput, CommandSlotInput>;
+export declare const commandFacet: Facet<CommandCreators, CommandCreators>;
+
+export declare type CommandPayload = CommandCreators;
 
-export declare type CommandSlotInput = Record<string, CommandCreator<any>>;
+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>;
@@ -121,19 +122,14 @@ declare function defineBaseCommands(): Extension<{
             to?: number | undefined;
         }];
         insertNode: [{
-            node: ProseMirrorNode;
+            node: Node_2;
             pos?: number | undefined;
         }];
         wrap: [{
-            nodeType: NodeType;
-            attrs?: Attrs | null | undefined;
-        }];
-        setBlockType: [{
-            nodeType: NodeType;
-            attrs?: Attrs | null | undefined;
-            from?: number | undefined;
-            to?: number | undefined;
+            nodeType: NodeType_2;
+            attrs?: Attrs_2 | null | undefined;
         }];
+        setBlockType: [nodeType: NodeType_2, attrs?: Attrs_2 | null | undefined];
         selectAll: [];
     };
 }>;
@@ -169,7 +165,7 @@ export { defineDoc as defineDoc_alias_1 }
  */
 declare function defineEventHandler(options: {
     update?: VoidFunction;
-}): FacetExtension<VoidFunction, PluginFacetInput>;
+}): FacetExtension<VoidFunction, PluginPayload>;
 export { defineEventHandler }
 export { defineEventHandler as defineEventHandler_alias_1 }
 
@@ -221,6 +217,10 @@ declare function defineNodeView(options: NodeViewOptions): Extension;
 export { defineNodeView }
 export { defineNodeView as defineNodeView_alias_1 }
 
+declare function defineNodeViewEffect(options: NodeViewEffectOptions): Extension;
+export { defineNodeViewEffect }
+export { defineNodeViewEffect as defineNodeViewEffect_alias_1 }
+
 /** @public */
 declare function defineParagraph(): Extension<    {
 NODES: "paragraph";
@@ -377,40 +377,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 }
@@ -421,17 +426,30 @@ 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 function insertNode(options: {
+    node: ProseMirrorNode;
+    pos?: number;
+}): Command;
 
-declare type InputTuple = [Input[], Input[], Input[], Input[], Input[]];
+declare function insertNode(options: {
+    attrs?: Attrs;
+    type: string;
+    pos?: number;
+}): Command;
+export { insertNode }
+export { insertNode as insertNode_alias_1 }
 
-export declare function insertNode({ node, pos, }: {
+export declare function insertNode_alias_2({ node, pos, }: {
     node: ProseMirrorNode;
     pos?: number;
 }): Action;
 
+export declare function insertText({ text, from, to, }: {
+    text: string;
+    from?: number;
+    to?: number;
+}): Command;
+
 export declare const isMac: boolean;
 
 export declare function isMark(mark: unknown): mark is Mark;
@@ -499,6 +517,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;
@@ -508,17 +538,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
@@ -541,7 +577,11 @@ 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;
+
+export declare function selectAll(): Command;
 
 /**
  * A JSON representation of the prosemirror selection.
@@ -556,6 +596,13 @@ declare interface SelectionJson {
 export { SelectionJson }
 export { SelectionJson as SelectionJson_alias_1 }
 
+export declare function setBlockType({ nodeType, attrs, from, to, }: {
+    nodeType: NodeType;
+    attrs?: Attrs | null;
+    from?: number;
+    to?: number;
+}): Command;
+
 /**
  * @internal
  */
@@ -574,35 +621,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.
@@ -622,7 +641,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]>;
@@ -636,27 +657,21 @@ export declare type ToCommandCreators<T extends CommandArgs> = {
     [K in keyof T]: CommandCreator<T[K]>;
 };
 
-declare function toggleMark(options: ToggleMarkOptions): Command;
+declare function toggleMark({ type, attrs, }: {
+    type: string | MarkType;
+    attrs?: Attrs | null;
+}): Command;
 export { toggleMark }
 export { toggleMark as toggleMark_alias_1 }
 
-declare interface ToggleMarkOptions {
-    type: string | MarkType;
+declare function toggleNode({ type, attrs, }: {
+    type: string | NodeType;
     attrs?: Attrs | null;
-}
-export { ToggleMarkOptions }
-export { ToggleMarkOptions as ToggleMarkOptions_alias_1 }
-
-declare function toggleNode(options: ToggleNodeOptions): Command;
+}): 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 }
+declare type Tuple5<T> = [T, T, T, T, T];
 
 declare function union<E extends Extension | Extension[]>(extension: E): SimplifyExtension<E>;
 export { union }
@@ -666,18 +681,16 @@ 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;
 
@@ -686,4 +699,9 @@ declare function withPriority<T extends Extension>(extension: T, priority: Prior
 export { withPriority }
 export { withPriority as withPriority_alias_1 }
 
+export declare function wrap({ nodeType, attrs, }: {
+    nodeType: NodeType;
+    attrs?: Attrs | null;
+}): Command;
+
 export { }

package/dist/prosekit-core.d.ts

@@ -1,9 +1,7 @@
 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 { insertNode } 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';
@@ -30,10 +28,12 @@ export { defineNodeSpec } from './_tsup-dts-rollup';
 export { NodeSpecOptions } from './_tsup-dts-rollup';
 export { defineNodeView } from './_tsup-dts-rollup';
 export { NodeViewOptions } 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 { PluginPayload } from './_tsup-dts-rollup';
 export { defineText } from './_tsup-dts-rollup';
 export { CommandArgs } from './_tsup-dts-rollup';
 export { Extension } from './_tsup-dts-rollup';
@@ -50,6 +50,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';

package/dist/prosekit-core.js

@@ -40,19 +40,21 @@ function addMark(options) {
 import { toggleMark as baseToggleMark } from "@prosekit/pm/commands";
 import "@prosekit/pm/model";
 import "@prosekit/pm/state";
-function toggleMark(options) {
+function toggleMark({
+  type,
+  attrs
+}) {
   return (state, dispatch, view) => {
-    return baseToggleMark(
-      getMarkType(state.schema, options.type),
-      options.attrs
-    )(state, dispatch, view);
+    return baseToggleMark(getMarkType(state.schema, type), attrs)(
+      state,
+      dispatch,
+      view
+    );
   };
 }
 
-// src/commands/toggle-node.ts
-import { setBlockType } from "@prosekit/pm/commands";
-import "@prosekit/pm/model";
-import "@prosekit/pm/state";
+// src/commands/insert-node.ts
+import { insertPoint } from "@prosekit/pm/transform";
 
 // src/utils/get-node-type.ts
 import "@prosekit/pm/model";
@@ -67,6 +69,34 @@ function getNodeType(schema, type) {
   return type;
 }
 
+// src/commands/insert-node.ts
+function insertNode(options) {
+  return (state, dispatch) => {
+    var _a;
+    const node = options.node ? options.node : options.type ? getNodeType(state.schema, options.type).createChecked(options.attrs) : null;
+    if (!node) {
+      throw new ProseKitError("You must provide either a node or a type");
+    }
+    const insertPos = insertPoint(
+      state.doc,
+      (_a = options.pos) != null ? _a : state.selection.to,
+      node.type
+    );
+    if (insertPos == null)
+      return false;
+    if (dispatch) {
+      const tr = state.tr.insert(insertPos, node);
+      dispatch(tr);
+    }
+    return true;
+  };
+}
+
+// src/commands/toggle-node.ts
+import { setBlockType } from "@prosekit/pm/commands";
+import "@prosekit/pm/model";
+import "@prosekit/pm/state";
+
 // src/utils/object-euqal.ts
 function objectEqual(a, b) {
   if (a === b) {
@@ -111,17 +141,20 @@ function isNodeActive(state, type, attrs) {
 }
 
 // src/commands/toggle-node.ts
-function toggleNode(options) {
+function toggleNode({
+  type,
+  attrs
+}) {
   return (state, dispatch, view) => {
-    if (isNodeActive(state, options.type, options.attrs)) {
+    if (isNodeActive(state, type, attrs)) {
       const defaultType = state.schema.topNodeType.contentMatch.defaultType;
       if (!defaultType) {
         return false;
       }
       return setBlockType(defaultType)(state, dispatch, view);
     } else {
-      const nodeType = getNodeType(state.schema, options.type);
-      return setBlockType(nodeType, options.attrs)(state, dispatch, view);
+      const nodeType = getNodeType(state.schema, type);
+      return setBlockType(nodeType, attrs)(state, dispatch, view);
     }
   };
 }
@@ -134,9 +167,6 @@ import { EditorView } from "@prosekit/pm/view";
 // src/extensions/default-state.ts
 import { Selection } from "@prosekit/pm/state";
 
-// src/editor/slots.ts
-import OrderedMap from "orderedmap";
-
 // src/utils/uniq-array.ts
 function uniqPush(prev, next) {
   const result = [...prev];
@@ -158,115 +188,50 @@ function uniqRemove(prev, next) {
   return result;
 }
 
-// src/editor/facet.ts
-var nextIndex = 0;
+// src/facets/facet.ts
+var facetCount = 0;
+function getFacetCount() {
+  return facetCount;
+}
 var Facet = class _Facet {
-  constructor(slot, next, single) {
+  constructor(converter, next) {
     /** @internal */
-    this.index = nextIndex++;
-    this.slot = slot;
+    this.index = facetCount++;
+    this.converter = converter;
     this.next = next;
-    this.single = single;
   }
   static define({
-    slot,
-    combine,
-    next,
-    single
+    converter,
+    convert,
+    next
   }) {
-    const slotFn = slot ? slot : combine ? () => ({
-      create: combine,
-      update: combine
+    const converterFunction = converter ? converter : convert ? () => ({
+      create: convert,
+      update: convert
     }) : null;
-    if (!slotFn) {
-      throw new ProseKitError(
-        "Facet must have either 'slot' or 'combine' option"
-      );
+    if (!converterFunction) {
+      throw new ProseKitError("Facet must have either 'convert' or 'converter'");
     }
-    return new _Facet(slotFn, next, single != null ? single : false);
+    return new _Facet(converterFunction, next);
   }
   /** @internal */
-  static defineSlot(options) {
+  static defineRootFacet(options) {
     return _Facet.define(options);
   }
-  extension(inputs) {
-    return new FacetExtension(this, inputs);
+  extension(payloads) {
+    return new FacetExtension(this, payloads);
   }
 };
 var FacetExtension = class {
-  constructor(facet, inputs) {
+  constructor(facet, payloads) {
     this.facet = facet;
-    this.inputs = inputs;
+    this.payloads = payloads;
   }
 };
-function sortFacets(unsorted) {
-  var _a;
-  const facets = unsorted.filter((val) => val);
-  const facetMap = [];
-  const inbounds = [];
-  let facetCount = 0;
-  for (const facet of facets) {
-    const index = facet.index;
-    if (facetMap[index] != null) {
-      continue;
-    }
-    if (inbounds[index] == null) {
-      inbounds[index] = 0;
-    }
-    facetCount++;
-    facetMap[index] = facet;
-    if (facet.next) {
-      const nextIndex2 = facet.next.index;
-      if (inbounds[nextIndex2] == null) {
-        inbounds[nextIndex2] = 0;
-      }
-      inbounds[nextIndex2] += 1;
-      if (facetMap[nextIndex2] == null) {
-        facets.push(facet.next);
-      }
-    }
-  }
-  const sortedFacets = [];
-  const sortedIndexes = [];
-  inbounds.forEach((inbound, index) => {
-    if (inbound === 0) {
-      sortedIndexes.push(index);
-    }
-  });
-  for (const index of sortedIndexes) {
-    const facet = facetMap[index];
-    sortedFacets.push(facet);
-    const nextIndex2 = (_a = facet.next) == null ? void 0 : _a.index;
-    if (nextIndex2 == null)
-      continue;
-    inbounds[nextIndex2] -= 1;
-    if (inbounds[nextIndex2] === 0) {
-      sortedIndexes.push(nextIndex2);
-    }
-  }
-  if (facetCount !== sortedFacets.length) {
-    throw new ProseKitError(`Facet has circular dependency`);
-  }
-  return sortedFacets;
-}
 
-// src/editor/slots.ts
-var schemaSlot = Facet.defineSlot({
-  combine: (specs) => {
-    var _a;
-    let nodes = OrderedMap.from({});
-    let marks = OrderedMap.from({});
-    let topNode = void 0;
-    for (const spec of specs) {
-      nodes = nodes.append(spec.nodes);
-      marks = marks.append((_a = spec.marks) != null ? _a : {});
-      topNode = topNode != null ? topNode : spec.topNode;
-    }
-    return { nodes, marks, topNode };
-  }
-});
-var stateSlot = Facet.defineSlot({
-  combine: (callbacks) => {
+// src/facets/state.ts
+var stateFacet = Facet.defineRootFacet({
+  convert: (callbacks) => {
     return (ctx) => {
       var _a, _b, _c, _d, _e, _f;
       const configs = callbacks.map((cb) => cb(ctx));
@@ -294,20 +259,10 @@ var stateSlot = Facet.defineSlot({
     };
   }
 });
-var viewSlot = Facet.defineSlot({
-  combine: (props) => {
-    return Object.assign({}, ...props);
-  }
-});
-var commandSlot = Facet.defineSlot({
-  combine: (inputs) => {
-    return Object.assign({}, ...inputs);
-  }
-});
 
 // src/extensions/default-state.ts
 function defineDefaultState(options) {
-  return stateSlot.extension([
+  return stateFacet.extension([
     ({ schema }) => {
       const config = {};
       if (options.doc) {
@@ -417,6 +372,37 @@ function isNodeChild(value) {
   return typeof value === "string" || Array.isArray(value) || isProseMirrorNode(value);
 }
 
+// src/facets/command.ts
+var commandFacet = Facet.defineRootFacet({
+  convert: (inputs) => {
+    return Object.assign({}, ...inputs);
+  }
+});
+
+// src/facets/schema.ts
+import OrderedMap from "orderedmap";
+var schemaFacet = Facet.defineRootFacet({
+  convert: (specs) => {
+    var _a;
+    let nodes = OrderedMap.from({});
+    let marks = OrderedMap.from({});
+    let topNode = void 0;
+    for (const spec of specs) {
+      nodes = nodes.append(spec.nodes);
+      marks = marks.append((_a = spec.marks) != null ? _a : {});
+      topNode = topNode != null ? topNode : spec.topNode;
+    }
+    return { nodes, marks, topNode };
+  }
+});
+
+// src/facets/view.ts
+var viewFacet = Facet.defineRootFacet({
+  convert: (props) => {
+    return Object.assign({}, ...props);
+  }
+});
+
 // src/types/priority.ts
 var Priority = /* @__PURE__ */ ((Priority2) => {
   Priority2[Priority2["lowest"] = 4] = "lowest";
@@ -472,7 +458,7 @@ function extractFacets(root) {
   const extensions = [root];
   const priorities = [2 /* default */];
   const facets = [];
-  const inputs = [];
+  const payloads = [];
   while (extensions.length > 0) {
     const ext = extensions.pop();
     const pri = priorities.pop();
@@ -480,10 +466,10 @@ function extractFacets(root) {
       const facet = ext.facet;
       if (!facets[facet.index]) {
         facets[facet.index] = facet;
-        inputs[facet.index] = [[], [], [], [], []];
+        payloads[facet.index] = [[], [], [], [], []];
       }
-      const facetInputs = ext.inputs;
-      inputs[facet.index][pri].push(...facetInputs);
+      const facetPayloads = ext.payloads;
+      payloads[facet.index][pri].push(...facetPayloads);
     } else if (ext.extension) {
       const p = (_a = ext.priority) != null ? _a : pri;
       if (Array.isArray(ext.extension)) {
@@ -499,25 +485,31 @@ function extractFacets(root) {
       throw new ProseKitError("Invalid extension");
     }
   }
-  return [facets, inputs];
+  return [facets, payloads];
 }
-function updateExtension(prevInputs, prevSlots, extension, mode) {
+function updateExtension(prevInputs, prevConverters, extension, mode) {
+  var _a;
   const modifyInputTuple = mode === "add" ? mergeInputTuple : removeInputTuple;
   const [facets, inputs] = extractFacets(extension);
   let schemaInput = null;
   let stateInput = null;
   let viewInput = null;
   let commandInput = null;
-  for (const facet of sortFacets(facets)) {
+  for (let index = getFacetCount(); index >= 0; index--) {
+    const facet = facets[index];
+    if (!facet) {
+      continue;
+    }
+    const nextFacet = facet.next;
+    if (nextFacet) {
+      facets[_a = nextFacet.index] || (facets[_a] = nextFacet);
+    }
     if (!inputs[facet.index]) {
       continue;
     }
-    const inputTuple = modifyInputTuple(
-      prevInputs[facet.index],
-      inputs[facet.index]
-    );
-    prevInputs[facet.index] = inputTuple;
-    if (facet.next && !facet.single) {
+    const inputTuple = modifyInputTuple(prevInputs[index], inputs[index]);
+    prevInputs[index] = inputTuple;
+    if (facet.next) {
       let hasOutput = false;
       const outputTuple = [[], [], [], [], []];
       for (let pri = 0; pri < 5; pri++) {
@@ -525,17 +517,17 @@ function updateExtension(prevInputs, prevSlots, extension, mode) {
         if (inputArray.length === 0) {
           continue;
         }
-        const slotTuple = prevSlots[facet.index] || (prevSlots[facet.index] = [
+        const converterTuple = prevConverters[index] || (prevConverters[index] = [
           void 0,
           void 0,
           void 0,
           void 0,
           void 0
         ]);
-        const prevSlot = slotTuple[pri];
-        const slot = prevSlot || facet.slot();
-        prevSlots[facet.index][pri] = slot;
-        const output = prevSlot ? slot.update(inputArray) : slot.create(inputArray);
+        const prevConverter = converterTuple[pri];
+        const converter = prevConverter || facet.converter();
+        prevConverters[index][pri] = converter;
+        const output = prevConverter ? converter.update(inputArray) : converter.create(inputArray);
         if (!output) {
           continue;
         }
@@ -552,44 +544,35 @@ function updateExtension(prevInputs, prevSlots, extension, mode) {
       continue;
     } else {
       const inputArray = flattenInputTuple(inputTuple);
-      const slotTuple = prevSlots[facet.index] || (prevSlots[facet.index] = [
+      const converterTuple = prevConverters[index] || (prevConverters[index] = [
         void 0,
         void 0,
         void 0,
         void 0,
         void 0
       ]);
-      const prevSlot = slotTuple[2 /* default */];
-      const slot = prevSlot || facet.slot();
-      prevSlots[facet.index][2 /* default */] = slot;
-      const output = prevSlot ? slot.update(inputArray) : slot.create(inputArray);
+      const prevConverter = converterTuple[2 /* default */];
+      const converter = prevConverter || facet.converter();
+      prevConverters[index][2 /* default */] = converter;
+      const output = prevConverter ? converter.update(inputArray) : converter.create(inputArray);
       if (!output) {
         continue;
       }
-      const outputTuple = [[], [], [output], [], []];
-      if (facet.next) {
-        inputs[facet.next.index] = modifyInputTuple(
-          inputs[facet.next.index],
-          outputTuple
-        );
-        continue;
-      } else {
-        switch (facet) {
-          case schemaSlot:
-            schemaInput = output;
-            break;
-          case stateSlot:
-            stateInput = output;
-            break;
-          case viewSlot:
-            viewInput = output;
-            break;
-          case commandSlot:
-            commandInput = output;
-            break;
-          default:
-            throw new ProseKitError("Invalid facet");
-        }
+      switch (facet) {
+        case schemaFacet:
+          schemaInput = output;
+          break;
+        case stateFacet:
+          stateInput = output;
+          break;
+        case viewFacet:
+          viewInput = output;
+          break;
+        case commandFacet:
+          commandInput = output;
+          break;
+        default:
+          throw new ProseKitError("Invalid root facet");
       }
     }
   }
@@ -625,11 +608,11 @@ var EditorInstance = class {
   constructor(extension) {
     this.view = null;
     this.commandAppliers = {};
-    this.inputs = [];
-    this.slots = [];
+    this.payloads = [];
+    this.converters = [];
     this.mount = this.mount.bind(this);
     this.unmount = this.unmount.bind(this);
-    const { schemaInput, stateInput, viewInput, commandInput } = updateExtension(this.inputs, this.slots, extension, "add");
+    const { schemaInput, stateInput, viewInput, commandInput } = updateExtension(this.payloads, this.converters, extension, "add");
     if (!schemaInput) {
       throw new ProseKitError("Schema must be defined");
     }
@@ -662,7 +645,7 @@ var EditorInstance = class {
   }
   updateExtension(extension, mode) {
     var _a;
-    const { schemaInput, stateInput, viewInput, commandInput } = updateExtension(this.inputs, this.slots, extension, mode);
+    const { schemaInput, stateInput, viewInput, commandInput } = updateExtension(this.payloads, this.converters, extension, mode);
     if (schemaInput) {
       throw new ProseKitError("Schema cannot be changed");
     }
@@ -703,8 +686,9 @@ var EditorInstance = class {
     this.view = null;
   }
   get assertView() {
-    if (!this.view)
+    if (!this.view) {
       throw new ProseKitError("Editor is not mounted");
+    }
     return this.view;
   }
   definePlugins(plugins) {
@@ -825,77 +809,83 @@ function withPriority(extension, priority) {
 }
 
 // src/extensions/command.ts
-import "@prosekit/pm/model";
+import { setBlockType as setBlockType2 } from "@prosekit/pm/commands";
+
+// src/commands/insert-text.ts
+function insertText({
+  text,
+  from,
+  to
+}) {
+  return (state, dispatch) => {
+    if (text) {
+      dispatch == null ? void 0 : dispatch(state.tr.insertText(text, from, to));
+    }
+    return true;
+  };
+}
+
+// src/commands/select-all.ts
 import { AllSelection } from "@prosekit/pm/state";
-import { findWrapping, insertPoint } from "@prosekit/pm/transform";
+function selectAll() {
+  return (state, dispatch) => {
+    dispatch == null ? void 0 : dispatch(state.tr.setSelection(new AllSelection(state.doc)));
+    return true;
+  };
+}
+
+// src/commands/wrap.ts
+import "@prosekit/pm/model";
+import "@prosekit/pm/state";
+import { findWrapping } from "@prosekit/pm/transform";
+function wrap({
+  nodeType,
+  attrs
+}) {
+  return (state, dispatch) => {
+    const { $from, $to } = state.selection;
+    const range = $from.blockRange($to);
+    if (!range)
+      return false;
+    const wrapping = findWrapping(range, nodeType, attrs);
+    if (!wrapping)
+      return false;
+    dispatch == null ? void 0 : dispatch(state.tr.wrap(range, wrapping));
+    return true;
+  };
+}
+
+// src/extensions/actions.ts
+import "@prosekit/pm/model";
+import { Selection as Selection2 } from "@prosekit/pm/state";
+import { insertPoint as insertPoint2 } from "@prosekit/pm/transform";
+function insertNode2({
+  node,
+  pos
+}) {
+  return ({ tr }) => {
+    const insertPos = insertPoint2(tr.doc, pos != null ? pos : tr.selection.to, node.type);
+    if (insertPos == null) {
+      return false;
+    }
+    tr.insert(insertPos, node);
+    const $pos = tr.doc.resolve(insertPos);
+    tr.setSelection(Selection2.near($pos));
+    return true;
+  };
+}
+
+// src/extensions/command.ts
 function defineCommands(commands) {
-  return commandSlot.extension([commands]);
+  return commandFacet.extension([commands]);
 }
 function defineBaseCommands() {
   return defineCommands({
-    insertText: ({
-      text,
-      from,
-      to
-    }) => {
-      return (state, dispatch) => {
-        if (text) {
-          dispatch == null ? void 0 : dispatch(state.tr.insertText(text, from, to));
-        }
-        return true;
-      };
-    },
-    insertNode: ({ node, pos }) => {
-      return (state, dispatch) => {
-        const insertPos = insertPoint(
-          state.doc,
-          pos != null ? pos : state.selection.to,
-          node.type
-        );
-        if (insertPos == null)
-          return false;
-        if (dispatch) {
-          const tr = state.tr.insert(insertPos, node);
-          dispatch(tr);
-        }
-        return true;
-      };
-    },
-    wrap: ({
-      nodeType,
-      attrs
-    }) => {
-      return (state, dispatch) => {
-        const { $from, $to } = state.selection;
-        const range = $from.blockRange($to);
-        if (!range)
-          return false;
-        const wrapping = findWrapping(range, nodeType, attrs);
-        if (!wrapping)
-          return false;
-        dispatch == null ? void 0 : dispatch(state.tr.wrap(range, wrapping));
-        return true;
-      };
-    },
-    setBlockType: ({
-      nodeType,
-      attrs,
-      from,
-      to
-    }) => {
-      return (state, dispatch) => {
-        from = from != null ? from : state.selection.from;
-        to = from != null ? from : state.selection.from;
-        dispatch == null ? void 0 : dispatch(state.tr.setBlockType(from, to, nodeType, attrs));
-        return true;
-      };
-    },
-    selectAll: () => {
-      return (state, dispatch) => {
-        dispatch == null ? void 0 : dispatch(state.tr.setSelection(new AllSelection(state.doc)));
-        return true;
-      };
-    }
+    insertText,
+    insertNode: insertNode2,
+    wrap,
+    setBlockType: setBlockType2,
+    selectAll
   });
 }
 
@@ -904,7 +894,7 @@ function defineNodeSpec(options) {
   return nodeSpecFacet.extension([options]);
 }
 var nodeSpecFacet = Facet.define({
-  combine: (options) => {
+  convert: (options) => {
     const nodes = {};
     let topNodeName = void 0;
     for (const { name, topNode, ...spec } of options) {
@@ -918,7 +908,7 @@ var nodeSpecFacet = Facet.define({
     }
     return { nodes, topNode: topNodeName };
   },
-  next: schemaSlot
+  next: schemaFacet
 });
 
 // src/extensions/doc.ts
@@ -952,13 +942,13 @@ function definePlugin(plugin) {
   throw new TypeError("Invalid plugin");
 }
 var pluginFacet = Facet.define({
-  combine: (callbacks) => {
+  convert: (callbacks) => {
     return ({ schema }) => {
       const plugins = callbacks.flatMap((func) => func({ schema }));
       return { plugins };
     };
   },
-  next: stateSlot
+  next: stateFacet
 });
 
 // src/extensions/event-handler.ts
@@ -968,7 +958,7 @@ function defineEventHandler(options) {
   return eventFacet.extension([updateHandler]);
 }
 var eventFacet = Facet.define({
-  slot: () => {
+  converter: () => {
     let updateHandlers = [];
     const plugin = new ProseMirrorPlugin({
       key: pluginKey,
@@ -993,8 +983,7 @@ var eventFacet = Facet.define({
       }
     };
   },
-  next: pluginFacet,
-  single: true
+  next: pluginFacet
 });
 var pluginKey = new PluginKey("prosekit-event-handler");
 
@@ -1015,7 +1004,7 @@ function defineBaseKeymap() {
   return defineKeymap(baseKeymap);
 }
 var keymapFacet = Facet.define({
-  slot: () => {
+  converter: () => {
     let handler = null;
     const handlerWrapper = (view, event) => {
       if (handler)
@@ -1038,8 +1027,7 @@ var keymapFacet = Facet.define({
       }
     };
   },
-  next: pluginFacet,
-  single: true
+  next: pluginFacet
 });
 function mergeKeymaps(keymaps) {
   const bindings = {};
@@ -1085,7 +1073,7 @@ function defineInputRule(rules) {
   return inputRuleFacet.extension([rules]);
 }
 var inputRuleFacet = Facet.define({
-  combine: (inputs) => {
+  convert: (inputs) => {
     return (context) => {
       const rules = inputs.flatMap((callback) => callback(context));
       return [inputRules({ rules })];
@@ -1099,7 +1087,7 @@ function defineMarkSpec(options) {
   return markSpecFacet.extension([options]);
 }
 var markSpecFacet = Facet.define({
-  combine: (options) => {
+  convert: (options) => {
     const marks = {};
     for (const { name, ...spec } of options) {
       if (marks[name]) {
@@ -1109,24 +1097,58 @@ var markSpecFacet = Facet.define({
     }
     return { marks, nodes: {} };
   },
-  next: schemaSlot
+  next: schemaFacet
 });
 
 // src/extensions/node-view.ts
-import { Plugin as Plugin5 } from "@prosekit/pm/state";
+import { ProseMirrorPlugin as ProseMirrorPlugin2 } from "@prosekit/pm/state";
 import "@prosekit/pm/view";
 function defineNodeView(options) {
   return nodeViewFacet.extension([options]);
 }
 var nodeViewFacet = Facet.define({
-  combine: (inputs) => {
+  convert: (inputs) => {
     const nodeViews = {};
     for (const input of inputs) {
       if (!nodeViews[input.name]) {
         nodeViews[input.name] = input.constructor;
       }
     }
-    return () => [new Plugin5({ props: { nodeViews } })];
+    return () => [new ProseMirrorPlugin2({ props: { nodeViews } })];
+  },
+  next: pluginFacet
+});
+
+// src/extensions/node-view-effect.ts
+import { ProseMirrorPlugin as ProseMirrorPlugin3 } from "@prosekit/pm/state";
+import "@prosekit/pm/view";
+function defineNodeViewEffect(options) {
+  return nodeViewEffectFacet.extension([options]);
+}
+var nodeViewEffectFacet = Facet.define({
+  convert: (inputs) => {
+    const nodeViews = {};
+    const options = {};
+    const factories = {};
+    for (const input of inputs) {
+      const group = input.group;
+      if (input.name == null) {
+        factories[group] = input.factory;
+      } else {
+        options[group] || (options[group] = []);
+        options[group].push({
+          name: input.name,
+          args: input.args
+        });
+      }
+    }
+    for (const [group, factory] of Object.entries(factories)) {
+      const groupOptions = options[group] || [];
+      for (const { name, args } of groupOptions) {
+        nodeViews[name] = factory(args);
+      }
+    }
+    return () => Object.keys(nodeViews).length > 0 ? [new ProseMirrorPlugin3({ props: { nodeViews } })] : [];
   },
   next: pluginFacet
 });
@@ -1171,11 +1193,13 @@ export {
   defineMarkSpec,
   defineNodeSpec,
   defineNodeView,
+  defineNodeViewEffect,
   defineParagraph,
   definePlugin,
   defineText,
   getMarkType,
   getNodeType,
+  insertNode,
   pluginFacet,
   toggleMark,
   toggleNode,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@prosekit/core",
   "type": "module",
-  "version": "0.0.12",
+  "version": "0.0.14",
   "private": false,
   "author": {
     "name": "ocavue",
@@ -40,7 +40,7 @@
   "dependencies": {
     "@prosekit/pm": "^0.0.6",
     "orderedmap": "^2.1.1",
-    "type-fest": "^4.4.0"
+    "type-fest": "^4.5.0"
   },
   "devDependencies": {
     "@prosekit/dev": "*",

package/src/index.ts

@@ -1,8 +1,9 @@
-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 } from './commands/add-mark'
+export { toggleMark } from './commands/toggle-mark'
+export { insertNode } from './commands/insert-node'
+export { toggleNode } from './commands/toggle-node'
 export { Editor, createEditor, type EditorOptions } from './editor/editor'
-export { Facet, FacetExtension, type FacetOptions } from './editor/facet'
+export { Facet, FacetExtension, type FacetOptions } from './facets/facet'
 export { union } from './editor/type-utils'
 export { withPriority } from './editor/with-priority'
 export { ProseKitError } from './error'
@@ -23,15 +24,18 @@ export {
 export { defineMarkSpec, type MarkSpecOptions } from './extensions/mark-spec'
 export { defineNodeSpec, type NodeSpecOptions } from './extensions/node-spec'
 export { defineNodeView, type NodeViewOptions } from './extensions/node-view'
+export {
+  defineNodeViewEffect,
+  type NodeViewEffectOptions,
+} from './extensions/node-view-effect'
 export { defineParagraph } from './extensions/paragraph'
 export {
   definePlugin,
   pluginFacet,
-  type PluginFacetInput,
+  type PluginPayload,
 } from './extensions/plugin'
 export { defineText } from './extensions/text'
 export { type CommandArgs as CommandArgs } from './types/command'
-export * from './types/editor'
 export {
   type Extension,
   type ExtractCommandAppliers,