@prosekit/core 0.0.0 → 0.0.2

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2022 ocavue
+Copyright (c) 2023 ocavue
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -1 +1 @@
-# prosekit
+# @prosekit/core

package/dist/prosekit-core.d.ts

@@ -0,0 +1,283 @@
+import { MarkType, Attrs, Schema, ProseMirrorNode, NodeType, MarkSpec, NodeSpec } from '@prosekit/pm/model';
+import { Command, EditorStateConfig, Plugin } from '@prosekit/pm/state';
+import { EditorView, NodeViewConstructor, DirectEditorProps } from '@prosekit/pm/view';
+import { ConditionalExcept, EmptyObject, Simplify, UnionToIntersection } from 'type-fest';
+import { InputRule } from '@prosekit/pm/inputrules';
+
+interface ToggleMarkOptions {
+    type: string | MarkType;
+    attrs?: Attrs | null;
+}
+declare function toggleMark(options: ToggleMarkOptions): Command;
+
+type CommandDispatcher<Args extends any[] = any[]> = (...arg: Args) => boolean;
+type CommandCreator<Args extends any[] = any[]> = (...arg: Args) => Command;
+/** @internal */
+interface CommandArgs {
+    [name: string]: any[];
+}
+type ToCommandCreators<T extends CommandArgs> = {
+    [K in keyof T]: CommandCreator<T[K]>;
+};
+type ToCommandDispatcher<T extends CommandArgs> = {
+    [K in keyof T]: CommandDispatcher<T[K]>;
+};
+
+type EmptyValue = never | undefined | null | EmptyObject;
+type ExceptEmptyValue<T> = ConditionalExcept<T, EmptyValue>;
+
+/**
+ * @intneral
+ */
+type ExtractKey<T, K extends string> = Extract<T, Record<K, any>>[K];
+
+/**
+ * @internal
+ */
+interface ExtensionTyping<Node extends string = string, Mark extends string = string, Commands extends CommandArgs = CommandArgs> {
+    NODES?: Node;
+    MARKS?: Mark;
+    COMMAND_ARGS?: Commands;
+}
+type ExtractNodesFromTyping<T extends ExtensionTyping> = ExtractKey<T, 'NODES'>;
+type ExtractMarksFromTyping<T extends ExtensionTyping> = ExtractKey<T, 'MARKS'>;
+type ExtractCommandArgsFromTyping<T extends ExtensionTyping> = ExtractKey<T, 'COMMAND_ARGS'>;
+
+/**
+ * @public
+ */
+declare const enum Priority {
+    lowest = 4,
+    low = 3,
+    default = 2,
+    high = 1,
+    highest = 0
+}
+
+/**
+ * @public
+ */
+interface Extension<T extends ExtensionTyping = ExtensionTyping> {
+    extension: Extension | Extension[];
+    priority?: Priority;
+    _type?: T;
+}
+/**
+ * @internal
+ */
+type ExtractTyping<E extends Extension> = E extends Extension<infer T> ? T : never;
+/**
+ * @public
+ */
+type ExtractNodes<E extends Extension> = ExtractNodesFromTyping<ExtractTyping<E>>;
+/**
+ * @public
+ */
+type ExtractMarks<E extends Extension> = ExtractMarksFromTyping<ExtractTyping<E>>;
+/**
+ * @internal
+ */
+type ExtractCommandArgs<E extends Extension> = ExtractCommandArgsFromTyping<ExtractTyping<E>>;
+/**
+ * @public
+ */
+type ExtractCommandCreators<E extends Extension> = ToCommandCreators<ExtractCommandArgs<E>>;
+/**
+ * @public
+ */
+type ExtractCommandDispatchers<E extends Extension> = ToCommandDispatcher<ExtractCommandArgs<E>>;
+/**
+ * @internal
+ */
+type SimplifyExtension<E extends Extension | Extension[]> = E extends Extension[] ? Extension<ExceptEmptyValue<{
+    NODES: ExtractNodes<E[number]>;
+    MARKS: ExtractMarks<E[number]>;
+    COMMAND_ARGS: SimplifyUnion<ExtractCommandArgs<E[number]>>;
+}>> : E;
+
+/** @public */
+interface EditorOptions<E extends Extension> {
+    extension: E;
+}
+/** @public */
+declare function createEditor<E extends Extension>({ extension, }: EditorOptions<E>): Editor<E>;
+/** @public */
+declare class Editor<E extends Extension = any> {
+    private instance;
+    private constructor();
+    private afterMounted;
+    /** @internal */
+    static create(instance: any): Editor<any>;
+    get mounted(): boolean;
+    get view(): EditorView;
+    get schema(): Schema<ExtractNodes<E>, ExtractMarks<E>>;
+    get commands(): ExtractCommandDispatchers<E>;
+    mount(place: HTMLElement | null | undefined | void): void;
+    unmount(): void;
+    use(extension: Extension): VoidFunction;
+}
+
+/** @public */
+interface FacetOptions<Input, Output> {
+    combine: (inputs: Input[]) => Output;
+    next: Facet<Output, any>;
+}
+/** @public */
+declare class Facet<Input, Output> {
+    /** @internal */
+    readonly index: number;
+    /** @internal */
+    readonly combine: (inputs: Input[]) => Output;
+    /** @internal */
+    readonly next: Facet<Output, any> | null;
+    private constructor();
+    static define<Input, Output>({ combine, next }: FacetOptions<Input, Output>): Facet<Input, Output>;
+    /** @internal */
+    static defineSlot<Input>({ combine, }: Omit<FacetOptions<Input, Input>, 'next'>): Facet<Input, Input>;
+    extension(inputs: Input[]): FacetExtension<Input, Output>;
+}
+/** @public */
+declare class FacetExtension<Input, Output> {
+    readonly facet: Facet<Input, Output>;
+    readonly inputs: Input[];
+    extension: Extension;
+    constructor(facet: Facet<Input, Output>, inputs: Input[]);
+}
+
+declare function defineExtension<E extends Extension | Extension[]>(extension: E): SimplifyExtension<E>;
+
+/** @public */
+declare function withPriority<T extends Extension>(extension: T, priority: Priority): T;
+
+/**
+ * Base class for all ProseKit errors.
+ */
+declare class ProseKitError extends Error {
+}
+
+declare function addCommands<T extends Record<string, CommandCreator> = Record<string, CommandCreator>>(commands: T): Extension<{
+    COMMAND_ARGS: {
+        [K in keyof T]: Parameters<T[K]>;
+    };
+}>;
+/**
+ * Add some base commands
+ *
+ * @public
+ */
+declare function addBaseCommands(): Extension<{
+    COMMAND_ARGS: {
+        insertText: [{
+            text: string;
+            from?: number | undefined;
+            to?: number | undefined;
+        }];
+        insertNode: [{
+            node: ProseMirrorNode;
+            pos?: number | undefined;
+        }];
+        wrap: [{
+            nodeType: NodeType;
+            attrs?: Attrs | null | undefined;
+        }];
+        setBlockType: [{
+            nodeType: NodeType;
+            attrs?: Attrs | null | undefined;
+            from?: number | undefined;
+            to?: number | undefined;
+        }];
+        selectAll: [];
+    };
+}>;
+
+/** @public */
+declare function addDoc(): Extension<{
+    NODES: "doc";
+}>;
+
+/** @public */
+declare function addInputRule(rules: (context: {
+    schema: Schema;
+}) => InputRule[]): Extension;
+
+/** @public */
+interface Keymap {
+    [key: string]: Command;
+}
+/** @public */
+declare function addKeymap(keymap: Keymap): Extension;
+/** @public */
+declare function addBaseKeymap(): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
+/**
+ * @public
+ */
+interface MarkSpecOptions<M extends string = string> {
+    name: M;
+    spec: MarkSpec;
+}
+/**
+ * @public
+ */
+declare function addMarkSpec<Mark extends string>(options: MarkSpecOptions<Mark>): Extension<{
+    MARKS: Mark;
+}>;
+
+/**
+ * @public
+ */
+interface NodeSpecOptions<N extends string = string> {
+    name: N;
+    spec: NodeSpec;
+    topNode?: boolean;
+}
+/**
+ * @public
+ */
+declare function addNodeSpec<Node extends string>(options: NodeSpecOptions<Node>): Extension<{
+    NODES: Node;
+}>;
+
+interface NodeViewOptions {
+    name: string;
+    constructor: NodeViewConstructor;
+}
+declare function addNodeView(options: NodeViewOptions): Extension;
+
+/** @public */
+declare function addParagraph(): Extension<{
+    NODES: "paragraph";
+}>;
+
+interface StateConfigContext {
+    schema: Schema;
+}
+type StateConfigCallback = (ctx: StateConfigContext) => EditorStateConfig;
+type ViewProps = Omit<DirectEditorProps, 'state'>;
+
+/** @public */
+interface PluginOptions {
+    plugins: Plugin[] | ((context: {
+        schema: Schema;
+    }) => Plugin[]);
+}
+/** @public */
+declare function addPlugin({ plugins }: PluginOptions): Extension;
+
+/** @public */
+declare function addText(): Extension<{
+    NODES: "text";
+}>;
+
+/**
+ * @intneral
+ */
+type SimplifyUnion<T> = Simplify<UnionToIntersection<T>>;
+
+/** @internal */
+declare function getMarkType(schema: Schema, type: string | MarkType): MarkType;
+
+/** @internal */
+declare function getNodeType(schema: Schema, type: string | NodeType): NodeType;
+
+export { CommandArgs, Editor, EditorOptions, Extension, ExtensionTyping, ExtractCommandCreators, ExtractCommandDispatchers, ExtractMarks, ExtractNodes, Facet, FacetExtension, FacetOptions, Keymap, MarkSpecOptions, NodeSpecOptions, NodeViewOptions, PluginOptions, Priority, ProseKitError, SimplifyUnion, StateConfigCallback, StateConfigContext, ViewProps, addBaseCommands, addBaseKeymap, addCommands, addDoc, addInputRule, addKeymap, addMarkSpec, addNodeSpec, addNodeView, addParagraph, addPlugin, addText, createEditor, defineExtension, getMarkType, getNodeType, toggleMark, withPriority };

