@prosekit/core 0.0.0-next-20230627094841 → 0.0.1

package/README.md

@@ -0,0 +1 @@
+# @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

@@ -280,8 +280,8 @@ var EditorInstance = class {
     this.directEditorProps = directEditorProps;
     this.view = null;
     this.commandDispatchers = {};
-    this.mount.bind(this);
-    this.unmount.bind(this);
+    this.mount = this.mount.bind(this);
+    this.unmount = this.unmount.bind(this);
     this.schema = directEditorProps.state.schema;
   }
   mount(place) {
@@ -291,7 +291,7 @@ var EditorInstance = class {
     if (!place) {
       throw new Error("Can't mount editor without a place");
     }
-    this.view = new EditorView(place, this.directEditorProps);
+    this.view = new EditorView({ mount: place }, this.directEditorProps);
   }
   unmount() {
     if (!this.view) {
@@ -337,6 +337,9 @@ 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) {
@@ -358,11 +361,16 @@ var Editor = class _Editor {
     return this.instance.commandDispatchers;
   }
   mount(place) {
+    if (!place) {
+      return this.unmount();
+    }
     this.instance.mount(place);
     this.afterMounted.forEach((callback) => callback());
   }
   unmount() {
-    this.instance.unmount();
+    if (this.mounted) {
+      this.instance.unmount();
+    }
   }
   use(extension) {
     if (!this.mounted) {
@@ -663,7 +671,7 @@ function getNodeType(schema, type) {
   if (typeof type === "string") {
     const nodeType = schema.nodes[type];
     if (!nodeType) {
-      throw new ProseKitError(`Cannot find node type "${type}"`);
+      throw new ProseKitError(`Cannot find ProseMirror node type "${type}"`);
     }
     return nodeType;
   }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@prosekit/core",
   "type": "module",
-  "version": "0.0.0-next-20230627094841",
+  "version": "0.0.1",
   "private": false,
   "author": {
     "name": "ocavue",
@@ -38,15 +38,15 @@
     "dist"
   ],
   "dependencies": {
-    "@prosekit/pm": "0.0.0-next-20230627094841",
+    "@prosekit/pm": "^0.0.1",
     "orderedmap": "^2.1.1",
     "type-fest": "^3.12.0"
   },
   "devDependencies": {
+    "@prosekit/dev": "^0.0.0",
     "tsup": "^7.1.0",
-    "typescript": "^5.1.3",
-    "vitest": "^0.32.2",
-    "@prosekit/dev": "0.0.0"
+    "typescript": "^5.1.6",
+    "vitest": "^0.33.0"
   },
   "scripts": {
     "build:tsup": "tsup",