@prosekit/lit 0.0.0-next-20230709090937 → 0.0.0-next-20231120040948

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

@@ -0,0 +1,456 @@
+import { AutoUpdateOptions } from '@floating-ui/dom';
+import { ComputePositionConfig } from '@floating-ui/dom';
+import { CSSResult } from 'lit';
+import { Editor } from '@prosekit/core';
+import type { EditorView } from '@prosekit/pm/view';
+import { Keymap } from '@prosekit/core';
+import { LitElement } from 'lit';
+import { Options } from 'tsup';
+import { PropertyValues } from 'lit';
+import { ReactiveController } from 'lit';
+import { ReactiveControllerHost } from 'lit';
+import { TemplateResult } from 'lit';
+import { UserProjectConfigExport } from 'vitest/dist/config.js';
+import { VirtualElement } from '@floating-ui/dom';
+
+export declare class AutocompleteEmpty extends LightElement implements AutocompleteEmptyProps {
+    listContext?: AutocompleteListContext;
+    connectedCallback(): void;
+    protected willUpdate(_changedProperties: PropertyValues<this>): void;
+}
+
+export declare interface AutocompleteEmptyProps {
+}
+
+/**
+ * Command menu item. Becomes active on pointer enter or through keyboard
+ * navigation. Preferably pass a `value`, otherwise the value will be inferred
+ * from the rendered item's `textContent`.
+ */
+declare class AutocompleteItem extends LightElement implements Partial<AutocompleteItemProps> {
+    value: string;
+    selected: boolean;
+    /** @hidden */
+    onSelect?: VoidFunction;
+    listContext?: AutocompleteListContext;
+    get content(): string;
+    connectedCallback(): void;
+    protected willUpdate(): void;
+    protected updated(changedProperties: PropertyValues<this>): void;
+}
+export { AutocompleteItem }
+export { AutocompleteItem as AutocompleteItem_alias_1 }
+
+declare interface AutocompleteItemProps {
+    value?: string;
+    onSelect: VoidFunction;
+}
+export { AutocompleteItemProps }
+export { AutocompleteItemProps as AutocompleteItemProps_alias_1 }
+
+declare class AutocompleteList extends LightElement implements Partial<AutocompleteListProps> {
+    /** @hidden */
+    private listManager;
+    /** @hidden */
+    private controller;
+    private get active();
+    editor?: Editor;
+    popoverContext: AutocompletePopoverContext | null;
+    context: AutocompleteListContext;
+    connectedCallback(): void;
+    private get items();
+    selectFirstItem(): void;
+    private updateValue;
+    /** @hidden */
+    willUpdate(changedProperties: PropertyValues<this>): void;
+}
+export { AutocompleteList }
+export { AutocompleteList as AutocompleteList_alias_1 }
+
+export declare interface AutocompleteListContext {
+    scores: Map<string, number>;
+    selectedValue: string;
+}
+
+export declare class AutocompleteListController implements ReactiveController {
+    private host;
+    private keymap;
+    private editor;
+    private cleanup;
+    constructor(host: ReactiveControllerHost, keymap: Keymap);
+    setEditor(editor: Editor): void;
+    hostDisconnected(): void;
+    private defineExtension;
+}
+
+declare interface AutocompleteListProps {
+    editor: Editor;
+}
+export { AutocompleteListProps }
+export { AutocompleteListProps as AutocompleteListProps_alias_1 }
+
+export declare class AutocompletePopover extends Popover implements Partial<AutocompletePopoverProps> {
+    /** @hidden */
+    private controller;
+    editor?: Editor;
+    regex?: RegExp;
+    popoverOptions: PopoverOptions;
+    context: AutocompletePopoverContext;
+    /** @hidden */
+    onSelect?: VoidFunction;
+    private get list();
+    private updateContext;
+    /** @hidden */
+    willUpdate(changedProperties: PropertyValues<this>): void;
+    /** @hidden */
+    hide(): void;
+}
+
+export declare interface AutocompletePopoverContext {
+    active: boolean;
+    query: string;
+    handleDismiss: VoidFunction;
+    handleSubmit: VoidFunction;
+}
+
+export declare class AutocompletePopoverController implements ReactiveController {
+    private host;
+    private onChange;
+    reference: Element | null;
+    private editor;
+    private regex;
+    private cleanup;
+    handleDismiss: VoidFunction | null;
+    handleSubmit: VoidFunction | null;
+    constructor(host: ReactiveControllerHost, onChange: (query: string, active: boolean) => void);
+    setEditor(editor: Editor): void;
+    setRegex(regex: RegExp): void;
+    private defineExtension;
+    hostDisconnected(): void;
+}
+
+export declare interface AutocompletePopoverProps {
+    editor: Editor;
+    regex: RegExp;
+    popoverOptions?: PopoverOptions;
+}
+
+export { AutoUpdateOptions }
+
+export declare const blockComponentStyles: CSSResult;
+
+export declare class ComboBox extends Popover {
+    onDismiss?: VoidFunction;
+    private listManager;
+    context: ComboBoxContext;
+    get items(): ComboBoxItem[];
+}
+
+export declare interface ComboBoxContext {
+    inputValue: string;
+    setInputValue: (val: string) => void;
+    selectedValue: string;
+    setSelectedValue: (val: string) => void;
+    listManager: ListManager<ComboBoxItem>;
+}
+
+export declare const comboBoxContext: {
+    __context__: ComboBoxContext;
+};
+
+export declare class ComboBoxInput extends LightElement {
+    placeholder: string;
+    comboBoxContext: ComboBoxContext | null;
+    private visible;
+    private handleKeydown;
+    private handleInput;
+    protected firstUpdated(): void;
+    /** @hidden */
+    render(): TemplateResult<1>;
+}
+
+export declare interface ComboBoxInputProps {
+    placeholder?: string;
+}
+
+declare class ComboBoxItem extends LightElement {
+    editor?: Editor;
+    selected: boolean;
+    comboBoxContext?: ComboBoxContext;
+    /** @hidden */
+    onSelect?: VoidFunction;
+    protected updated(): void;
+}
+export { ComboBoxItem }
+export { ComboBoxItem as ComboBoxItem_alias_1 }
+
+declare type ComboBoxItemProps = {
+    onSelect?: VoidFunction;
+};
+export { ComboBoxItemProps }
+export { ComboBoxItemProps as ComboBoxItemProps_alias_1 }
+
+declare class ComboBoxList extends LightElement {
+    comboBoxContext: ComboBoxContext | null;
+    connectedCallback(): void;
+}
+export { ComboBoxList }
+export { ComboBoxList as ComboBoxList_alias_1 }
+
+declare type ComboBoxListProps = {
+    lang?: string;
+};
+export { ComboBoxListProps }
+export { ComboBoxListProps as ComboBoxListProps_alias_1 }
+
+export declare interface ComboBoxProps extends PopoverProps {
+    onDismiss?: VoidFunction;
+}
+
+export declare const commandListContext: {
+    __context__: AutocompleteListContext;
+};
+
+export declare const commandPopoverContext: {
+    __context__: AutocompletePopoverContext;
+};
+
+declare type CommandScore = (item: string, query: string) => number;
+
+export declare const commandScore: CommandScore;
+
+export declare const componentStyles: CSSResult;
+
+export declare const default_alias: Options | Options[] | ((overrideOptions: Options) => Options | Options[] | Promise<Options | Options[]>);
+
+export declare const default_alias_1: UserProjectConfigExport;
+
+/**
+ * Default popover options.
+ */
+export declare const defaultPopoverOptions: PopoverOptions;
+
+/**
+ * Default popover options.
+ */
+export declare const defaultPopoverOptions_alias_1: PopoverOptions;
+
+export declare const defaultPopoverOptions_alias_2: PopoverOptions;
+
+export declare function defaultQueryBuilder(match: RegExpExecArray): string;
+
+export declare function getVirtualSelectionElement(view: EditorView): Range | undefined;
+
+export declare class InlinePopover extends Popover implements Partial<InlinePopoverProps> {
+    /** @hidden */
+    private controller;
+    editor?: Editor;
+    popoverOptions: PopoverOptions;
+    constructor();
+    /** @hidden */
+    willUpdate(): void;
+    /** @hidden */
+    hide(): void;
+}
+
+export declare class InlinePopoverController implements ReactiveController {
+    private host;
+    reference?: VirtualElement;
+    private editor?;
+    private cleanupExtension?;
+    private cleanupEventListener?;
+    private mouseHovering;
+    constructor(host: ReactiveControllerHost);
+    setEditor(editor: Editor): void;
+    hostConnected(): void;
+    hostDisconnected(): void;
+    private update;
+    private defineExtension;
+}
+
+export declare interface InlinePopoverProps {
+    editor: Editor;
+    popoverOptions?: PopoverOptions;
+}
+
+export declare function isAutocompleteItem(element?: Element | null): element is AutocompleteItem;
+
+export declare function isAutocompleteList(element?: Element | null): element is AutocompleteList;
+
+export declare function isComboBoxItem(element?: Element | null): element is ComboBoxItem;
+
+export declare function isComboBoxList(element?: Element | null): element is ComboBoxList;
+
+export declare class LightElement extends LitElement {
+    createRenderRoot(): this;
+    setHidden(hidden: boolean): void;
+}
+
+export declare class ListManager<Item extends {
+    hidden: boolean;
+} & HTMLElement> {
+    private lastMouseMoveTime;
+    private getItems;
+    private getSelectedValue;
+    private setSelectedValue;
+    private getItemValue;
+    private queryClosestItem;
+    private getActive;
+    private onDismiss;
+    private onSelect;
+    constructor(options: {
+        getItems: () => Item[];
+        getSelectedValue: () => string;
+        setSelectedValue: (value: string) => void;
+        getItemValue: (item: Item) => string;
+        queryClosestItem: (element: HTMLElement) => Item | null;
+        getActive: () => boolean;
+        onDismiss: () => void;
+        onSelect: (item?: Item | null) => void;
+    });
+    get items(): Item[];
+    get availableItems(): Item[];
+    get firstItem(): Item | null;
+    get selectedItem(): Item | null;
+    private updateSelectedByChange;
+    private handleSelect;
+    selectFirstItem(): void;
+    handleMouseMove(_event: MouseEvent): void;
+    handleMouseOver(event: MouseEvent): void;
+    handleMouseDown(event: MouseEvent): void;
+    handleClick(event: MouseEvent): void;
+    handleArrowUp(): boolean;
+    handleArrowDown(): boolean;
+    handleEscape(): boolean;
+    handleEnter(): boolean;
+}
+
+/**
+ * A custom element that displays a popover anchored to a reference element.
+ */
+export declare class Popover extends LightElement implements Partial<PopoverProps> {
+    /** @hidden */
+    constructor();
+    /**
+     * Controls the visibility of the popover element. When set to `true`, the popover is displayed and positioned
+     * relative to its reference element. When set to `false`, the popover is hidden and its positioning logic is
+     * deactivated.
+     */
+    active: boolean;
+    /**
+     * The element that the popover is anchored to. This can be either a DOM element or an object that implements the
+     * virtual element interface from Floating UI.
+     */
+    reference?: Element | VirtualElement;
+    /**
+     * The options that are passed to the `computePosition` function from Floating UI. These options are used to
+     * configure the positioning of the popover element relative to its reference element. For more information on the
+     * available options, please refer to the Floating UI documentation.
+     */
+    options?: PopoverOptions;
+    /**
+     * Controls whether the popover position is automatically updated when the reference element changes position. When
+     * set to `true`, the popover position is updated automatically. When set to `false`, the popover position is only
+     * updated when the given properties are changed.
+     *
+     * @default false
+     */
+    autoUpdate: boolean;
+    /**
+     * The options that are passed to the `autoUpdate` function from Floating UI. These options are used to configure the
+     * automatic update behavior of the popover position. For more information on the available options, please refer to
+     * the Floating UI documentation. This property is only used when the `autoUpdate` property is set to `true`.
+     */
+    autoUpdateOptions?: AutoUpdateOptions;
+    /**
+     * Controls whether the popover should be dismissed based on user interaction.
+     *
+     * Available options:
+     *
+     * - "off": The popover is not dismissed.
+     * - "on": The popover is dismissed when the user clicks outside of the popover or presses the escape key.
+     * - "click": The popover is dismissed when the user clicks outside of the popover.
+     * - "escape": The popover is dismissed when the user presses the escape key.
+     *
+     * @default "on"
+     */
+    dismiss: string;
+    /** @hidden */
+    private disposeAutoUpdate?;
+    /** @hidden */
+    private disposeEventListeners?;
+    /** @hidden */
+    connectedCallback(): void;
+    /** @hidden */
+    disconnectedCallback(): void;
+    /** @hidden */
+    protected updated(changedProperties: PropertyValues<this>): void;
+    /** @hidden */
+    private start;
+    /** @hidden */
+    private compute;
+    /** @hidden */
+    hide(): void;
+    private handleDocumentMouseDown;
+    private handleDocumentKeyDown;
+}
+
+/**
+ * The `PopoverOptions` interface defines the options that can be passed to the
+ * `computePosition` function from Floating UI. These options are used to
+ * configure the positioning of the popover element relative to its reference
+ * element. For more information on the available options, please refer to the
+ * Floating UI documentation.
+ *
+ * https://floating-ui.com/docs/computeposition#options
+ */
+declare type PopoverOptions = ComputePositionConfig;
+export { PopoverOptions }
+export { PopoverOptions as PopoverOptions_alias_1 }
+export { PopoverOptions as PopoverOptions_alias_2 }
+export { PopoverOptions as PopoverOptions_alias_3 }
+
+export declare interface PopoverProps {
+    active: boolean;
+    reference?: Element | VirtualElement;
+    options?: PopoverOptions;
+    autoUpdate?: boolean;
+    autoUpdateOptions?: AutoUpdateOptions;
+}
+
+export declare const propNames: readonly [];
+
+declare const propNames_2: readonly ["value", "onSelect"];
+export { propNames_2 as propNames_alias_1 }
+export { propNames_2 as propNames_alias_2 }
+
+declare const propNames_3: readonly ["editor"];
+export { propNames_3 as propNames_alias_3 }
+export { propNames_3 as propNames_alias_4 }
+
+declare const propNames_4: never[];
+export { propNames_4 as propNames_alias_8 }
+export { propNames_4 as propNames_alias_9 }
+
+declare const propNames_5: never[];
+export { propNames_5 as propNames_alias_10 }
+export { propNames_5 as propNames_alias_11 }
+
+export declare const propNames_alias_12: readonly ["editor", "popoverOptions"];
+
+export declare const propNames_alias_13: readonly ["active", "reference", "options", "autoUpdate", "autoUpdateOptions"];
+
+export declare const propNames_alias_5: readonly ["editor", "regex", "popoverOptions"];
+
+export declare const propNames_alias_6: readonly ["onDismiss"];
+
+export declare const propNames_alias_7: readonly ["placeholder"];
+
+export declare function queryClosestAutocompleteItem(element?: Element | null): AutocompleteItem | null;
+
+export declare function queryClosestComboBoxItem(element?: Element | null): ComboBoxItem | null;
+
+/** Rounds a value to the nearest device pixel ratio. */
+export declare function roundByDPR(value: number): number;
+
+export { }

