@prosekit/web 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,679 @@
+import { BaseElement } from '@aria-ui/core';
+import { ConnectableElement } from '@aria-ui/core';
+import { Context } from '@aria-ui/core';
+import { defaultPopoverContentProps } from '@aria-ui/popover';
+import { defaultPopoverRootProps } from '@aria-ui/popover';
+import { defaultPopoverTriggerProps } from '@aria-ui/popover';
+import { defaultTooltipContentProps } from '@aria-ui/tooltip';
+import { defaultTooltipRootProps } from '@aria-ui/tooltip';
+import { Editor } from '@prosekit/core';
+import type { EditorView } from '@prosekit/pm/view';
+import { Extension } from '@prosekit/core';
+import { FocusChangeHandler } from '@prosekit/core';
+import { ListboxProps } from '@aria-ui/listbox';
+import { Options } from 'tsup';
+import type { OverlayPositionerProps } from '@aria-ui/overlay';
+import type { Placement } from '@floating-ui/dom';
+import { PopoverContentProps } from '@aria-ui/popover';
+import { PopoverRootProps } from '@aria-ui/popover';
+import { PopoverTriggerProps } from '@aria-ui/popover';
+import type { ProseMirrorNode } from '@prosekit/pm/model';
+import { ReadonlySignal } from '@aria-ui/core';
+import type { ReferenceElement } from '@floating-ui/dom';
+import type { Selection as Selection_2 } from '@prosekit/pm/state';
+import { SignalState } from '@aria-ui/core';
+import { TooltipContentProps } from '@aria-ui/tooltip';
+import { TooltipRootProps } from '@aria-ui/tooltip';
+import { UpdateHandler } from '@prosekit/core';
+import { usePopoverContent } from '@aria-ui/popover';
+import { usePopoverRoot } from '@aria-ui/popover';
+import { useTooltipContent } from '@aria-ui/tooltip';
+import { useTooltipRoot } from '@aria-ui/tooltip';
+import type { VirtualElement } from '@floating-ui/dom';
+
+declare class AutocompleteEmptyElement extends BaseElement implements AutocompleteEmptyProps {
+    readonly _s: SignalState<AutocompleteEmptyProps>;
+    constructor();
+}
+
+declare interface AutocompleteEmptyElement extends AutocompleteEmptyProps {
+}
+export { AutocompleteEmptyElement }
+export { AutocompleteEmptyElement as AutocompleteEmptyElement_alias_1 }
+
+declare interface AutocompleteEmptyProps {
+}
+export { AutocompleteEmptyProps }
+export { AutocompleteEmptyProps as AutocompleteEmptyProps_alias_1 }
+
+declare class AutocompleteItemElement extends BaseElement implements AutocompleteItemProps {
+    readonly _s: SignalState<AutocompleteItemProps>;
+    constructor();
+}
+
+declare interface AutocompleteItemElement extends AutocompleteItemProps {
+}
+export { AutocompleteItemElement }
+export { AutocompleteItemElement as AutocompleteItemElement_alias_1 }
+
+declare interface AutocompleteItemProps {
+    /**
+     * The value of the item, which will be matched against the query.
+     *
+     * If not provided, the value is the item's text content.
+     *
+     * @default ""
+     */
+    value: string;
+    /**
+     * The function to call when the item is selected.
+     *
+     * @default null
+     */
+    onSelect: VoidFunction | null;
+}
+export { AutocompleteItemProps }
+export { AutocompleteItemProps as AutocompleteItemProps_alias_1 }
+
+declare class AutocompleteListElement extends BaseElement implements AutocompleteListProps {
+    readonly _s: SignalState<AutocompleteListProps>;
+    constructor();
+}
+
+declare interface AutocompleteListElement extends AutocompleteListProps {
+}
+export { AutocompleteListElement }
+export { AutocompleteListElement as AutocompleteListElement_alias_1 }
+
+declare interface AutocompleteListProps extends Pick<ListboxProps, 'filter'> {
+    editor: Editor | null;
+}
+export { AutocompleteListProps }
+export { AutocompleteListProps as AutocompleteListProps_alias_1 }
+
+declare class AutocompletePopoverElement extends BaseElement implements AutocompletePopoverProps {
+    readonly _s: SignalState<AutocompletePopoverProps>;
+    constructor();
+}
+
+declare interface AutocompletePopoverElement extends AutocompletePopoverProps {
+}
+export { AutocompletePopoverElement }
+export { AutocompletePopoverElement as AutocompletePopoverElement_alias_1 }
+
+declare interface AutocompletePopoverProps extends OverlayPositionerProps {
+    /**
+     * The ProseKit editor instance.
+     *
+     * @default null
+     */
+    editor: Editor | null;
+    /**
+     * The regular expression to match the query text to autocomplete.
+     *
+     * @default null
+     */
+    regex: RegExp | null;
+    /**
+     * A callback that is called when the query changes.
+     */
+    onQueryChange: ((query: string) => void) | null;
+    /**
+     * A callback that is called when the open state changes.
+     */
+    onOpenChange: ((open: boolean) => void) | null;
+    /**
+     * The placement of the popover, relative to the text cursor.
+     *
+     * @default "bottom-start"
+     */
+    placement: OverlayPositionerProps['placement'];
+    /**
+     * The distance between the popover and the hovered block.
+     *
+     * @default 4
+     */
+    offset: OverlayPositionerProps['offset'];
+    /**
+     * @default true
+     */
+    inline: OverlayPositionerProps['inline'];
+    /**
+     * @default true
+     */
+    hoist: OverlayPositionerProps['hoist'];
+    /**
+     * @default true
+     */
+    fitViewport: OverlayPositionerProps['fitViewport'];
+    /**
+     * @default "The body element"
+     */
+    boundary: OverlayPositionerProps['boundary'];
+    /**
+     * @default 8
+     */
+    overflowPadding: OverlayPositionerProps['overflowPadding'];
+}
+export { AutocompletePopoverProps }
+export { AutocompletePopoverProps as AutocompletePopoverProps_alias_1 }
+
+declare class BlockDragHandleElement extends BaseElement implements BlockDragHandleProps {
+    readonly _s: SignalState<BlockDragHandleProps>;
+    constructor();
+}
+
+declare interface BlockDragHandleElement extends BlockDragHandleProps {
+}
+export { BlockDragHandleElement }
+export { BlockDragHandleElement as BlockDragHandleElement_alias_1 }
+
+declare interface BlockDragHandleProps {
+    /**
+     * The ProseKit editor instance.
+     *
+     * @default null
+     */
+    editor: Editor | null;
+}
+export { BlockDragHandleProps }
+export { BlockDragHandleProps as BlockDragHandleProps_alias_1 }
+
+/**
+ * @internal
+ */
+export declare interface BlockPopoverContext {
+    pos: number | null;
+    node: ProseMirrorNode | null;
+    element: HTMLElement | null;
+}
+
+/**
+ * @internal
+ */
+export declare const blockPopoverContext: Context<BlockPopoverContext>;
+
+declare class BlockPopoverElement extends BaseElement implements BlockPopoverProps {
+    readonly _s: SignalState<BlockPopoverProps>;
+    constructor();
+}
+
+declare interface BlockPopoverElement extends BlockPopoverProps {
+}
+export { BlockPopoverElement }
+export { BlockPopoverElement as BlockPopoverElement_alias_1 }
+
+declare interface BlockPopoverProps extends Omit<OverlayPositionerProps, 'placement' | 'offset'> {
+    /**
+     * The ProseKit editor instance.
+     *
+     * @default null
+     */
+    editor: Editor | null;
+    /**
+     * The placement of the popover, relative to the hovered block.
+     *
+     * @default "left-start"
+     */
+    placement: Placement;
+    /**
+     * The distance between the popover and the hovered block.
+     *
+     * @default 4
+     */
+    offset: number;
+}
+export { BlockPopoverProps }
+export { BlockPopoverProps as BlockPopoverProps_alias_1 }
+
+export declare function calcResize(position: 'top' | 'right' | 'bottom' | 'left' | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right', w: number, h: number, dx: number, dy: number, aspectRatio: number | null | undefined): [w: number, h: number];
+
+export declare const default_alias: Options | Options[] | ((overrideOptions: Options) => Options | Options[] | Promise<Options | Options[]>);
+
+export declare const default_alias_1: {
+    test: {
+        environment: "jsdom";
+    };
+};
+
+declare const defaultAutocompleteEmptyProps: {};
+export { defaultAutocompleteEmptyProps }
+export { defaultAutocompleteEmptyProps as defaultAutocompleteEmptyProps_alias_1 }
+
+declare const defaultAutocompleteItemProps: {
+    value: string;
+    onSelect: null;
+};
+export { defaultAutocompleteItemProps }
+export { defaultAutocompleteItemProps as defaultAutocompleteItemProps_alias_1 }
+
+declare const defaultAutocompleteListProps: {
+    filter: (options: {
+        query: string;
+        value: string;
+    }) => boolean;
+    editor: null;
+};
+export { defaultAutocompleteListProps }
+export { defaultAutocompleteListProps as defaultAutocompleteListProps_alias_1 }
+
+declare const defaultAutocompletePopoverProps: Readonly<{
+    editor: null;
+    regex: null;
+    onQueryChange: null;
+    onOpenChange: null;
+    placement: "bottom-start";
+    offset: 4;
+    inline: true;
+    hoist: true;
+    fitViewport: true;
+    boundary: HTMLBodyElement | "clippingAncestors";
+    overflowPadding: 8;
+    strategy: "absolute";
+    autoUpdate: true;
+    transform: false;
+    flip: false;
+    shift: false;
+    overlap: false;
+    sameWidth: false;
+    sameHeight: false;
+    hide: false;
+    rootBoundary: "viewport";
+    elementContext: "floating";
+    altBoundary: true;
+}>;
+export { defaultAutocompletePopoverProps }
+export { defaultAutocompletePopoverProps as defaultAutocompletePopoverProps_alias_1 }
+
+declare const defaultBlockDragHandleProps: Readonly<{
+    editor: null;
+}>;
+export { defaultBlockDragHandleProps }
+export { defaultBlockDragHandleProps as defaultBlockDragHandleProps_alias_1 }
+
+declare const defaultBlockPopoverProps: Readonly<{
+    editor: null;
+    placement: "left-start";
+    offset: 4;
+    strategy: "absolute";
+    autoUpdate: true;
+    hoist: false;
+    transform: false;
+    flip: false;
+    shift: false;
+    overlap: false;
+    fitViewport: false;
+    sameWidth: false;
+    sameHeight: false;
+    inline: false;
+    hide: false;
+    boundary: "clippingAncestors";
+    rootBoundary: "viewport";
+    overflowPadding: 0;
+    elementContext: "floating";
+    altBoundary: true;
+}>;
+export { defaultBlockPopoverProps }
+export { defaultBlockPopoverProps as defaultBlockPopoverProps_alias_1 }
+
+declare const defaultInlinePopoverProps: Readonly<{
+    editor: null;
+    open: true;
+    onOpenChange: null;
+    placement: "top";
+    offset: 12;
+    flip: true;
+    hide: true;
+    overlap: true;
+    inline: true;
+    hoist: true;
+    strategy: "absolute";
+    autoUpdate: true;
+    transform: false;
+    shift: false;
+    fitViewport: false;
+    sameWidth: false;
+    sameHeight: false;
+    boundary: "clippingAncestors";
+    rootBoundary: "viewport";
+    overflowPadding: 0;
+    elementContext: "floating";
+    altBoundary: true;
+}>;
+export { defaultInlinePopoverProps }
+export { defaultInlinePopoverProps as defaultInlinePopoverProps_alias_1 }
+
+export { defaultPopoverContentProps }
+export { defaultPopoverContentProps as defaultPopoverContentProps_alias_1 }
+
+export { defaultPopoverRootProps }
+export { defaultPopoverRootProps as defaultPopoverRootProps_alias_1 }
+
+export { defaultPopoverTriggerProps }
+export { defaultPopoverTriggerProps as defaultPopoverTriggerProps_alias_1 }
+
+export declare function defaultQueryBuilder(match: RegExpExecArray): string;
+
+declare const defaultResizableHandleProps: {
+    position: "bottom-right";
+};
+export { defaultResizableHandleProps }
+export { defaultResizableHandleProps as defaultResizableHandleProps_alias_1 }
+
+declare const defaultResizableRootProps: {
+    width: null;
+    height: null;
+    aspectRatio: null;
+    onSizeChangeStart: null;
+    onSizeChange: null;
+    onSizeChangeEnd: null;
+};
+export { defaultResizableRootProps }
+export { defaultResizableRootProps as defaultResizableRootProps_alias_1 }
+
+export { defaultTooltipContentProps }
+export { defaultTooltipContentProps as defaultTooltipContentProps_alias_1 }
+
+export { defaultTooltipRootProps }
+export { defaultTooltipRootProps as defaultTooltipRootProps_alias_1 }
+
+declare const defaultTooltipTriggerProps: {};
+export { defaultTooltipTriggerProps }
+export { defaultTooltipTriggerProps as defaultTooltipTriggerProps_alias_1 }
+
+export declare function defineCustomElement(name: string, constructor: CustomElementConstructor, options?: ElementDefinitionOptions): void;
+
+export declare function defineElementHoverHandler(handler: ElementHoverHandler): Extension<    {}>;
+
+export declare function defineProperties(ElementConstructor: new () => {
+    _s: SignalState<any>;
+}, defaultProps: Record<string, any>): void;
+
+export declare type ElementHoverHandler = (reference: VirtualElement | null, element: HTMLElement | null, node: ProseMirrorNode | null, pos: number | null) => void;
+
+export declare function getVirtualSelectionElement(view: EditorView): ReferenceElement | null;
+
+declare class InlinePopoverElement extends BaseElement implements InlinePopoverProps {
+    readonly _s: SignalState<InlinePopoverProps>;
+    constructor();
+}
+
+declare interface InlinePopoverElement extends InlinePopoverProps {
+}
+export { InlinePopoverElement }
+export { InlinePopoverElement as InlinePopoverElement_alias_1 }
+
+declare interface InlinePopoverProps extends Omit<OverlayPositionerProps, 'placement' | 'offset'> {
+    /**
+     * The ProseKit editor instance.
+     *
+     * @default null
+     */
+    editor: Editor | null;
+    /**
+     * Whether the popover is open.
+     *
+     * Notice that the popover will be always hidden if the inline selection is empty.
+     *
+     * @default `true`
+     */
+    open: boolean;
+    /**
+     * A callback that is called when the popover's open state changes.
+     *
+     * @default null
+     */
+    onOpenChange: ((open: boolean) => void) | null;
+    /**
+     * The placement of the popover, relative to the selected inline content.
+     *
+     * @default "top"
+     */
+    placement: OverlayPositionerProps['placement'];
+    /**
+     * @default 12
+     */
+    offset: OverlayPositionerProps['offset'];
+    /**
+     * @default true
+     */
+    flip: OverlayPositionerProps['flip'];
+    /**
+     * @default true
+     */
+    hide: OverlayPositionerProps['hide'];
+    /**
+     * @default true
+     */
+    overlap: OverlayPositionerProps['overlap'];
+    /**
+     * @default true
+     */
+    inline: OverlayPositionerProps['inline'];
+    /**
+     * @default true
+     */
+    hoist: OverlayPositionerProps['hoist'];
+}
+export { InlinePopoverProps }
+export { InlinePopoverProps as InlinePopoverProps_alias_1 }
+
+export declare function isFinitePositiveNumber(value: unknown): value is number;
+
+export declare function isInCodeBlock(selection: Selection_2): boolean | undefined;
+
+/**
+ * @internal
+ */
+export declare type OnResize = ((width: number, height: number) => void) | null;
+
+/**
+ * @internal
+ */
+export declare const onResizeContext: Context<OnResize>;
+
+/**
+ * @internal
+ */
+export declare type OnResizeEnd = (() => void) | null;
+
+/**
+ * @internal
+ */
+export declare const onResizeEndContext: Context<OnResizeEnd>;
+
+/**
+ * @internal
+ */
+export declare type OnResizeStart = (() => readonly [width: number, height: number, aspectRatio: number]) | null;
+
+/**
+ * @internal
+ */
+export declare const onResizeStartContext: Context<OnResizeStart>;
+
+export declare const onSubmitContext: Context<VoidFunction | null>;
+
+export declare const openContext: Context<boolean>;
+
+declare class PopoverContentElement extends BaseElement implements PopoverContentProps {
+    readonly _s: SignalState<PopoverContentProps>;
+    constructor();
+}
+
+declare interface PopoverContentElement extends PopoverContentProps {
+}
+export { PopoverContentElement }
+export { PopoverContentElement as PopoverContentElement_alias_1 }
+
+export { PopoverContentProps }
+export { PopoverContentProps as PopoverContentProps_alias_1 }
+
+declare class PopoverRootElement extends BaseElement implements PopoverRootProps {
+    readonly _s: SignalState<PopoverRootProps>;
+    constructor();
+}
+
+declare interface PopoverRootElement extends PopoverRootProps {
+}
+export { PopoverRootElement }
+export { PopoverRootElement as PopoverRootElement_alias_1 }
+
+export { PopoverRootProps }
+export { PopoverRootProps as PopoverRootProps_alias_1 }
+
+declare class PopoverTriggerElement extends BaseElement implements PopoverTriggerProps {
+    readonly _s: SignalState<PopoverTriggerProps>;
+    constructor();
+}
+
+declare interface PopoverTriggerElement extends PopoverTriggerProps {
+}
+export { PopoverTriggerElement }
+export { PopoverTriggerElement as PopoverTriggerElement_alias_1 }
+
+export { PopoverTriggerProps }
+export { PopoverTriggerProps as PopoverTriggerProps_alias_1 }
+
+export declare const queryContext: Context<string>;
+
+declare class ResizableHandleElement extends BaseElement implements ResizableHandleProps {
+    readonly _s: SignalState<ResizableHandleProps>;
+    constructor();
+}
+
+declare interface ResizableHandleElement extends ResizableHandleProps {
+}
+export { ResizableHandleElement }
+export { ResizableHandleElement as ResizableHandleElement_alias_1 }
+
+declare interface ResizableHandleProps {
+    /**
+     * The position of the handle.
+     *
+     * @default "bottom-right"
+     */
+    position: 'top' | 'right' | 'bottom' | 'left' | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+}
+export { ResizableHandleProps }
+export { ResizableHandleProps as ResizableHandleProps_alias_1 }
+
+declare class ResizableRootElement extends BaseElement implements ResizableRootProps {
+    readonly _s: SignalState<ResizableRootProps>;
+    constructor();
+}
+
+declare interface ResizableRootElement extends ResizableRootProps {
+}
+export { ResizableRootElement }
+export { ResizableRootElement as ResizableRootElement_alias_1 }
+
+declare interface ResizableRootProps {
+    width: number | null;
+    height: number | null;
+    aspectRatio: number | null;
+    onSizeChangeStart: ((size: {
+        width: number;
+        height: number;
+    }) => void) | null;
+    onSizeChange: ((size: {
+        width: number;
+        height: number;
+    }) => void) | null;
+    onSizeChangeEnd: ((size: {
+        width: number;
+        height: number;
+    }) => void) | null;
+}
+export { ResizableRootProps }
+export { ResizableRootProps as ResizableRootProps_alias_1 }
+
+/**
+ * @internal
+ */
+export declare function throttle<Args extends any[]>(callback: (...args: Args) => void, wait: number): (...args: Args) => void;
+
+declare class TooltipContentElement extends BaseElement implements TooltipContentProps {
+    readonly _s: SignalState<TooltipContentProps>;
+    constructor();
+}
+
+declare interface TooltipContentElement extends TooltipContentProps {
+}
+export { TooltipContentElement }
+export { TooltipContentElement as TooltipContentElement_alias_1 }
+
+export { TooltipContentProps }
+export { TooltipContentProps as TooltipContentProps_alias_1 }
+
+declare class TooltipRootElement extends BaseElement implements TooltipRootProps {
+    readonly _s: SignalState<TooltipRootProps>;
+    constructor();
+}
+
+declare interface TooltipRootElement extends TooltipRootProps {
+}
+export { TooltipRootElement }
+export { TooltipRootElement as TooltipRootElement_alias_1 }
+
+export { TooltipRootProps }
+export { TooltipRootProps as TooltipRootProps_alias_1 }
+
+declare class TooltipTriggerElement extends BaseElement implements TooltipTriggerProps {
+    readonly _s: SignalState<TooltipTriggerProps>;
+    constructor();
+}
+
+declare interface TooltipTriggerElement extends TooltipTriggerProps {
+}
+export { TooltipTriggerElement }
+export { TooltipTriggerElement as TooltipTriggerElement_alias_1 }
+
+declare interface TooltipTriggerProps {
+}
+export { TooltipTriggerProps }
+export { TooltipTriggerProps as TooltipTriggerProps_alias_1 }
+
+export declare function useAutocompleteEmpty(element: ConnectableElement, _props?: Partial<AutocompleteEmptyProps>): SignalState<AutocompleteEmptyProps>;
+
+export declare function useAutocompleteItem(element: ConnectableElement, props?: Partial<AutocompleteItemProps>): SignalState<AutocompleteItemProps>;
+
+export declare function useAutocompleteList(element: ConnectableElement, props?: Partial<AutocompleteListProps>): SignalState<AutocompleteListProps>;
+
+export declare function useAutocompletePopover(host: ConnectableElement, props?: Partial<AutocompletePopoverProps>): SignalState<Readonly<AutocompletePopoverProps>>;
+
+export declare function useBlockDragHandle(host: ConnectableElement, props?: Partial<BlockDragHandleProps>): SignalState<BlockDragHandleProps>;
+
+export declare function useBlockPopover(host: ConnectableElement, props?: Partial<BlockPopoverProps>): SignalState<BlockPopoverProps>;
+
+export declare function useEditorExtension(host: ConnectableElement, editor: ReadonlySignal<Editor | null>, extension: Extension): void;
+
+/**
+ * @internal
+ */
+export declare function useEditorFocusChangeEvent(host: ConnectableElement, editor: ReadonlySignal<Editor | null>, handler: FocusChangeHandler): void;
+
+/**
+ * @internal
+ */
+export declare function useEditorUpdateEvent(host: ConnectableElement, editor: ReadonlySignal<Editor | null>, handler: UpdateHandler): void;
+
+export declare function useInlinePopover(host: ConnectableElement, props?: Partial<InlinePopoverProps>): SignalState<Readonly<InlinePopoverProps>>;
+
+export { usePopoverContent }
+
+export { usePopoverRoot }
+
+export declare function usePopoverTrigger(host: ConnectableElement): {};
+
+export declare function useResizableHandle(host: ConnectableElement, props?: Partial<ResizableHandleProps>): SignalState<Readonly<ResizableHandleProps>>;
+
+export declare function useResizableRoot(host: ConnectableElement, props?: Partial<ResizableRootProps>): SignalState<Readonly<ResizableRootProps>>;
+
+export { useTooltipContent }
+
+export { useTooltipRoot }
+
+export declare function useTooltipTrigger(host: ConnectableElement): {};
+
+export { }