@prosekit/solid 0.0.0-next-20240421132240

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+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
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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

@@ -0,0 +1,269 @@
+import { Accessor } from 'solid-js';
+import { AutocompleteEmptyElement } from '@prosekit/web/autocomplete';
+import { AutocompleteEmptyProps } from '@prosekit/web/autocomplete';
+import { AutocompleteItemElement } from '@prosekit/web/autocomplete';
+import { AutocompleteItemProps } from '@prosekit/web/autocomplete';
+import { AutocompleteListElement } from '@prosekit/web/autocomplete';
+import { AutocompleteListProps } from '@prosekit/web/autocomplete';
+import { AutocompletePopoverElement } from '@prosekit/web/autocomplete';
+import { AutocompletePopoverProps } from '@prosekit/web/autocomplete';
+import { BlockDragHandleElement } from '@prosekit/web/block-handle';
+import { BlockDragHandleProps } from '@prosekit/web/block-handle';
+import { BlockPopoverElement } from '@prosekit/web/block-handle';
+import { BlockPopoverProps } from '@prosekit/web/block-handle';
+import { Component } from 'solid-js';
+import { ContextProviderComponent } from 'solid-js';
+import { Editor } from '@prosekit/core';
+import type { EditorState } from '@prosekit/pm/state';
+import { Extension } from '@prosekit/core';
+import { InlinePopoverElement } from '@prosekit/web/inline-popover';
+import { InlinePopoverProps } from '@prosekit/web/inline-popover';
+import { JSX } from 'solid-js';
+import type { JSXElement } from 'solid-js';
+import { Keymap } from '@prosekit/core';
+import { Options } from 'tsup';
+import { ParentProps } from 'solid-js';
+import { PopoverContentElement } from '@prosekit/web/popover';
+import { PopoverContentProps } from '@prosekit/web/popover';
+import { PopoverRootElement } from '@prosekit/web/popover';
+import { PopoverRootProps } from '@prosekit/web/popover';
+import { PopoverTriggerElement } from '@prosekit/web/popover';
+import { PopoverTriggerProps } from '@prosekit/web/popover';
+import { Priority } from '@prosekit/core';
+import type { ProseMirrorNode } from '@prosekit/pm/model';
+import { ResizableHandleElement } from '@prosekit/web/resizable';
+import { ResizableHandleProps } from '@prosekit/web/resizable';
+import { ResizableRootElement } from '@prosekit/web/resizable';
+import { ResizableRootProps } from '@prosekit/web/resizable';
+import { TooltipContentElement } from '@prosekit/web/tooltip';
+import { TooltipContentProps } from '@prosekit/web/tooltip';
+import { TooltipRootElement } from '@prosekit/web/tooltip';
+import { TooltipRootProps } from '@prosekit/web/tooltip';
+import { TooltipTriggerElement } from '@prosekit/web/tooltip';
+import { TooltipTriggerProps } from '@prosekit/web/tooltip';
+
+declare const AutocompleteEmpty: Component<Partial<AutocompleteEmptyProps> & JSX<AutocompleteEmptyElement>>;
+export { AutocompleteEmpty }
+export { AutocompleteEmpty as AutocompleteEmpty_alias_1 }
+
+declare const AutocompleteItem: Component<Partial<AutocompleteItemProps> & JSX<AutocompleteItemElement>>;
+export { AutocompleteItem }
+export { AutocompleteItem as AutocompleteItem_alias_1 }
+
+declare const AutocompleteList: Component<Partial<AutocompleteListProps> & JSX<AutocompleteListElement>>;
+export { AutocompleteList }
+export { AutocompleteList as AutocompleteList_alias_1 }
+
+declare const AutocompletePopover: Component<Partial<AutocompletePopoverProps> & JSX<AutocompletePopoverElement>>;
+export { AutocompletePopover }
+export { AutocompletePopover as AutocompletePopover_alias_1 }
+
+declare const BlockDragHandle: Component<Partial<BlockDragHandleProps> & JSX<BlockDragHandleElement>>;
+export { BlockDragHandle }
+export { BlockDragHandle as BlockDragHandle_alias_1 }
+
+declare const BlockPopover: Component<Partial<BlockPopoverProps> & JSX<BlockPopoverElement>>;
+export { BlockPopover }
+export { BlockPopover as BlockPopover_alias_1 }
+
+export declare function createComponent<Props extends object, CustomElement extends HTMLElement>(tagName: string, defaultProps: Props): Component<Partial<Props> & JSX.HTMLAttributes<CustomElement>>;
+
+export declare const default_alias: Options | Options[] | ((overrideOptions: Options) => Options | Options[] | Promise<Options | Options[]>);
+
+export declare const default_alias_1: {
+    test: {
+        environment: "jsdom";
+    };
+};
+
+/**
+ * @internal
+ */
+export declare const EditorContextProvider: ContextProviderComponent<Editor<any> | null>;
+
+export declare function forceProps<T extends Record<string, any>>(props: T): T;
+
+declare const InlinePopover: Component<Partial<InlinePopoverProps> & JSX<InlinePopoverElement>>;
+export { InlinePopover }
+export { InlinePopover as InlinePopover_alias_1 }
+
+/**
+ * T or a reactive/non-reactive function returning T
+ */
+declare type MaybeAccessor<T> = T | Accessor<T>;
+export { MaybeAccessor }
+export { MaybeAccessor as MaybeAccessor_alias_1 }
+
+/**
+ * Accessed value of a MaybeAccessor
+ *
+ * @example
+ *
+ * ```ts
+ * MaybeAccessorValue<MaybeAccessor<string>>
+ * // => string
+ * MaybeAccessorValue<MaybeAccessor<() => string>>
+ * // => string | (() => string)
+ * MaybeAccessorValue<MaybeAccessor<string> | Function>
+ * // => string | void
+ * ```
+ */
+export declare type MaybeAccessorValue<T extends MaybeAccessor<any>> = T extends () => any ? ReturnType<T> : T;
+
+declare const PopoverContent: Component<Partial<PopoverContentProps> & JSX<PopoverContentElement>>;
+export { PopoverContent }
+export { PopoverContent as PopoverContent_alias_1 }
+
+declare const PopoverRoot: Component<Partial<PopoverRootProps> & JSX<PopoverRootElement>>;
+export { PopoverRoot }
+export { PopoverRoot as PopoverRoot_alias_1 }
+
+declare const PopoverTrigger: Component<Partial<PopoverTriggerProps> & JSX<PopoverTriggerElement>>;
+export { PopoverTrigger }
+export { PopoverTrigger as PopoverTrigger_alias_1 }
+
+/**
+ * @internal
+ */
+declare type PropsWithChildren<P = unknown> = P & {
+    children?: JSXElement | undefined;
+};
+export { PropsWithChildren }
+export { PropsWithChildren as PropsWithChildren_alias_1 }
+
+/**
+ * @internal
+ */
+declare type PropsWithClass<P = unknown> = P & {
+    class?: string | undefined;
+};
+export { PropsWithClass }
+export { PropsWithClass as PropsWithClass_alias_1 }
+
+/**
+ * The root component for a ProseKit editor.
+ *
+ * @public
+ */
+declare const ProseKit: Component<ProseKitProps>;
+export { ProseKit }
+export { ProseKit as ProseKit_alias_1 }
+
+declare type ProseKitProps = ParentProps<{
+    editor: Editor;
+}>;
+export { ProseKitProps }
+export { ProseKitProps as ProseKitProps_alias_1 }
+
+declare const ResizableHandle: Component<Partial<ResizableHandleProps> & JSX<ResizableHandleElement>>;
+export { ResizableHandle }
+export { ResizableHandle as ResizableHandle_alias_1 }
+
+declare const ResizableRoot: Component<Partial<ResizableRootProps> & JSX<ResizableRootElement>>;
+export { ResizableRoot }
+export { ResizableRoot as ResizableRoot_alias_1 }
+
+declare const TooltipContent: Component<Partial<TooltipContentProps> & JSX<TooltipContentElement>>;
+export { TooltipContent }
+export { TooltipContent as TooltipContent_alias_1 }
+
+declare const TooltipRoot: Component<Partial<TooltipRootProps> & JSX<TooltipRootElement>>;
+export { TooltipRoot }
+export { TooltipRoot as TooltipRoot_alias_1 }
+
+declare const TooltipTrigger: Component<Partial<TooltipTriggerProps> & JSX<TooltipTriggerElement>>;
+export { TooltipTrigger }
+export { TooltipTrigger as TooltipTrigger_alias_1 }
+
+/**
+ * Accesses the value of a MaybeAccessor
+ *
+ * @example
+ * ```ts
+ * access("foo") // => "foo"
+ * access(() => "foo") // => "foo"
+ * ```
+ */
+export declare function toValue<T extends MaybeAccessor<any>>(v: T): MaybeAccessorValue<T>;
+
+/**
+ * Calls the given handler whenever the editor document changes.
+ *
+ * @public
+ */
+declare function useDocChange(handler: (doc: ProseMirrorNode) => void, options?: UseExtensionOptions): void;
+export { useDocChange }
+export { useDocChange as useDocChange_alias_1 }
+
+/**
+ * Retrieves the editor instance from the nearest ProseKit component.
+ *
+ * @public
+ */
+declare function useEditor<E extends Extension = any>(options?: {
+    /**
+     * Whether to update the component when the editor is mounted or editor state
+     * is updated.
+     *
+     * @default false
+     */
+    update?: boolean;
+}): () => Editor<E>;
+export { useEditor }
+export { useEditor as useEditor_alias_1 }
+
+/**
+ * @internal
+ */
+export declare function useEditorContext<E extends Extension>(): Editor<E> | null;
+
+/**
+ * @internal
+ */
+export declare function useEditorExtension(editorAccessor: MaybeAccessor<Editor> | undefined | null, extensionAccessor: Accessor<Extension | null>): void;
+
+/**
+ * Add an extension to the editor.
+ */
+declare function useExtension(
+/**
+ * The accessor to an extension to add to the editor. If it changes, the previous
+ * extension will be removed and the new one (if not null) will be added.
+ */
+extension: Accessor<Extension | null>, options?: UseExtensionOptions): void;
+export { useExtension }
+export { useExtension as useExtension_alias_1 }
+
+declare interface UseExtensionOptions {
+    /**
+     * The editor to add the extension to. If not provided, it will use the
+     * editor from the nearest `ProseKit` component.
+     */
+    editor?: MaybeAccessor<Editor>;
+    /**
+     * Optional priority to add the extension with.
+     */
+    priority?: Priority;
+}
+export { UseExtensionOptions }
+export { UseExtensionOptions as UseExtensionOptions_alias_1 }
+
+declare function useKeymap(keymap: () => Keymap, options?: UseExtensionOptions): void;
+export { useKeymap }
+export { useKeymap as useKeymap_alias_1 }
+
+/**
+ * @internal
+ */
+export declare function usePriorityExtension<T extends Extension = Extension>(extension: () => T | null, priority?: Priority | null): () => T | null;
+
+/**
+ * Calls the given handler whenever the editor state changes.
+ *
+ * @public
+ */
+declare function useStateUpdate(handler: (state: EditorState) => void, options?: UseExtensionOptions): void;
+export { useStateUpdate }
+export { useStateUpdate as useStateUpdate_alias_1 }
+
+export { }

