@prosekit/core 0.0.11 → 0.0.13

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 addDefaultState(options) {
-  return stateSlot.extension([
+function defineDefaultState(options) {
+  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");
       }
     }
   }
@@ -597,7 +547,7 @@ function updateExtension(prevInputs, prevSlots, extension, mode) {
 }
 
 // src/editor/type-utils.ts
-function defineExtension(extension) {
+function union(extension) {
   if (extension && Array.isArray(extension)) {
     return { extension };
   }
@@ -611,9 +561,9 @@ function createEditor({
   defaultSelection
 }) {
   if (defaultDoc) {
-    extension = defineExtension([
+    extension = union([
       extension,
-      addDefaultState({
+      defineDefaultState({
         doc: defaultDoc,
         selection: defaultSelection
       })
@@ -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");
     }
@@ -638,7 +588,7 @@ var EditorInstance = class {
     const state = EditorState.create(stateConfig);
     if (commandInput) {
       for (const [name, commandCreator] of Object.entries(commandInput)) {
-        this.addCommand(name, commandCreator);
+        this.defineCommand(name, commandCreator);
       }
     }
     this.directEditorProps = { state, ...viewInput };
@@ -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");
     }
@@ -682,7 +632,7 @@ var EditorInstance = class {
     if (commandInput) {
       const names = Object.keys(commandInput);
       for (const name of names) {
-        this.addCommand(name, commandInput[name]);
+        this.defineCommand(name, commandInput[name]);
       }
     }
   }
@@ -703,11 +653,12 @@ var EditorInstance = class {
     this.view = null;
   }
   get assertView() {
-    if (!this.view)
+    if (!this.view) {
       throw new ProseKitError("Editor is not mounted");
+    }
     return this.view;
   }
-  addPlugins(plugins) {
+  definePlugins(plugins) {
     const view = this.assertView;
     const state = view.state;
     const newPlugins = [...plugins, ...state.plugins];
@@ -723,7 +674,7 @@ var EditorInstance = class {
     const newState = state.reconfigure({ plugins: newPlugins });
     view.setProps({ state: newState });
   }
-  addCommand(name, commandCreator) {
+  defineCommand(name, commandCreator) {
     const applier = (...args) => {
       const view = this.view;
       if (!view) {
@@ -828,11 +779,11 @@ function withPriority(extension, priority) {
 import "@prosekit/pm/model";
 import { AllSelection } from "@prosekit/pm/state";
 import { findWrapping, insertPoint } from "@prosekit/pm/transform";
-function addCommands(commands) {
-  return commandSlot.extension([commands]);
+function defineCommands(commands) {
+  return commandFacet.extension([commands]);
 }
-function addBaseCommands() {
-  return addCommands({
+function defineBaseCommands() {
+  return defineCommands({
     insertText: ({
       text,
       from,
@@ -900,11 +851,11 @@ function addBaseCommands() {
 }
 
 // src/extensions/node-spec.ts
-function addNodeSpec(options) {
+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,12 +869,12 @@ var nodeSpecFacet = Facet.define({
     }
     return { nodes, topNode: topNodeName };
   },
-  next: schemaSlot
+  next: schemaFacet
 });
 
 // src/extensions/doc.ts
-function addDoc() {
-  return addNodeSpec({
+function defineDoc() {
+  return defineNodeSpec({
     name: "doc",
     content: "block+"
   });
@@ -939,7 +890,7 @@ function voidFunction() {
 // src/extensions/plugin.ts
 import "@prosekit/pm/model";
 import { Plugin as Plugin2 } from "@prosekit/pm/state";
-function addPlugin(plugin) {
+function definePlugin(plugin) {
   if (plugin instanceof Plugin2) {
     return pluginFacet.extension([() => [plugin]]);
   }
@@ -952,27 +903,28 @@ function addPlugin(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
-function addEventHandler(options) {
+function defineEventHandler(options) {
   var _a;
   const updateHandler = (_a = options == null ? void 0 : options.update) != null ? _a : voidFunction;
   return eventFacet.extension([updateHandler]);
 }
 var eventFacet = Facet.define({
-  slot: () => {
+  converter: () => {
     let updateHandlers = [];
     const plugin = new ProseMirrorPlugin({
       key: pluginKey,
       view: () => {
+        updateHandlers.forEach((fn) => fn());
         return {
           update: (_view, _prevState) => {
             updateHandlers.forEach((fn) => fn());
@@ -992,8 +944,7 @@ var eventFacet = Facet.define({
       }
     };
   },
-  next: pluginFacet,
-  single: true
+  next: pluginFacet
 });
 var pluginKey = new PluginKey("prosekit-event-handler");
 
@@ -1007,14 +958,14 @@ var isMac = typeof navigator !== "undefined" ? /Mac|iP(hone|[ao]d)/.test(navigat
 import { baseKeymap, chainCommands } from "@prosekit/pm/commands";
 import { keydownHandler } from "@prosekit/pm/keymap";
 import { Plugin as Plugin3, PluginKey as PluginKey2 } from "@prosekit/pm/state";
-function addKeymap(keymap) {
+function defineKeymap(keymap) {
   return keymapFacet.extension([keymap]);
 }
-function addBaseKeymap() {
-  return addKeymap(baseKeymap);
+function defineBaseKeymap() {
+  return defineKeymap(baseKeymap);
 }
 var keymapFacet = Facet.define({
-  slot: () => {
+  converter: () => {
     let handler = null;
     const handlerWrapper = (view, event) => {
       if (handler)
@@ -1037,8 +988,7 @@ var keymapFacet = Facet.define({
       }
     };
   },
-  next: pluginFacet,
-  single: true
+  next: pluginFacet
 });
 function mergeKeymaps(keymaps) {
   const bindings = {};
@@ -1058,7 +1008,7 @@ function mergeKeymaps(keymaps) {
 var keymapPluginKey = new PluginKey2("prosekit-keymap");
 
 // src/extensions/history.ts
-function addHistory() {
+function defineHistory() {
   const keymap = {
     "Mod-z": undo,
     "Shift-Mod-z": redo
@@ -1066,10 +1016,10 @@ function addHistory() {
   if (!isMac) {
     keymap["Mod-y"] = redo;
   }
-  return defineExtension([
-    addPlugin(history()),
-    addKeymap(keymap),
-    addCommands({
+  return union([
+    definePlugin(history()),
+    defineKeymap(keymap),
+    defineCommands({
       undo: () => undo,
       redo: () => redo
     })
@@ -1080,11 +1030,11 @@ function addHistory() {
 import { inputRules } from "@prosekit/pm/inputrules";
 import "@prosekit/pm/model";
 import "@prosekit/pm/state";
-function addInputRule(rules) {
+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 })];
@@ -1094,11 +1044,11 @@ var inputRuleFacet = Facet.define({
 });
 
 // src/extensions/mark-spec.ts
-function addMarkSpec(options) {
+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]) {
@@ -1108,31 +1058,65 @@ 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 addNodeView(options) {
+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
 });
 
 // src/extensions/paragraph.ts
-function addParagraph() {
-  return addNodeSpec({
+function defineParagraph() {
+  return defineNodeSpec({
     name: "paragraph",
     content: "inline*",
     group: "block",
@@ -1144,8 +1128,8 @@ function addParagraph() {
 }
 
 // src/extensions/text.ts
-function addText() {
-  return addNodeSpec({
+function defineText() {
+  return defineNodeSpec({
     name: "text",
     group: "inline"
   });
@@ -1156,28 +1140,29 @@ export {
   FacetExtension,
   Priority,
   ProseKitError,
-  addBaseCommands,
-  addBaseKeymap,
-  addCommands,
-  addDefaultState,
-  addDoc,
-  addEventHandler,
-  addHistory,
-  addInputRule,
-  addKeymap,
   addMark,
-  addMarkSpec,
-  addNodeSpec,
-  addNodeView,
-  addParagraph,
-  addPlugin,
-  addText,
   createEditor,
-  defineExtension,
+  defineBaseCommands,
+  defineBaseKeymap,
+  defineCommands,
+  defineDefaultState,
+  defineDoc,
+  defineEventHandler,
+  defineHistory,
+  defineInputRule,
+  defineKeymap,
+  defineMarkSpec,
+  defineNodeSpec,
+  defineNodeView,
+  defineNodeViewEffect,
+  defineParagraph,
+  definePlugin,
+  defineText,
   getMarkType,
   getNodeType,
   pluginFacet,
   toggleMark,
   toggleNode,
+  union,
   withPriority
 };