@prosekit/core 0.2.2 → 0.2.3

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

@@ -120,6 +120,17 @@ declare interface BaseNodeViewOptions {
 export { BaseNodeViewOptions }
 export { BaseNodeViewOptions as BaseNodeViewOptions_alias_1 }
 
+/**
+ * A utility for constructing `className` strings conditionally.
+ *
+ * It is a re-export of [clsx/lite](https://www.npmjs.com/package/clsx) with stricter types.
+ *
+ * @public
+ */
+declare const clsx: (...args: Array<string | boolean | null | undefined>) => string;
+export { clsx }
+export { clsx as clsx_alias_1 }
+
 export declare function collectNodes(content: NodeContent): ProseMirrorNode[];
 
 export declare interface CommandApplier<Args extends any[] = any[]> {
@@ -321,6 +332,13 @@ declare function defineKeymap(keymap: Keymap): Extension;
 export { defineKeymap }
 export { defineKeymap as defineKeymap_alias_1 }
 
+/**
+ * @public
+ */
+declare function defineMarkAttr(options: MarkAttrOptions): Extension;
+export { defineMarkAttr }
+export { defineMarkAttr as defineMarkAttr_alias_1 }
+
 /**
  * @public
  */
@@ -340,6 +358,17 @@ export { defineMountHandler }
 export { defineMountHandler as defineMountHandler_alias_1 }
 
 /**
+ * Defines an attribute for a node type.
+ *
+ * @public
+ */
+declare function defineNodeAttr(options: NodeAttrOptions): Extension;
+export { defineNodeAttr }
+export { defineNodeAttr as defineNodeAttr_alias_1 }
+
+/**
+ * Defines a node type.
+ *
  * @public
  */
 declare function defineNodeSpec<NodeName extends string>(options: NodeSpecOptions<NodeName>): Extension<{
@@ -701,6 +730,8 @@ declare function isAllSelection(sel: Selection_2): sel is AllSelection;
 export { isAllSelection }
 export { isAllSelection as isAllSelection_alias_1 }
 
+export declare function isElement(value: unknown): value is Element;
+
 export declare const isMac: boolean;
 
 /**
@@ -796,6 +827,36 @@ declare type KeymapPayload = Keymap;
 export { KeymapPayload }
 export { KeymapPayload as KeymapPayload_alias_1 }
 
+/**
+ * @public
+ */
+declare interface MarkAttrOptions {
+    /**
+     * The name of the mark type.
+     */
+    type: string;
+    /**
+     * The name of the attribute.
+     */
+    attr: string;
+    /**
+     * The default value for this attribute, to use when no explicit value is
+     * provided. Attributes that have no default must be provided whenever a mark
+     * of a type that has them is created.
+     */
+    default?: any;
+    /**
+     * Returns the attribute key and value to be set on the DOM node.
+     */
+    toDOM?: (value: any) => [key: string, value: string] | null | void;
+    /**
+     * Parses the attribute value from the DOM.
+     */
+    parseDOM?: (node: HTMLElement) => any;
+}
+export { MarkAttrOptions }
+export { MarkAttrOptions as MarkAttrOptions_alias_1 }
+
 export declare interface MarkBuilder {
     (attrs: Attrs | null, ...children: NodeChild[]): ProseMirrorNode[];
     (...children: NodeChild[]): ProseMirrorNode[];
@@ -822,6 +883,36 @@ declare type MountHandler = (view: EditorView) => void;
 export { MountHandler }
 export { MountHandler as MountHandler_alias_1 }
 
+/**
+ * @public
+ */
+declare interface NodeAttrOptions {
+    /**
+     * The name of the node type.
+     */
+    type: string;
+    /**
+     * The name of the attribute.
+     */
+    attr: string;
+    /**
+     * The default value for this attribute, to use when no explicit value is
+     * provided. Attributes that have no default must be provided whenever a node
+     * of a type that has them is created.
+     */
+    default?: any;
+    /**
+     * Returns the attribute key and value to be set on the DOM node.
+     */
+    toDOM?: (value: any) => [key: string, value: string] | null | void;
+    /**
+     * Parses the attribute value from the DOM.
+     */
+    parseDOM?: (node: HTMLElement) => any;
+}
+export { NodeAttrOptions }
+export { NodeAttrOptions as NodeAttrOptions_alias_1 }
+
 export declare interface NodeBuilder {
     (attrs: Attrs | null, ...children: NodeChild[]): ProseMirrorNode;
     (...children: NodeChild[]): ProseMirrorNode;
@@ -931,6 +1022,8 @@ export { PluginPayload }
 export { PluginPayload as PluginPayload_alias_1 }
 
 /**
+ * ProseKit extension priority.
+ *
  * @public
  */
 declare const enum Priority {

package/dist/prosekit-core.d.ts

@@ -15,14 +15,14 @@ export { defineCommands } from './_tsup-dts-rollup';
 export { defineDefaultState } from './_tsup-dts-rollup';
 export { DefaultStateOptions } from './_tsup-dts-rollup';
 export { defineDoc } from './_tsup-dts-rollup';
+export { defineDocChangeHandler } from './_tsup-dts-rollup';
+export { DocChangeHandler } from './_tsup-dts-rollup';
 export { defineMountHandler } from './_tsup-dts-rollup';
 export { defineUnmountHandler } from './_tsup-dts-rollup';
 export { defineUpdateHandler } from './_tsup-dts-rollup';
 export { MountHandler } from './_tsup-dts-rollup';
 export { UnmountHandler } from './_tsup-dts-rollup';
 export { UpdateHandler } from './_tsup-dts-rollup';
-export { defineDocChangeHandler } from './_tsup-dts-rollup';
-export { DocChangeHandler } from './_tsup-dts-rollup';
 export { defineHistory } from './_tsup-dts-rollup';
 export { defineInputRule } from './_tsup-dts-rollup';
 export { defineBaseKeymap } from './_tsup-dts-rollup';
@@ -30,9 +30,13 @@ export { defineKeymap } from './_tsup-dts-rollup';
 export { keymapFacet } from './_tsup-dts-rollup';
 export { Keymap } from './_tsup-dts-rollup';
 export { KeymapPayload } from './_tsup-dts-rollup';
+export { defineMarkAttr } from './_tsup-dts-rollup';
 export { defineMarkSpec } from './_tsup-dts-rollup';
+export { MarkAttrOptions } from './_tsup-dts-rollup';
 export { MarkSpecOptions } from './_tsup-dts-rollup';
+export { defineNodeAttr } from './_tsup-dts-rollup';
 export { defineNodeSpec } from './_tsup-dts-rollup';
+export { NodeAttrOptions } from './_tsup-dts-rollup';
 export { NodeSpecOptions } from './_tsup-dts-rollup';
 export { defineNodeView } from './_tsup-dts-rollup';
 export { NodeViewOptions } from './_tsup-dts-rollup';
@@ -59,6 +63,7 @@ export { SelectionJSON } from './_tsup-dts-rollup';
 export { StateJSON } from './_tsup-dts-rollup';
 export { Priority } from './_tsup-dts-rollup';
 export { SimplifyUnion } from './_tsup-dts-rollup';
+export { clsx } from './_tsup-dts-rollup';
 export { _getId } from './_tsup-dts-rollup';
 export { getMarkType } from './_tsup-dts-rollup';
 export { getNodeType } from './_tsup-dts-rollup';

package/dist/prosekit-core.js

@@ -1099,26 +1099,110 @@ function defineBaseCommands() {
   });
 }
 
+// src/utils/is-element.ts
+var hasElement = typeof Element !== "undefined";
+function isElement(value) {
+  return hasElement && value instanceof Element;
+}
+
+// src/utils/is-not-null.ts
+function isNotNull(value) {
+  return value != null;
+}
+
 // src/extensions/node-spec.ts
 function defineNodeSpec(options) {
-  return nodeSpecFacet.extension([options]);
+  const payload = [options, void 0];
+  return nodeSpecFacet.extension([payload]);
+}
+function defineNodeAttr(options) {
+  const payload = [void 0, options];
+  return nodeSpecFacet.extension([payload]);
 }
 var nodeSpecFacet = Facet.define({
-  convert: (options) => {
+  convert: (payloads) => {
     const nodes = {};
     let topNodeName = void 0;
-    for (const { name, topNode, ...spec } of options) {
+    const specPayloads = payloads.map((input) => input[0]).filter(isNotNull);
+    const attrPayloads = payloads.map((input) => input[1]).filter(isNotNull);
+    for (const { name, topNode, ...spec } of specPayloads) {
       if (nodes[name]) {
         throw new ProseKitError(`Node type ${name} has already been defined`);
       }
-      if (topNodeName && !topNode) {
+      if (topNode) {
         topNodeName = name;
       }
       nodes[name] = spec;
     }
+    for (const {
+      type,
+      attr,
+      default: defaultValue,
+      toDOM,
+      parseDOM
+    } of attrPayloads) {
+      const spec = nodes[type];
+      if (!spec) {
+        throw new ProseKitError(
+          `Node type ${type} must be defined before defining attributes`
+        );
+      }
+      if (!spec.attrs) {
+        spec.attrs = {};
+      }
+      spec.attrs[attr] = { default: defaultValue };
+      if (toDOM && spec.toDOM) {
+        const existingToDom = spec.toDOM;
+        spec.toDOM = (node) => {
+          const dom = existingToDom(node);
+          if (!dom) {
+            return dom;
+          }
+          const attrDOM = toDOM(node.attrs[attr]);
+          if (!attrDOM) {
+            return dom;
+          }
+          const [key, value] = attrDOM;
+          if (!key) {
+            return dom;
+          }
+          if (Array.isArray(dom)) {
+            if (typeof dom[1] === "object") {
+              return [dom[0], { ...dom[1], [key]: value }, ...dom.slice(2)];
+            } else {
+              return [dom[0], { [key]: value }, ...dom.slice(1)];
+            }
+          } else if (isElement(dom)) {
+            dom.setAttribute(key, value);
+          } else if (typeof dom === "object" && "dom" in dom && isElement(dom.dom)) {
+            dom.dom.setAttribute(key, value);
+          }
+          return dom;
+        };
+      }
+      if (parseDOM && spec.parseDOM) {
+        for (const rule of spec.parseDOM) {
+          const existingGetAttrs = rule.getAttrs;
+          const existingAttrs = rule.attrs;
+          rule.getAttrs = (dom) => {
+            var _a;
+            const attrs = (_a = existingGetAttrs == null ? void 0 : existingGetAttrs(dom)) != null ? _a : existingAttrs;
+            if (attrs === false || !dom || !isElement(dom)) {
+              return attrs != null ? attrs : null;
+            }
+            const value = parseDOM(dom);
+            return {
+              ...attrs,
+              [attr]: value
+            };
+          };
+        }
+      }
+    }
     return { nodes, topNode: topNodeName };
   },
-  next: schemaFacet
+  next: schemaFacet,
+  singleton: true
 });
 
 // src/extensions/doc.ts
@@ -1351,20 +1435,93 @@ var inputRuleFacet = Facet.define({
 
 // src/extensions/mark-spec.ts
 function defineMarkSpec(options) {
-  return markSpecFacet.extension([options]);
+  const payload = [options, void 0];
+  return markSpecFacet.extension([payload]);
+}
+function defineMarkAttr(options) {
+  const payload = [void 0, options];
+  return markSpecFacet.extension([payload]);
 }
 var markSpecFacet = Facet.define({
-  convert: (options) => {
+  convert: (payloads) => {
     const marks = {};
-    for (const { name, ...spec } of options) {
+    const specPayloads = payloads.map((input) => input[0]).filter(isNotNull);
+    const attrPayloads = payloads.map((input) => input[1]).filter(isNotNull);
+    for (const { name, ...spec } of specPayloads) {
       if (marks[name]) {
         throw new ProseKitError(`Mark type ${name} has already been defined`);
       }
       marks[name] = spec;
     }
+    for (const {
+      type,
+      attr,
+      default: defaultValue,
+      toDOM,
+      parseDOM
+    } of attrPayloads) {
+      const spec = marks[type];
+      if (!spec) {
+        throw new ProseKitError(
+          `Mark type ${type} must be defined before defining attributes`
+        );
+      }
+      if (!spec.attrs) {
+        spec.attrs = {};
+      }
+      spec.attrs[attr] = { default: defaultValue };
+      if (toDOM && spec.toDOM) {
+        const existingToDom = spec.toDOM;
+        spec.toDOM = (mark, inline) => {
+          const dom = existingToDom(mark, inline);
+          if (!dom) {
+            return dom;
+          }
+          const attrDOM = toDOM(mark.attrs[attr]);
+          if (!attrDOM) {
+            return dom;
+          }
+          const [key, value] = attrDOM;
+          if (!key) {
+            return dom;
+          }
+          if (Array.isArray(dom)) {
+            if (typeof dom[1] === "object") {
+              return [dom[0], { ...dom[1], [key]: value }, ...dom.slice(2)];
+            } else {
+              return [dom[0], { [key]: value }, ...dom.slice(1)];
+            }
+          } else if (isElement(dom)) {
+            dom.setAttribute(key, value);
+          } else if (typeof dom === "object" && "dom" in dom && isElement(dom.dom)) {
+            dom.dom.setAttribute(key, value);
+          }
+          return dom;
+        };
+      }
+      if (parseDOM && spec.parseDOM) {
+        for (const rule of spec.parseDOM) {
+          const existingGetAttrs = rule.getAttrs;
+          const existingAttrs = rule.attrs;
+          rule.getAttrs = (dom) => {
+            var _a;
+            const attrs = (_a = existingGetAttrs == null ? void 0 : existingGetAttrs(dom)) != null ? _a : existingAttrs;
+            if (attrs === false || !dom || !isElement(dom)) {
+              return attrs != null ? attrs : null;
+            }
+            const value = parseDOM(dom);
+            return {
+              ...attrs,
+              [attr]: value
+            };
+          };
+        }
+      }
+    }
     return { marks, nodes: {} };
   },
-  next: schemaFacet
+  next: schemaFacet,
+  singleton: true
 });
 
 // src/extensions/node-view.ts
@@ -1444,6 +1601,10 @@ function defineText() {
   });
 }
 
+// src/utils/clsx.ts
+import clsxLite from "clsx/lite";
+var clsx = clsxLite;
+
 // src/utils/get-id.ts
 var id = 0;
 function getId() {
@@ -1457,6 +1618,7 @@ export {
   ProseKitError,
   getId as _getId,
   addMark,
+  clsx,
   createEditor,
   defineBaseCommands,
   defineBaseKeymap,
@@ -1467,8 +1629,10 @@ export {
   defineHistory,
   defineInputRule,
   defineKeymap,
+  defineMarkAttr,
   defineMarkSpec,
   defineMountHandler,
+  defineNodeAttr,
   defineNodeSpec,
   defineNodeView,
   defineNodeViewFactory,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@prosekit/core",
   "type": "module",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "private": false,
   "author": {
     "name": "ocavue",
@@ -36,6 +36,7 @@
   ],
   "dependencies": {
     "@prosekit/pm": "^0.1.1",
+    "clsx": "^2.1.0",
     "orderedmap": "^2.1.1",
     "type-fest": "^4.9.0"
   },
@@ -43,7 +44,7 @@
     "@prosekit/dev": "*",
     "tsup": "^8.0.1",
     "typescript": "^5.3.3",
-    "vitest": "^1.1.1"
+    "vitest": "^1.1.3"
   },
   "scripts": {
     "build:tsup": "tsup",

package/src/index.ts

@@ -14,6 +14,10 @@ export {
   type DefaultStateOptions,
 } from './extensions/default-state'
 export { defineDoc } from './extensions/doc'
+export {
+  defineDocChangeHandler,
+  type DocChangeHandler,
+} from './extensions/events/doc-change'
 export {
   defineMountHandler,
   defineUnmountHandler,
@@ -22,10 +26,6 @@ export {
   type UnmountHandler,
   type UpdateHandler,
 } from './extensions/events/plugin-view'
-export {
-  defineDocChangeHandler,
-  type DocChangeHandler,
-} from './extensions/events/doc-change'
 export { defineHistory } from './extensions/history'
 export { defineInputRule } from './extensions/input-rules'
 export {
@@ -35,8 +35,18 @@ export {
   type Keymap,
   type KeymapPayload,
 } from './extensions/keymap'
-export { defineMarkSpec, type MarkSpecOptions } from './extensions/mark-spec'
-export { defineNodeSpec, type NodeSpecOptions } from './extensions/node-spec'
+export {
+  defineMarkAttr,
+  defineMarkSpec,
+  type MarkAttrOptions,
+  type MarkSpecOptions,
+} from './extensions/mark-spec'
+export {
+  defineNodeAttr,
+  defineNodeSpec,
+  type NodeAttrOptions,
+  type NodeSpecOptions,
+} from './extensions/node-spec'
 export { defineNodeView, type NodeViewOptions } from './extensions/node-view'
 export {
   defineNodeViewFactory,
@@ -64,6 +74,7 @@ export { type ExtensionTyping } from './types/extension-typing'
 export type { NodeJSON, SelectionJSON, StateJSON } from './types/model'
 export { Priority } from './types/priority'
 export { type SimplifyUnion } from './types/simplify-union'
+export { clsx } from './utils/clsx'
 export { getId as _getId } from './utils/get-id'
 export { getMarkType } from './utils/get-mark-type'
 export { getNodeType } from './utils/get-node-type'