package/dist/chunk-XXXIBXNC.js

@@ -0,0 +1,12 @@
+// src/contexts/editor-context.ts
+import { createContext, useContext } from "solid-js";
+var editorContext = createContext(null);
+function useEditorContext() {
+  return useContext(editorContext);
+}
+var EditorContextProvider = editorContext.Provider;
+
+export {
+  useEditorContext,
+  EditorContextProvider
+};

package/dist/chunk-Z3TWLQOI.js

@@ -0,0 +1,26 @@
+import {
+  useEditorContext
+} from "./chunk-XXXIBXNC.js";
+
+// src/components/create-component.ts
+import h from "solid-js/h";
+function createComponent(tagName, defaultProps) {
+  const propertyNames = Object.keys(defaultProps);
+  const hasEditor = Object.hasOwn(defaultProps, "editor");
+  const Component = (props) => {
+    const p = {};
+    for (const key of Object.keys(props)) {
+      p[propertyNames.includes(key) ? "prop:" + key : key] = () => props[key];
+    }
+    const editor = useEditorContext();
+    if (hasEditor && editor) {
+      p["prop:editor"] = () => props["editor"] || editor;
+    }
+    return h(tagName, p);
+  };
+  return Component;
+}
+
+export {
+  createComponent
+};

package/dist/prosekit-solid-autocomplete.d.ts

