prosekit 0.0.0-next-20230627094841

package/dist/chunk-2MVHS73Q.js

@@ -0,0 +1,709 @@
+import {
+  EditorView
+} from "./chunk-UWHQRU5N.js";
+import {
+  baseKeymap,
+  chainCommands,
+  toggleMark
+} from "./chunk-VIKPJJET.js";
+import {
+  inputRules
+} from "./chunk-JMNJUDT7.js";
+import {
+  keymap
+} from "./chunk-T2V5UU6H.js";
+import {
+  AllSelection,
+  EditorState,
+  Plugin,
+  Selection
+} from "./chunk-UTNVEPBA.js";
+import {
+  findWrapping,
+  insertPoint
+} from "./chunk-ERNIDFFW.js";
+import {
+  Schema,
+  dist_default
+} from "./chunk-FAVXZAF7.js";
+
+// ../core/src/error.ts
+var ProseKitError = class extends Error {
+};
+
+// ../core/src/utils/get-mark-type.ts
+function getMarkType(schema, type) {
+  if (typeof type === "string") {
+    const markType = schema.marks[type];
+    if (!markType) {
+      throw new ProseKitError(`Cannot find mark type "${type}"`);
+    }
+    return markType;
+  }
+  return type;
+}
+
+// ../core/src/commands/toggle-mark.ts
+function toggleMark2(options) {
+  return (state, dispatch, view) => {
+    return toggleMark(
+      getMarkType(state.schema, options.type),
+      options.attrs
+    )(state, dispatch, view);
+  };
+}
+
+// ../core/src/types/priority.ts
+var Priority = /* @__PURE__ */ ((Priority2) => {
+  Priority2[Priority2["lowest"] = 4] = "lowest";
+  Priority2[Priority2["low"] = 3] = "low";
+  Priority2[Priority2["default"] = 2] = "default";
+  Priority2[Priority2["high"] = 1] = "high";
+  Priority2[Priority2["highest"] = 0] = "highest";
+  return Priority2;
+})(Priority || {});
+
+// ../core/src/editor/facet.ts
+var nextIndex = 0;
+var Facet = class _Facet {
+  constructor(combine, next) {
+    /** @internal */
+    this.index = nextIndex++;
+    this.combine = combine;
+    this.next = next;
+  }
+  static define({ combine, next }) {
+    return new _Facet(combine, next);
+  }
+  /** @internal */
+  static defineSlot({
+    combine
+  }) {
+    return new _Facet(combine, null);
+  }
+  extension(inputs) {
+    return new FacetExtension(this, inputs);
+  }
+};
+var FacetExtension = class {
+  constructor(facet, inputs) {
+    this.facet = facet;
+    this.inputs = inputs;
+  }
+};
+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 Error(`Facet has circular dependency`);
+  }
+  return sortedFacets;
+}
+
+// ../core/src/types/void-function.ts
+function voidFunction() {
+}
+
+// ../core/src/editor/slot.ts
+var schemaSlot = Facet.defineSlot({
+  combine: (specs) => {
+    var _a;
+    let nodes = dist_default.from({});
+    let marks = dist_default.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) => {
+    return (ctx) => {
+      var _a, _b, _c, _d, _e;
+      const configs = callbacks.map((cb) => cb(ctx));
+      const config = {
+        schema: ctx.schema,
+        storedMarks: [],
+        plugins: []
+      };
+      for (const c of configs) {
+        config.schema = (_a = config.schema) != null ? _a : c.schema;
+        config.doc = (_b = config.doc) != null ? _b : c.doc;
+        config.selection = (_c = config.selection) != null ? _c : c.selection;
+        config.storedMarks = [...config.storedMarks, ...(_d = c.storedMarks) != null ? _d : []];
+        config.plugins = [...config.plugins, ...(_e = c.plugins) != null ? _e : []];
+      }
+      if (!config.doc && !config.schema) {
+        throw new Error("Can't create state without a schema nor a document");
+      }
+      if (config.doc) {
+        config.schema = void 0;
+      }
+      return config;
+    };
+  }
+});
+var viewSlot = Facet.defineSlot({
+  combine: (props) => {
+    return Object.assign({}, ...props);
+  }
+});
+var commandSlot = Facet.defineSlot({
+  combine: (inputs) => {
+    return Object.assign({}, ...inputs);
+  }
+});
+
+// ../core/src/editor/flatten.ts
+function flatten(root) {
+  var _a;
+  const extensions = [root];
+  const priorities = [2 /* default */];
+  const facets = [];
+  const inputs = [];
+  while (extensions.length > 0) {
+    const ext = extensions.pop();
+    const pri = priorities.pop();
+    if (ext instanceof FacetExtension) {
+      const facet = ext.facet;
+      if (!facets[facet.index]) {
+        facets[facet.index] = facet;
+        inputs[facet.index] = [[], [], [], [], []];
+      }
+      const facetInputs = ext.inputs;
+      inputs[facet.index][pri].push(...facetInputs);
+    } else if (ext.extension) {
+      const p = (_a = ext.priority) != null ? _a : pri;
+      if (Array.isArray(ext.extension)) {
+        for (const e of ext.extension) {
+          extensions.push(e);
+          priorities.push(p);
+        }
+      } else {
+        extensions.push(ext.extension);
+        priorities.push(p);
+      }
+    } else {
+      throw new Error("Invalid extension");
+    }
+  }
+  let schemaInput = null;
+  let stateInput = null;
+  let viewInput = null;
+  let commandInput = null;
+  const sortedFacets = sortFacets(facets);
+  for (const facet of sortedFacets) {
+    const nextFacet = facet.next;
+    if (nextFacet) {
+      for (let pri = 0; pri < 5; pri++) {
+        const input = inputs[facet.index][pri];
+        if (input.length > 0) {
+          const output = facet.combine(input);
+          if (!inputs[nextFacet.index]) {
+            inputs[nextFacet.index] = [[], [], [], [], []];
+          }
+          inputs[nextFacet.index][pri].push(output);
+        }
+      }
+    } else if (inputs[facet.index]) {
+      const [i1, i2, i3, i4, i5] = inputs[facet.index];
+      const jointInputs = [...i1, ...i2, ...i3, ...i4, ...i5];
+      const output = facet.combine(jointInputs);
+      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 Error("Invalid facet");
+      }
+    }
+  }
+  return { schemaInput, stateInput, viewInput, commandInput };
+}
+
+// ../core/src/editor/editor.ts
+function createEditor({
+  extension
+}) {
+  const { schemaInput, stateInput, viewInput, commandInput } = flatten(extension);
+  if (!schemaInput) {
+    throw new Error("Schema must be defined");
+  }
+  const schema = new Schema(schemaInput);
+  const stateConfig = stateInput ? stateInput({ schema }) : { schema };
+  const state = EditorState.create(stateConfig);
+  const directEditorProps = { state, ...viewInput };
+  const instance = new EditorInstance(directEditorProps);
+  if (commandInput) {
+    for (const [name, commandCreator] of Object.entries(commandInput)) {
+      instance.addCommand(name, commandCreator);
+    }
+  }
+  return Editor.create(instance);
+}
+var EditorInstance = class {
+  constructor(directEditorProps) {
+    this.directEditorProps = directEditorProps;
+    this.view = null;
+    this.commandDispatchers = {};
+    this.mount.bind(this);
+    this.unmount.bind(this);
+    this.schema = directEditorProps.state.schema;
+  }
+  mount(place) {
+    if (this.view) {
+      throw new Error("Editor is already mounted");
+    }
+    if (!place) {
+      throw new Error("Can't mount editor without a place");
+    }
+    this.view = new EditorView(place, this.directEditorProps);
+  }
+  unmount() {
+    if (!this.view) {
+      throw new Error("Editor is not mounted yet");
+    }
+    this.view.destroy();
+    this.view = null;
+  }
+  get assertView() {
+    if (!this.view)
+      throw new Error("Editor is not mounted");
+    return this.view;
+  }
+  addPlugins(plugins) {
+    const view = this.assertView;
+    const state = view.state;
+    const newPlugins = [...plugins, ...state.plugins];
+    const newState = state.reconfigure({ plugins: newPlugins });
+    view.setProps({ state: newState });
+  }
+  removePlugins(plugins) {
+    const view = this.view;
+    if (!view)
+      return;
+    const state = view.state;
+    const newPlugins = state.plugins.filter((p) => !plugins.includes(p));
+    const newState = state.reconfigure({ plugins: newPlugins });
+    view.setProps({ state: newState });
+  }
+  addCommand(name, commandCreator) {
+    const dispatcher = (...args) => {
+      const view = this.assertView;
+      const command = commandCreator(...args);
+      return command(view.state, view.dispatch.bind(view), view);
+    };
+    this.commandDispatchers[name] = dispatcher;
+  }
+  removeCommand(name) {
+    delete this.commandDispatchers[name];
+  }
+};
+var Editor = class _Editor {
+  constructor(instance) {
+    this.afterMounted = [];
+    this.instance = instance;
+  }
+  /** @internal */
+  static create(instance) {
+    if (!(instance instanceof EditorInstance)) {
+      throw new TypeError("Editor's instance is not EditorInstance");
+    }
+    return new _Editor(instance);
+  }
+  get mounted() {
+    return !!this.instance.view;
+  }
+  get view() {
+    return this.instance.assertView;
+  }
+  get schema() {
+    return this.instance.schema;
+  }
+  get commands() {
+    return this.instance.commandDispatchers;
+  }
+  mount(place) {
+    this.instance.mount(place);
+    this.afterMounted.forEach((callback) => callback());
+  }
+  unmount() {
+    this.instance.unmount();
+  }
+  use(extension) {
+    if (!this.mounted) {
+      let lazyRemove = null;
+      const lazyCreate = () => {
+        lazyRemove = this.use(extension);
+      };
+      this.afterMounted.push(lazyCreate);
+      return () => {
+        lazyRemove == null ? void 0 : lazyRemove();
+      };
+    }
+    const { schemaInput, stateInput, viewInput, commandInput } = flatten(extension);
+    if (schemaInput) {
+      throw new ProseKitError("Schema cannot be changed");
+    }
+    if (viewInput) {
+      throw new ProseKitError("View cannot be changed");
+    }
+    if (stateInput) {
+      const stateConfig = stateInput({ schema: this.schema });
+      const plugins = stateConfig.plugins;
+      if (plugins && plugins.length > 0) {
+        this.instance.addPlugins(plugins);
+        return () => this.instance.removePlugins(plugins);
+      }
+    }
+    if (commandInput) {
+      const names = Object.keys(commandInput);
+      for (const name of names) {
+        this.instance.addCommand(name, commandInput[name]);
+      }
+      return () => {
+        for (const name of names) {
+          this.instance.removeCommand(name);
+        }
+      };
+    }
+    return voidFunction;
+  }
+};
+
+// ../core/src/editor/type-utils.ts
+function defineExtension(extension) {
+  if (extension && Array.isArray(extension)) {
+    return { extension };
+  }
+  return extension;
+}
+
+// ../core/src/editor/with-priority.ts
+function withPriority(extension, priority) {
+  return { extension, priority };
+}
+
+// ../core/src/extensions/command.ts
+function addCommands(commands) {
+  return commandSlot.extension([commands]);
+}
+function addBaseCommands() {
+  return addCommands({
+    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);
+          const $pos = tr.doc.resolve(insertPos);
+          tr.setSelection(Selection.near($pos));
+          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;
+      };
+    }
+  });
+}
+
+// ../core/src/extensions/node-spec.ts
+function addNodeSpec(options) {
+  return nodeSpecFacet.extension([options]);
+}
+var nodeSpecFacet = Facet.define({
+  combine: (options) => {
+    const nodes = {};
+    let topNode = void 0;
+    for (const { name, spec, topNode: isTopNode } of options) {
+      if (nodes[name]) {
+        throw new Error(`Node type ${name} has already been defined`);
+      }
+      nodes[name] = spec;
+      if (isTopNode && !topNode) {
+        topNode = name;
+      }
+    }
+    return { nodes, topNode };
+  },
+  next: schemaSlot
+});
+
+// ../core/src/extensions/doc.ts
+function addDoc() {
+  return addNodeSpec({
+    name: "doc",
+    spec: {
+      content: "block+"
+    }
+  });
+}
+
+// ../core/src/extensions/plugin.ts
+function addPlugin({ plugins }) {
+  if (typeof plugins === "function") {
+    return pluginFacet.extension([plugins]);
+  } else if (Array.isArray(plugins)) {
+    return pluginFacet.extension([() => plugins]);
+  } else {
+    throw new TypeError("plugins must be a function or an array");
+  }
+}
+var pluginFacet = Facet.define({
+  combine: (callbacks) => {
+    return ({ schema }) => {
+      const plugins = callbacks.flatMap((func) => func({ schema }));
+      return { plugins };
+    };
+  },
+  next: stateSlot
+});
+
+// ../core/src/extensions/input-rules.ts
+function addInputRule(rules) {
+  return inputRuleFacet.extension([rules]);
+}
+var inputRuleFacet = Facet.define({
+  combine: (inputs) => {
+    return (context) => {
+      const rules = inputs.flatMap((callback) => callback(context));
+      return [inputRules({ rules })];
+    };
+  },
+  next: pluginFacet
+});
+
+// ../core/src/extensions/keymap.ts
+function addKeymap(keymap2) {
+  return keymapFacet.extension([keymap2]);
+}
+function addBaseKeymap() {
+  return addKeymap(baseKeymap);
+}
+var keymapFacet = Facet.define({
+  combine: (keymaps) => {
+    const keymap2 = mergeKeymaps(keymaps);
+    const plugin = keymap(keymap2);
+    return () => [plugin];
+  },
+  next: pluginFacet
+});
+function mergeKeymaps(keymaps) {
+  const bindings = {};
+  for (const keymap2 of keymaps) {
+    for (const [key, command] of Object.entries(keymap2)) {
+      if (!bindings[key])
+        bindings[key] = [];
+      bindings[key].push(command);
+    }
+  }
+  return Object.fromEntries(
+    Object.entries(bindings).map(([key, commands]) => [
+      key,
+      chainCommands(...commands)
+    ])
+  );
+}
+
+// ../core/src/extensions/mark-spec.ts
+function addMarkSpec(options) {
+  return markSpecFacet.extension([options]);
+}
+var markSpecFacet = Facet.define({
+  combine: (options) => {
+    const marks = {};
+    for (const { name, spec } of options) {
+      if (marks[name]) {
+        throw new Error(`Mark type ${name} has already been defined`);
+      }
+      marks[name] = spec;
+    }
+    return { marks, nodes: {} };
+  },
+  next: schemaSlot
+});
+
+// ../core/src/extensions/paragraph.ts
+function addParagraph() {
+  return addNodeSpec({
+    name: "paragraph",
+    spec: {
+      content: "inline*",
+      group: "block",
+      parseDOM: [{ tag: "p" }],
+      toDOM() {
+        return ["p", 0];
+      }
+    }
+  });
+}
+
+// ../core/src/extensions/text.ts
+function addText() {
+  return addNodeSpec({
+    name: "text",
+    spec: {
+      group: "inline"
+    }
+  });
+}
+
+// ../core/src/utils/get-node-type.ts
+function getNodeType(schema, type) {
+  if (typeof type === "string") {
+    const nodeType = schema.nodes[type];
+    if (!nodeType) {
+      throw new ProseKitError(`Cannot find node type "${type}"`);
+    }
+    return nodeType;
+  }
+  return type;
+}
+
+// ../core/src/extensions/node-view.ts
+function addNodeView(options) {
+  return nodeViewFacet.extension([options]);
+}
+var nodeViewFacet = Facet.define({
+  combine: (inputs) => {
+    const nodeViews = {};
+    for (const input of inputs) {
+      if (!nodeViews[input.name]) {
+        nodeViews[input.name] = input.constructor;
+      }
+    }
+    return () => [new Plugin({ props: { nodeViews } })];
+  },
+  next: pluginFacet
+});
+
+export {
+  ProseKitError,
+  getMarkType,
+  toggleMark2 as toggleMark,
+  Priority,
+  Facet,
+  FacetExtension,
+  createEditor,
+  Editor,
+  defineExtension,
+  withPriority,
+  addCommands,
+  addBaseCommands,
+  addNodeSpec,
+  addDoc,
+  addPlugin,
+  addInputRule,
+  addKeymap,
+  addBaseKeymap,
+  addMarkSpec,
+  addNodeView,
+  addParagraph,
+  addText,
+  getNodeType
+};