package/dist/chunk-55G7TJI3.js

@@ -0,0 +1,48 @@
+import {
+  comboBoxContext
+} from "./chunk-C4MW43I4.js";
+import {
+  LightElement,
+  __decorateClass
+} from "./chunk-O5JP3B34.js";
+
+// src/components/combo-box-item/component.ts
+import { consume } from "@lit/context";
+import { customElement, property, state } from "lit/decorators.js";
+var propNames = [];
+var ComboBoxItem = class extends LightElement {
+  constructor() {
+    super(...arguments);
+    this.selected = false;
+  }
+  updated() {
+    var _a, _b, _c, _d;
+    const content = ((_a = this.textContent) != null ? _a : "").trim();
+    const query = ((_c = (_b = this.comboBoxContext) == null ? void 0 : _b.inputValue) != null ? _c : "").trim();
+    const match = content.toLowerCase().includes(query.toLowerCase());
+    this.selected = match && content === ((_d = this.comboBoxContext) == null ? void 0 : _d.selectedValue);
+    this.ariaSelected = String(this.selected);
+    this.setHidden(!match);
+  }
+};
+__decorateClass([
+  property({ attribute: false })
+], ComboBoxItem.prototype, "editor", 2);
+__decorateClass([
+  property({ type: Boolean, reflect: true, attribute: "data-selected" })
+], ComboBoxItem.prototype, "selected", 2);
+__decorateClass([
+  consume({ context: comboBoxContext, subscribe: true }),
+  state({})
+], ComboBoxItem.prototype, "comboBoxContext", 2);
+__decorateClass([
+  property({ attribute: false })
+], ComboBoxItem.prototype, "onSelect", 2);
+ComboBoxItem = __decorateClass([
+  customElement("prosekit-combo-box-item")
+], ComboBoxItem);
+
+export {
+  propNames,
+  ComboBoxItem
+};