@@ -0,0 +1,4 @@
+export { AutocompleteEmpty_alias_1 as AutocompleteEmpty } from './_tsup-dts-rollup';
+export { AutocompleteItem_alias_1 as AutocompleteItem } from './_tsup-dts-rollup';
+export { AutocompleteList_alias_1 as AutocompleteList } from './_tsup-dts-rollup';
+export { AutocompletePopover_alias_1 as AutocompletePopover } from './_tsup-dts-rollup';

package/dist/prosekit-solid-autocomplete.js

@@ -0,0 +1,46 @@
+import {
+  createComponent
+} from "./chunk-Z3TWLQOI.js";
+import "./chunk-XXXIBXNC.js";
+
+// src/components/autocomplete/autocomplete-empty.gen.ts
+import {
+  defaultAutocompleteEmptyProps
+} from "@prosekit/web/autocomplete";
+var AutocompleteEmpty = createComponent(
+  "prosekit-autocomplete-empty",
+  defaultAutocompleteEmptyProps
+);
+
+// src/components/autocomplete/autocomplete-item.gen.ts
+import {
+  defaultAutocompleteItemProps
+} from "@prosekit/web/autocomplete";
+var AutocompleteItem = createComponent(
+  "prosekit-autocomplete-item",
+  defaultAutocompleteItemProps
+);
+
+// src/components/autocomplete/autocomplete-list.gen.ts
+import {
+  defaultAutocompleteListProps
+} from "@prosekit/web/autocomplete";
+var AutocompleteList = createComponent(
+  "prosekit-autocomplete-list",
+  defaultAutocompleteListProps
+);
+
+// src/components/autocomplete/autocomplete-popover.gen.ts
+import {
+  defaultAutocompletePopoverProps
+} from "@prosekit/web/autocomplete";
+var AutocompletePopover = createComponent(
+  "prosekit-autocomplete-popover",
+  defaultAutocompletePopoverProps
+);
+export {
+  AutocompleteEmpty,
+  AutocompleteItem,
+  AutocompleteList,
+  AutocompletePopover
+};