package/dist/prosekit-core.js

@@ -0,0 +1,704 @@
+// src/commands/toggle-mark.ts
+import { toggleMark as baseToggleMark } from "@prosekit/pm/commands";
+
+// src/error.ts
+var ProseKitError = class extends Error {
+};
+
+// 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;
+}
+
+// src/commands/toggle-mark.ts
+function toggleMark(options) {
+  return (state, dispatch, view) => {
+    return baseToggleMark(
+      getMarkType(state.schema, options.type),
+      options.attrs
+    )(state, dispatch, view);
+  };
+}
+
+// src/editor/editor.ts
+import { Schema } from "@prosekit/pm/model";
+import { EditorState } from "@prosekit/pm/state";
+import { EditorView } from "@prosekit/pm/view";
+
+// src/types/void-function.ts
+function voidFunction() {
+}
+
+// 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 || {});
+
+// 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;
+}
+
+// src/editor/slot.ts
+import OrderedMap from "orderedmap";
+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) => {
+    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);
+  }
+});
+
+// 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 };
+}
+
+// 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 = this.mount.bind(this);
+    this.unmount = 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({ mount: 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;
+    this.mount = this.mount.bind(this);
+    this.unmount = this.unmount.bind(this);
+    this.use = this.use.bind(this);
+  }
+  /** @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) {
+    if (!place) {
+      return this.unmount();
+    }
+    this.instance.mount(place);
+    this.afterMounted.forEach((callback) => callback());
+  }
+  unmount() {
+    if (this.mounted) {
+      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;
+  }
+};
+
+// src/editor/type-utils.ts
+function defineExtension(extension) {
+  if (extension && Array.isArray(extension)) {
+    return { extension };
+  }
+  return extension;
+}
+
+// src/editor/with-priority.ts
+function withPriority(extension, priority) {
+  return { extension, priority };
+}
+
+// src/extensions/command.ts
+import { AllSelection, Selection } from "@prosekit/pm/state";
+import { findWrapping, insertPoint } from "@prosekit/pm/transform";
+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;
+      };
+    }
+  });
+}
+
+// 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
+});
+
+// src/extensions/doc.ts
+function addDoc() {
+  return addNodeSpec({
+    name: "doc",
+    spec: {
+      content: "block+"
+    }
+  });
+}
+
+// src/extensions/input-rules.ts
+import { inputRules } from "@prosekit/pm/inputrules";
+
+// 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
+});
+
+// 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
+});
+
+// src/extensions/keymap.ts
+import { baseKeymap, chainCommands } from "@prosekit/pm/commands";
+import { keymap as createKeymapPlugin } from "@prosekit/pm/keymap";
+function addKeymap(keymap) {
+  return keymapFacet.extension([keymap]);
+}
+function addBaseKeymap() {
+  return addKeymap(baseKeymap);
+}
+var keymapFacet = Facet.define({
+  combine: (keymaps) => {
+    const keymap = mergeKeymaps(keymaps);
+    const plugin = createKeymapPlugin(keymap);
+    return () => [plugin];
+  },
+  next: pluginFacet
+});
+function mergeKeymaps(keymaps) {
+  const bindings = {};
+  for (const keymap of keymaps) {
+    for (const [key, command] of Object.entries(keymap)) {
+      if (!bindings[key])
+        bindings[key] = [];
+      bindings[key].push(command);
+    }
+  }
+  return Object.fromEntries(
+    Object.entries(bindings).map(([key, commands]) => [
+      key,
+      chainCommands(...commands)
+    ])
+  );
+}
+
+// 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
+});
+
+// src/extensions/node-view.ts
+import { Plugin as Plugin2 } from "@prosekit/pm/state";
+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 Plugin2({ props: { nodeViews } })];
+  },
+  next: pluginFacet
+});
+
+// src/extensions/paragraph.ts
+function addParagraph() {
+  return addNodeSpec({
+    name: "paragraph",
+    spec: {
+      content: "inline*",
+      group: "block",
+      parseDOM: [{ tag: "p" }],
+      toDOM() {
+        return ["p", 0];
+      }
+    }
+  });
+}
+
+// src/extensions/text.ts
+function addText() {
+  return addNodeSpec({
+    name: "text",
+    spec: {
+      group: "inline"
+    }
+  });
+}
+
+// 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 ProseMirror node type "${type}"`);
+    }
+    return nodeType;
+  }
+  return type;
+}
+export {
+  Editor,
+  Facet,
+  FacetExtension,
+  Priority,
+  ProseKitError,
+  addBaseCommands,
+  addBaseKeymap,
+  addCommands,
+  addDoc,
+  addInputRule,
+  addKeymap,
+  addMarkSpec,
+  addNodeSpec,
+  addNodeView,
+  addParagraph,
+  addPlugin,
+  addText,
+  createEditor,
+  defineExtension,
+  getMarkType,
+  getNodeType,
+  toggleMark,
+  withPriority
+};

package/dist/style.css

@@ -0,0 +1,52 @@
+/* ../../node_modules/.pnpm/prosemirror-view@1.31.5/node_modules/prosemirror-view/style/prosemirror.css */
+.ProseMirror {
+  position: relative;
+}
+.ProseMirror {
+  word-wrap: break-word;
+  white-space: pre-wrap;
+  white-space: break-spaces;
+  -webkit-font-variant-ligatures: none;
+  font-variant-ligatures: none;
+  font-feature-settings: "liga" 0;
+}
+.ProseMirror pre {
+  white-space: pre-wrap;
+}
+.ProseMirror li {
+  position: relative;
+}
+.ProseMirror-hideselection *::selection {
+  background: transparent;
+}
+.ProseMirror-hideselection *::-moz-selection {
+  background: transparent;
+}
+.ProseMirror-hideselection {
+  caret-color: transparent;
+}
+.ProseMirror-selectednode {
+  outline: 2px solid #8cf;
+}
+li.ProseMirror-selectednode {
+  outline: none;
+}
+li.ProseMirror-selectednode:after {
+  content: "";
+  position: absolute;
+  left: -32px;
+  right: -2px;
+  top: -2px;
+  bottom: -2px;
+  border: 2px solid #8cf;
+  pointer-events: none;
+}
+img.ProseMirror-separator {
+  display: inline !important;
+  border: none !important;
+  margin: 0 !important;
+}
+
+/* ../pm/src/view/style/prosemirror.css */
+
+/* src/style.css */

package/package.json

@@ -1,68 +1,56 @@
 {
   "name": "@prosekit/core",
   "type": "module",
-  "publishConfig": {
-    "access": "public"
+  "version": "0.0.2",
+  "private": false,
+  "author": {
+    "name": "ocavue",
+    "email": "ocavue@gmail.com"
   },
-  "version": "0.0.0",
-  "packageManager": "pnpm@7.32.0",
-  "description": "",
-  "author": "ocavue <ocavue@gmail.com>",
   "license": "MIT",
   "funding": "https://github.com/sponsors/ocavue",
   "homepage": "https://github.com/ocavue/prosekit#readme",
   "repository": {
     "type": "git",
-    "url": "https://github.com/ocavue/prosekit.git"
+    "url": "git+https://github.com/ocavue/prosekit.git",
+    "directory": "packages/core"
   },
-  "bugs": "https://github.com/ocavue/prosekit/issues",
-  "keywords": [],
+  "bugs": {
+    "url": "https://github.com/ocavue/prosekit/issues"
+  },
+  "keywords": [
+    "ProseMirror"
+  ],
   "sideEffects": false,
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "main": "./dist/prosekit-core.js",
+  "module": "./dist/prosekit-core.js",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "require": "./dist/index.cjs",
-      "import": "./dist/index.js"
-    }
-  },
-  "typesVersions": {
-    "*": {
-      "*": [
-        "./dist/*",
-        "./dist/index.d.ts"
-      ]
+      "types": "./dist/prosekit-core.d.ts",
+      "import": "./dist/prosekit-core.js",
+      "default": "./dist/prosekit-core.js"
+    },
+    "./style.css": {
+      "default": "./dist/style.css"
     }
   },
   "files": [
     "dist"
   ],
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "lint": "eslint .",
-    "prepublishOnly": "nr build",
-    "start": "esno src/index.ts",
-    "test": "vitest",
-    "typecheck": "tsc --noEmit"
+  "dependencies": {
+    "@prosekit/pm": "^0.0.2",
+    "orderedmap": "^2.1.1",
+    "type-fest": "^3.12.0"
   },
   "devDependencies": {
-    "@antfu/ni": "^0.21.3",
-    "@ocavue/eslint-config": "^0.4.7",
-    "@types/node": "^18.15.11",
-    "eslint": "^8.38.0",
-    "esno": "^0.16.3",
-    "prettier": "^2.8.7",
-    "tsup": "^6.7.0",
-    "typescript": "^5.0.4",
-    "vite": "^4.2.1",
-    "vitest": "^0.30.0"
+    "@prosekit/dev": "*",
+    "tsup": "^7.1.0",
+    "typescript": "^5.1.6",
+    "vitest": "^0.33.0"
+  },
+  "scripts": {
+    "build:tsup": "tsup",
+    "build:tsc": "tsc -b tsconfig.json"
   },
-  "renovate": {
-    "extends": [
-      "github>ocavue/config-renovate"
-    ]
-  }
-}
+  "types": "./dist/prosekit-core.d.ts"
+}