package/dist/chunk-6P3YKUWI.js

@@ -0,0 +1,9 @@
+// src/components/autocomplete-list/context.ts
+import { createContext } from "@lit/context";
+var commandListContext = createContext(
+  "prosekit-autocomplete-list-context"
+);
+
+export {
+  commandListContext
+};

package/dist/chunk-7WLKD2U6.js

@@ -0,0 +1,184 @@
+import {
+  LightElement,
+  __decorateClass
+} from "./chunk-O5JP3B34.js";
+
+// src/components/popover/index.ts
+import {
+  autoUpdate,
+  computePosition
+} from "@floating-ui/dom";
+import { customElement, property } from "lit/decorators.js";
+
+// src/utils/round-by-dpr.ts
+function roundByDPR(value) {
+  const dpr = window.devicePixelRatio || 1;
+  return Math.round(value * dpr) / dpr;
+}
+
+// src/components/popover/default-popover-options.ts
+import { offset, shift, size } from "@floating-ui/dom";
+
+// src/components/popover/options.ts
+import "@floating-ui/dom";
+
+// src/components/popover/default-popover-options.ts
+var defaultPopoverOptions = {
+  placement: "bottom",
+  middleware: [
+    offset({ mainAxis: 8, crossAxis: 8 }),
+    shift({ padding: 8 }),
+    size({
+      apply: ({ availableWidth, availableHeight, elements }) => {
+        elements.floating.style.setProperty(
+          "max-width",
+          `${Math.floor(availableWidth)}px`
+        );
+        elements.floating.style.setProperty(
+          "max-height",
+          `${Math.floor(availableHeight)}px`
+        );
+      },
+      padding: 8
+    })
+  ]
+};
+
+// src/components/popover/index.ts
+var propNames = [
+  "active",
+  "reference",
+  "options",
+  "autoUpdate",
+  "autoUpdateOptions"
+];
+var Popover = class extends LightElement {
+  /** @hidden */
+  constructor() {
+    super();
+    this.active = false;
+    this.autoUpdate = false;
+    this.dismiss = "on";
+    this.handleDocumentMouseDown = (event) => {
+      const path = event.composedPath();
+      if (!path.includes(this)) {
+        this.hide();
+      }
+    };
+    this.handleDocumentKeyDown = (event) => {
+      if (event.key === "Escape" && this.active) {
+        event.stopPropagation();
+        this.hide();
+        return;
+      }
+    };
+  }
+  /** @hidden */
+  connectedCallback() {
+    super.connectedCallback();
+    const clickEnabled = this.dismiss === "on" || this.dismiss === "click";
+    const escapeEnabled = this.dismiss === "on" || this.dismiss === "escape";
+    const handleMouseDown = clickEnabled ? this.handleDocumentMouseDown.bind(this) : null;
+    const handleKeyDown = escapeEnabled ? this.handleDocumentKeyDown.bind(this) : null;
+    handleMouseDown && document.addEventListener("mousedown", handleMouseDown);
+    handleKeyDown && document.addEventListener("keydown", handleKeyDown);
+    this.disposeEventListeners = () => {
+      handleMouseDown && document.removeEventListener("mousedown", handleMouseDown);
+      handleKeyDown && document.removeEventListener("keydown", handleKeyDown);
+    };
+  }
+  /** @hidden */
+  disconnectedCallback() {
+    var _a, _b;
+    super.disconnectedCallback();
+    (_a = this.disposeAutoUpdate) == null ? void 0 : _a.call(this);
+    this.disposeAutoUpdate = void 0;
+    (_b = this.disposeEventListeners) == null ? void 0 : _b.call(this);
+    this.disposeEventListeners = void 0;
+  }
+  /** @hidden */
+  updated(changedProperties) {
+    super.updated(changedProperties);
+    this.start();
+    this.setHidden(!this.active);
+  }
+  /** @hidden */
+  start() {
+    var _a;
+    (_a = this.disposeAutoUpdate) == null ? void 0 : _a.call(this);
+    this.disposeAutoUpdate = void 0;
+    const reference = this.reference;
+    if (!reference)
+      return;
+    if (!this.active)
+      return;
+    if (this.autoUpdate) {
+      this.disposeAutoUpdate = autoUpdate(
+        reference,
+        this,
+        () => void this.compute(),
+        this.autoUpdateOptions
+      );
+    } else {
+      void this.compute();
+    }
+  }
+  /** @hidden */
+  async compute() {
+    var _a, _b, _c;
+    const reference = this.reference;
+    if (!reference)
+      return;
+    if (!this.active)
+      return;
+    this.setHidden(false);
+    this.style.setProperty("top", "0");
+    this.style.setProperty("left", "0");
+    this.style.setProperty("position", (_b = (_a = this.options) == null ? void 0 : _a.strategy) != null ? _b : "absolute");
+    const options = (_c = this.options) != null ? _c : defaultPopoverOptions;
+    const computed = await computePosition(reference, this, options);
+    const { x, y, strategy } = computed != null ? computed : { x: 0, y: 0, strategy: "absolute" };
+    this.style.setProperty("opacity", "1");
+    this.style.setProperty("position", strategy);
+    this.style.setProperty(
+      "transform",
+      `translate(${roundByDPR(x)}px,${roundByDPR(y)}px)`
+    );
+  }
+  /** @hidden */
+  hide() {
+    this.active = false;
+  }
+};
+__decorateClass([
+  property({ type: Boolean, reflect: true })
+], Popover.prototype, "active", 2);
+__decorateClass([
+  property({ attribute: false })
+], Popover.prototype, "reference", 2);
+__decorateClass([
+  property({ attribute: false })
+], Popover.prototype, "options", 2);
+__decorateClass([
+  property({
+    type: Boolean,
+    reflect: true
+  })
+], Popover.prototype, "autoUpdate", 2);
+__decorateClass([
+  property({ type: Object })
+], Popover.prototype, "autoUpdateOptions", 2);
+__decorateClass([
+  property({
+    type: String,
+    reflect: true
+  })
+], Popover.prototype, "dismiss", 2);
+Popover = __decorateClass([
+  customElement("prosekit-popover")
+], Popover);
+
+export {
+  propNames,
+  Popover
+};

package/dist/chunk-C4MW43I4.js

@@ -0,0 +1,9 @@
+// src/components/combo-box/context.ts
+import { createContext } from "@lit/context";
+var comboBoxContext = createContext(
+  "prosekit-combo-box-context"
+);
+
+export {
+  comboBoxContext
+};