package/dist/prosekit-solid-block-handle.d.ts

@@ -0,0 +1,2 @@
+export { BlockDragHandle_alias_1 as BlockDragHandle } from './_tsup-dts-rollup';
+export { BlockPopover_alias_1 as BlockPopover } from './_tsup-dts-rollup';

package/dist/prosekit-solid-block-handle.js

@@ -0,0 +1,26 @@
+import {
+  createComponent
+} from "./chunk-Z3TWLQOI.js";
+import "./chunk-XXXIBXNC.js";
+
+// src/components/block-handle/block-drag-handle.gen.ts
+import {
+  defaultBlockDragHandleProps
+} from "@prosekit/web/block-handle";
+var BlockDragHandle = createComponent(
+  "prosekit-block-drag-handle",
+  defaultBlockDragHandleProps
+);
+
+// src/components/block-handle/block-popover.gen.ts
+import {
+  defaultBlockPopoverProps
+} from "@prosekit/web/block-handle";
+var BlockPopover = createComponent(
+  "prosekit-block-popover",
+  defaultBlockPopoverProps
+);
+export {
+  BlockDragHandle,
+  BlockPopover
+};

package/dist/prosekit-solid-inline-popover.d.ts

@@ -0,0 +1 @@
+export { InlinePopover } from './_tsup-dts-rollup';

package/dist/prosekit-solid-inline-popover.js

@@ -0,0 +1,16 @@
+import {
+  createComponent
+} from "./chunk-Z3TWLQOI.js";
+import "./chunk-XXXIBXNC.js";
+
+// src/components/inline-popover/inline-popover.gen.ts
+import {
+  defaultInlinePopoverProps
+} from "@prosekit/web/inline-popover";
+var InlinePopover = createComponent(
+  "prosekit-inline-popover",
+  defaultInlinePopoverProps
+);
+export {
+  InlinePopover
+};

