@prosekit/core 0.0.12 → 0.0.13

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

@@ -49,8 +49,6 @@ declare interface AddMarkOptions {
 export { AddMarkOptions }
 export { AddMarkOptions as AddMarkOptions_alias_1 }
 
-export declare type AnySlot = Slot<any, any>;
-
 export declare function applyAction(operator: Action): Command;
 
 /**
@@ -78,9 +76,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 Converters = ConverterTuple[];
 
-export declare type CommandSlotInput = Record<string, CommandCreator<any>>;
+declare type ConverterTuple = Tuple5<FacetConverter | undefined>;
 
 /** @public */
 declare function createEditor<E extends Extension>({ extension, defaultDoc, defaultSelection, }: EditorOptions<E>): Editor<E>;
@@ -169,7 +171,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 +223,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 +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 }
@@ -421,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;
@@ -499,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;
@@ -508,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
@@ -541,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.
@@ -574,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.
@@ -622,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]>;
@@ -658,6 +657,8 @@ 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 }
@@ -666,18 +667,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;
 

package/dist/prosekit-core.d.ts

@@ -30,10 +30,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 +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';

package/dist/prosekit-core.js

@@ -134,9 +134,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 +155,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 +226,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 +339,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 +425,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 +433,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 +452,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 +484,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 +511,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 +575,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 +612,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 +653,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) {
@@ -829,7 +780,7 @@ import "@prosekit/pm/model";
 import { AllSelection } from "@prosekit/pm/state";
 import { findWrapping, insertPoint } from "@prosekit/pm/transform";
 function defineCommands(commands) {
-  return commandSlot.extension([commands]);
+  return commandFacet.extension([commands]);
 }
 function defineBaseCommands() {
   return defineCommands({
@@ -904,7 +855,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 +869,7 @@ var nodeSpecFacet = Facet.define({
     }
     return { nodes, topNode: topNodeName };
   },
-  next: schemaSlot
+  next: schemaFacet
 });
 
 // src/extensions/doc.ts
@@ -952,13 +903,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 +919,7 @@ function defineEventHandler(options) {
   return eventFacet.extension([updateHandler]);
 }
 var eventFacet = Facet.define({
-  slot: () => {
+  converter: () => {
     let updateHandlers = [];
     const plugin = new ProseMirrorPlugin({
       key: pluginKey,
@@ -993,8 +944,7 @@ var eventFacet = Facet.define({
       }
     };
   },
-  next: pluginFacet,
-  single: true
+  next: pluginFacet
 });
 var pluginKey = new PluginKey("prosekit-event-handler");
 
@@ -1015,7 +965,7 @@ function defineBaseKeymap() {
   return defineKeymap(baseKeymap);
 }
 var keymapFacet = Facet.define({
-  slot: () => {
+  converter: () => {
     let handler = null;
     const handlerWrapper = (view, event) => {
       if (handler)
@@ -1038,8 +988,7 @@ var keymapFacet = Facet.define({
       }
     };
   },
-  next: pluginFacet,
-  single: true
+  next: pluginFacet
 });
 function mergeKeymaps(keymaps) {
   const bindings = {};
@@ -1085,7 +1034,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 +1048,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 +1058,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,6 +1154,7 @@ export {
   defineMarkSpec,
   defineNodeSpec,
   defineNodeView,
+  defineNodeViewEffect,
   defineParagraph,
   definePlugin,
   defineText,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@prosekit/core",
   "type": "module",
-  "version": "0.0.12",
+  "version": "0.0.13",
   "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

@@ -2,7 +2,7 @@ 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 { 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 +23,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,