package/src/index.ts

@@ -0,0 +1,30 @@
+export { toggleMark } from './commands/toggle-mark'
+export { Editor, createEditor, type EditorOptions } from './editor/editor'
+export { Facet, FacetExtension, type FacetOptions } from './editor/facet'
+export { defineExtension } from './editor/type-utils'
+export { withPriority } from './editor/with-priority'
+export { ProseKitError } from './error'
+export { addBaseCommands, addCommands } from './extensions/command'
+export { addDoc } from './extensions/doc'
+export { addInputRule } from './extensions/input-rules'
+export { addBaseKeymap, addKeymap, type Keymap } from './extensions/keymap'
+export { addMarkSpec, type MarkSpecOptions } from './extensions/mark-spec'
+export { addNodeSpec, type NodeSpecOptions } from './extensions/node-spec'
+export { addNodeView, type NodeViewOptions } from './extensions/node-view'
+export { addParagraph } from './extensions/paragraph'
+export { addPlugin, type PluginOptions } from './extensions/plugin'
+export { addText } from './extensions/text'
+export { type CommandArgs as CommandArgs } from './types/command'
+export * from './types/editor'
+export {
+  type Extension,
+  type ExtractCommandCreators,
+  type ExtractCommandDispatchers,
+  type ExtractMarks,
+  type ExtractNodes,
+} from './types/extension'
+export { type ExtensionTyping } from './types/extension-typing'
+export { Priority } from './types/priority'
+export { type SimplifyUnion } from './types/simplify-union'
+export { getMarkType } from './utils/get-mark-type'
+export { getNodeType } from './utils/get-node-type'

package/dist/index.cjs

@@ -1,33 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  one: () => one,
-  two: () => two
-});
-module.exports = __toCommonJS(src_exports);
-var one = 1;
-var two = 2;
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  one,
-  two
-});

package/dist/index.d.ts

@@ -1,4 +0,0 @@
-declare const one = 1;
-declare const two = 2;
-
-export { one, two };

package/dist/index.js

@@ -1,7 +0,0 @@
-// src/index.ts
-var one = 1;
-var two = 2;
-export {
-  one,
-  two
-};