package/dist/prosekit-solid-popover.d.ts

@@ -0,0 +1,3 @@
+export { PopoverContent } from './_tsup-dts-rollup';
+export { PopoverRoot } from './_tsup-dts-rollup';
+export { PopoverTrigger } from './_tsup-dts-rollup';

package/dist/prosekit-solid-popover.js

@@ -0,0 +1,36 @@
+import {
+  createComponent
+} from "./chunk-Z3TWLQOI.js";
+import "./chunk-XXXIBXNC.js";
+
+// src/components/popover/popover-content.gen.ts
+import {
+  defaultPopoverContentProps
+} from "@prosekit/web/popover";
+var PopoverContent = createComponent(
+  "prosekit-popover-content",
+  defaultPopoverContentProps
+);
+
+// src/components/popover/popover-root.gen.ts
+import {
+  defaultPopoverRootProps
+} from "@prosekit/web/popover";
+var PopoverRoot = createComponent(
+  "prosekit-popover-root",
+  defaultPopoverRootProps
+);
+
+// src/components/popover/popover-trigger.gen.ts
+import {
+  defaultPopoverTriggerProps
+} from "@prosekit/web/popover";
+var PopoverTrigger = createComponent(
+  "prosekit-popover-trigger",
+  defaultPopoverTriggerProps
+);
+export {
+  PopoverContent,
+  PopoverRoot,
+  PopoverTrigger
+};

package/dist/prosekit-solid-resizable.d.ts

@@ -0,0 +1,2 @@
+export { ResizableHandle } from './_tsup-dts-rollup';
+export { ResizableRoot } from './_tsup-dts-rollup';

package/dist/prosekit-solid-resizable.js

@@ -0,0 +1,26 @@
+import {
+  createComponent
+} from "./chunk-Z3TWLQOI.js";
+import "./chunk-XXXIBXNC.js";
+
+// src/components/resizable/resizable-handle.gen.ts
+import {
+  defaultResizableHandleProps
+} from "@prosekit/web/resizable";
+var ResizableHandle = createComponent(
+  "prosekit-resizable-handle",
+  defaultResizableHandleProps
+);
+
+// src/components/resizable/resizable-root.gen.ts
+import {
+  defaultResizableRootProps
+} from "@prosekit/web/resizable";
+var ResizableRoot = createComponent(
+  "prosekit-resizable-root",
+  defaultResizableRootProps
+);
+export {
+  ResizableHandle,
+  ResizableRoot
+};

package/dist/prosekit-solid-tooltip.d.ts

@@ -0,0 +1,3 @@
+export { TooltipContent } from './_tsup-dts-rollup';
+export { TooltipRoot } from './_tsup-dts-rollup';
+export { TooltipTrigger } from './_tsup-dts-rollup';

package/dist/prosekit-solid-tooltip.js

@@ -0,0 +1,36 @@
+import {
+  createComponent
+} from "./chunk-Z3TWLQOI.js";
+import "./chunk-XXXIBXNC.js";
+
+// src/components/tooltip/tooltip-content.gen.ts
+import {
+  defaultTooltipContentProps
+} from "@prosekit/web/tooltip";
+var TooltipContent = createComponent(
+  "prosekit-tooltip-content",
+  defaultTooltipContentProps
+);
+
+// src/components/tooltip/tooltip-root.gen.ts
+import {
+  defaultTooltipRootProps
+} from "@prosekit/web/tooltip";
+var TooltipRoot = createComponent(
+  "prosekit-tooltip-root",
+  defaultTooltipRootProps
+);
+
+// src/components/tooltip/tooltip-trigger.gen.ts
+import {
+  defaultTooltipTriggerProps
+} from "@prosekit/web/tooltip";
+var TooltipTrigger = createComponent(
+  "prosekit-tooltip-trigger",
+  defaultTooltipTriggerProps
+);
+export {
+  TooltipContent,
+  TooltipRoot,
+  TooltipTrigger
+};

package/dist/prosekit-solid.d.ts

@@ -0,0 +1,11 @@
+export { ProseKit } from './_tsup-dts-rollup';
+export { ProseKitProps } from './_tsup-dts-rollup';
+export { useEditor } from './_tsup-dts-rollup';
+export { useExtension } from './_tsup-dts-rollup';
+export { UseExtensionOptions } from './_tsup-dts-rollup';
+export { useKeymap } from './_tsup-dts-rollup';
+export { useStateUpdate } from './_tsup-dts-rollup';
+export { useDocChange } from './_tsup-dts-rollup';
+export { MaybeAccessor } from './_tsup-dts-rollup';
+export { PropsWithChildren } from './_tsup-dts-rollup';
+export { PropsWithClass } from './_tsup-dts-rollup';

package/dist/prosekit-solid.js

@@ -0,0 +1,127 @@
+import {
+  EditorContextProvider,
+  useEditorContext
+} from "./chunk-XXXIBXNC.js";
+
+// src/components/prosekit.ts
+import { createComponent } from "solid-js";
+var ProseKit = (props) => {
+  return createComponent(EditorContextProvider, {
+    get value() {
+      return props.editor;
+    },
+    get children() {
+      return props.children;
+    }
+  });
+};
+
+// src/hooks/use-editor.ts
+import {
+  ProseKitError,
+  defineMountHandler,
+  defineUpdateHandler,
+  union
+} from "@prosekit/core";
+import { createEffect, createSignal } from "solid-js";
+function useEditor(options) {
+  var _a;
+  const update = (_a = options == null ? void 0 : options.update) != null ? _a : false;
+  const editor = useEditorContext();
+  if (!editor) {
+    throw new ProseKitError(
+      "useEditor must be used within the ProseKit component"
+    );
+  }
+  const [depend, forceUpdate] = useForceUpdate();
+  createEffect(() => {
+    if (update) {
+      const extension = union([
+        defineMountHandler(forceUpdate),
+        defineUpdateHandler(forceUpdate)
+      ]);
+      return editor.use(extension);
+    }
+  }, [editor, update, forceUpdate]);
+  return () => {
+    depend();
+    return editor;
+  };
+}
+function useForceUpdate() {
+  return createSignal(void 0, { equals: false });
+}
+
+// src/hooks/use-extension.ts
+import "@prosekit/core";
+import "solid-js";
+
+// src/hooks/use-editor-extension.ts
+import { EditorNotFoundError } from "@prosekit/core";
+import { createEffect as createEffect2, onCleanup } from "solid-js";
+
+// src/utils/to-value.ts
+function toValue(v) {
+  return typeof v === "function" && v.length === 0 ? v() : v;
+}
+
+// src/hooks/use-editor-extension.ts
+function useEditorExtension(editorAccessor, extensionAccessor) {
+  const editorContext = useEditorContext();
+  createEffect2(() => {
+    const editor = toValue(editorAccessor) || toValue(editorContext);
+    const extension = extensionAccessor();
+    if (!editor) {
+      throw new EditorNotFoundError();
+    }
+    if (extension) {
+      onCleanup(editor.use(extension));
+    }
+  });
+}
+
+// src/hooks/use-priority-extension.ts
+import { withPriority } from "@prosekit/core";
+function usePriorityExtension(extension, priority) {
+  return () => {
+    const ext = extension();
+    return ext && priority ? withPriority(ext, priority) : ext;
+  };
+}
+
+// src/hooks/use-extension.ts
+function useExtension(extension, options) {
+  useEditorExtension(
+    options == null ? void 0 : options.editor,
+    usePriorityExtension(extension, options == null ? void 0 : options.priority)
+  );
+}
+
+// src/hooks/use-keymap.ts
+import { defineKeymap } from "@prosekit/core";
+function useKeymap(keymap, options) {
+  const extension = () => defineKeymap(keymap());
+  return useExtension(extension, options);
+}
+
+// src/hooks/use-state-update.ts
+import { defineUpdateHandler as defineUpdateHandler2 } from "@prosekit/core";
+function useStateUpdate(handler, options) {
+  const extension = defineUpdateHandler2((view) => handler(view.state));
+  return useExtension(() => extension, options);
+}
+
+// src/hooks/use-doc-change.ts
+import { defineDocChangeHandler } from "@prosekit/core";
+function useDocChange(handler, options) {
+  const extension = defineDocChangeHandler((view) => handler(view.state.doc));
+  return useExtension(() => extension, options);
+}
+export {
+  ProseKit,
+  useDocChange,
+  useEditor,
+  useExtension,
+  useKeymap,
+  useStateUpdate
+};

package/package.json

@@ -0,0 +1,117 @@
+{
+  "name": "@prosekit/solid",
+  "type": "module",
+  "version": "0.0.0-next-20240421132240",
+  "private": false,
+  "author": {
+    "name": "ocavue",
+    "email": "ocavue@gmail.com"
+  },
+  "license": "MIT",
+  "funding": "https://github.com/sponsors/ocavue",
+  "homepage": "https://github.com/ocavue/prosekit#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ocavue/prosekit.git",
+    "directory": "packages/solid"
+  },
+  "bugs": {
+    "url": "https://github.com/ocavue/prosekit/issues"
+  },
+  "keywords": [
+    "ProseMirror"
+  ],
+  "sideEffects": false,
+  "main": "./dist/prosekit-solid.js",
+  "module": "./dist/prosekit-solid.js",
+  "exports": {
+    ".": {
+      "types": "./dist/prosekit-solid.d.ts",
+      "import": "./dist/prosekit-solid.js",
+      "default": "./dist/prosekit-solid.js"
+    },
+    "./autocomplete": {
+      "types": "./dist/prosekit-solid-autocomplete.d.ts",
+      "import": "./dist/prosekit-solid-autocomplete.js",
+      "default": "./dist/prosekit-solid-autocomplete.js"
+    },
+    "./block-handle": {
+      "types": "./dist/prosekit-solid-block-handle.d.ts",
+      "import": "./dist/prosekit-solid-block-handle.js",
+      "default": "./dist/prosekit-solid-block-handle.js"
+    },
+    "./inline-popover": {
+      "types": "./dist/prosekit-solid-inline-popover.d.ts",
+      "import": "./dist/prosekit-solid-inline-popover.js",
+      "default": "./dist/prosekit-solid-inline-popover.js"
+    },
+    "./popover": {
+      "types": "./dist/prosekit-solid-popover.d.ts",
+      "import": "./dist/prosekit-solid-popover.js",
+      "default": "./dist/prosekit-solid-popover.js"
+    },
+    "./resizable": {
+      "types": "./dist/prosekit-solid-resizable.d.ts",
+      "import": "./dist/prosekit-solid-resizable.js",
+      "default": "./dist/prosekit-solid-resizable.js"
+    },
+    "./tooltip": {
+      "types": "./dist/prosekit-solid-tooltip.d.ts",
+      "import": "./dist/prosekit-solid-tooltip.js",
+      "default": "./dist/prosekit-solid-tooltip.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@prosekit/core": "0.0.0-next-20240421132240",
+    "@prosekit/pm": "0.0.0-next-20240421132240",
+    "@prosekit/web": "0.0.0-next-20240421132240"
+  },
+  "peerDependencies": {
+    "solid-js": ">= 1.7.0"
+  },
+  "peerDependenciesMeta": {
+    "solid-js": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@prosekit/dev": "*",
+    "solid-js": "^1.8.16",
+    "tsup": "^8.0.2",
+    "typescript": "^5.4.5",
+    "vitest": "^1.5.0"
+  },
+  "scripts": {
+    "build:tsup": "tsup",
+    "build:tsc": "tsc -b tsconfig.json"
+  },
+  "types": "./dist/prosekit-solid.d.ts",
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/prosekit-solid.d.ts"
+      ],
+      "autocomplete": [
+        "./dist/prosekit-solid-autocomplete.d.ts"
+      ],
+      "block-handle": [
+        "./dist/prosekit-solid-block-handle.d.ts"
+      ],
+      "inline-popover": [
+        "./dist/prosekit-solid-inline-popover.d.ts"
+      ],
+      "popover": [
+        "./dist/prosekit-solid-popover.d.ts"
+      ],
+      "resizable": [
+        "./dist/prosekit-solid-resizable.d.ts"
+      ],
+      "tooltip": [
+        "./dist/prosekit-solid-tooltip.d.ts"
+      ]
+    }
+  }
+}