@prosekit/lit 0.0.9 → 0.0.11

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

@@ -0,0 +1,469 @@
+import { AutoUpdateOptions } from '@floating-ui/dom';
+import { CommandArgs } from '@prosekit/core';
+import { ComputePositionConfig } from '@floating-ui/dom';
+import { CSSResult } from 'lit';
+import { CSSResultGroup } from 'lit';
+import { Editor } from '@prosekit/core';
+import { Extension } from '@prosekit/core';
+import { ExtensionTyping } from '@prosekit/core';
+import { Keymap } from '@prosekit/core';
+import { LitElement } from 'lit';
+import { Options } from 'tsup';
+import { PropertyValues } from 'lit';
+import type { ProseMirrorNode } from '@prosekit/pm/model';
+import { ReactiveController } from 'lit';
+import { ReactiveControllerHost } from 'lit';
+import { TemplateResult } from 'lit-html';
+import { UserProjectConfigExport } from 'vitest/dist/config.js';
+import { VirtualElement } from '@floating-ui/dom';
+
+/**
+ * Returns a ProseKit extension that call `onSelect` when the text selection is
+ * insert into a code block, and `onDismiss` when it is not.
+ */
+export declare function addCodeBlockSelect(options: {
+    onSelect: (info: {
+        pos: number;
+        node: ProseMirrorNode;
+        dom: HTMLElement;
+    }) => void;
+    onDismiss: () => void;
+}): Extension<ExtensionTyping<string, string, CommandArgs>>;
+
+export declare class AutocompleteEmpty extends LitElement implements AutocompleteEmptyProps {
+    /** @hidden */
+    static styles: CSSResultGroup;
+    listContext?: AutocompleteListContext;
+    protected willUpdate(_changedProperties: PropertyValues<this>): void;
+    /** @hidden */
+    render(): TemplateResult<1> | null;
+}
+
+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 LitElement implements Partial<AutocompleteItemProps> {
+    /** @hidden */
+    static styles: CSSResultGroup;
+    value: string;
+    selected: boolean;
+    /** @hidden */
+    onSelect?: VoidFunction;
+    /** @hidden */
+    defaultSlot?: HTMLSlotElement;
+    listContext?: AutocompleteListContext;
+    get content(): string;
+    protected willUpdate(changedProperties: PropertyValues<this>): void;
+    protected updated(changedProperties: PropertyValues<this>): void;
+    /** @hidden */
+    render(): TemplateResult<1> | null;
+}
+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 LitElement implements Partial<AutocompleteListProps> {
+    /** @hidden */
+    static styles: CSSResultGroup;
+    /** @hidden */
+    private listManager;
+    /** @hidden */
+    private controller;
+    private get active();
+    editor?: Editor;
+    popoverContext: AutocompletePopoverContext | null;
+    context: AutocompleteListContext;
+    protected firstUpdated(): void;
+    private get items();
+    selectFirstItem(): void;
+    private updateValue;
+    private registerValue;
+    /** @hidden */
+    defaultSlot?: HTMLSlotElement;
+    /** @hidden */
+    willUpdate(changedProperties: PropertyValues<this>): void;
+    /** @hidden */
+    render(): TemplateResult<1>;
+}
+export { AutocompleteList }
+export { AutocompleteList as AutocompleteList_alias_1 }
+
+export declare type AutocompleteListContext = {
+    scores: Map<string, number>;
+    selectedValue: string;
+    registerValue: (value: string) => VoidFunction;
+};
+
+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 addExtension;
+}
+
+declare interface AutocompleteListProps {
+    editor: Editor;
+}
+export { AutocompleteListProps }
+export { AutocompleteListProps as AutocompleteListProps_alias_1 }
+
+export declare class AutocompletePopover extends LitElement implements Partial<AutocompletePopoverProps> {
+    /** @hidden */
+    static styles: CSSResultGroup;
+    /** @hidden */
+    private controller;
+    editor?: Editor;
+    regex?: RegExp;
+    popoverOptions: PopoverOptions;
+    context: AutocompletePopoverContext;
+    /** @hidden */
+    onSelect?: VoidFunction;
+    private get list();
+    private updateContext;
+    /** @hidden */
+    defaultSlot?: HTMLSlotElement;
+    /** @hidden */
+    protected get active(): boolean;
+    /** @hidden */
+    willUpdate(): void;
+    /** @hidden */
+    render(): TemplateResult<1>;
+}
+
+export declare type 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 addExtension;
+    hostDisconnected(): void;
+}
+
+export declare interface AutocompletePopoverProps {
+    editor: Editor;
+    regex: RegExp;
+    popoverOptions?: PopoverOptions;
+}
+
+export { AutoUpdateOptions }
+
+export declare const blockComponentStyles: CSSResult;
+
+declare class BlockElement extends LitElement {
+    setHidden(hidden: boolean): void;
+}
+
+export declare class CodeBlockPopover extends Popover implements Partial<CodeBlockPopoverProps> {
+    editor?: Editor;
+    /** @hidden */
+    private controller;
+    protected updated(): void;
+}
+
+export declare class CodeBlockPopoverController implements ReactiveController {
+    private host;
+    reference: Element | null;
+    private editor;
+    private cleanup;
+    constructor(host: ReactiveControllerHost);
+    setEditor(editor: Editor): void;
+    private addExtension;
+    hostDisconnected(): void;
+}
+
+export declare interface CodeBlockPopoverProps {
+    editor: Editor;
+}
+
+export declare class ComboBox extends Popover {
+    onDismiss?: VoidFunction;
+    private listManager;
+    context: ComboBoxContext;
+    get items(): ComboBoxItem[];
+}
+
+export declare type 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 LightBlockElement {
+    placeholder: string;
+    comboBoxContext: ComboBoxContext | null;
+    private visible;
+    private handleKeydown;
+    private handleInput;
+    protected firstUpdated(): void;
+    /** @hidden */
+    render(): TemplateResult<1>;
+}
+
+export declare type ComboBoxInputProps = {
+    placeholder?: string;
+};
+
+declare class ComboBoxItem extends LightBlockElement {
+    /** @hidden */
+    static styles: CSSResultGroup;
+    editor?: Editor;
+    /** @hidden */
+    defaultSlot?: HTMLSlotElement;
+    selected: boolean;
+    comboBoxContext?: ComboBoxContext;
+    /** @hidden */
+    onSelect?: VoidFunction;
+    protected updated(): void;
+}
+export { ComboBoxItem }
+export { ComboBoxItem as ComboBoxItem_alias_1 }
+
+declare type ComboBoxItemProps = Record<string, never>;
+export { ComboBoxItemProps }
+export { ComboBoxItemProps as ComboBoxItemProps_alias_1 }
+
+declare class ComboBoxList extends LightBlockElement {
+    comboBoxContext: ComboBoxContext | null;
+    connectedCallback(): void;
+}
+export { ComboBoxList }
+export { ComboBoxList as ComboBoxList_alias_1 }
+
+declare type ComboBoxListProps = Record<string, never>;
+export { ComboBoxListProps }
+export { ComboBoxListProps as ComboBoxListProps_alias_1 }
+
+export declare type ComboBoxProps = {
+    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;
+
+export declare const defaultPopoverOptions_alias_1: PopoverOptions;
+
+export declare function defaultQueryBuilder(match: RegExpExecArray): string;
+
+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 LightBlockElement extends BlockElement {
+    createRenderRoot(): this;
+}
+
+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 LightBlockElement implements Partial<PopoverProps> {
+    /** @hidden */
+    constructor();
+    /** @hidden */
+    static styles: CSSResultGroup;
+    /**
+     * 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;
+    /** @hidden */
+    private cleanupAutoUpdate?;
+    /** @hidden */
+    disconnectedCallback(): void;
+    /** @hidden */
+    protected updated(): void;
+    /** @hidden */
+    private start;
+    /** @hidden */
+    private compute;
+    /** @hidden */
+    private cleanup;
+}
+
+/**
+ * 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 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_10 }
+export { propNames_4 as propNames_alias_9 }
+
+declare const propNames_5: never[];
+export { propNames_5 as propNames_alias_11 }
+export { propNames_5 as propNames_alias_12 }
+
+export declare const propNames_alias_13: string[];
+
+export declare const propNames_alias_5: readonly ["editor", "regex", "popoverOptions"];
+
+export declare const propNames_alias_6: readonly ["editor"];
+
+export declare const propNames_alias_7: readonly ["onDismiss"];
+
+export declare const propNames_alias_8: 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 declare class ShadowBlockElement extends BlockElement {
+    /** @hidden */
+    static styles: CSSResultGroup;
+    setHidden(hidden: boolean): void;
+}
+
+export { }

package/dist/{chunk-J73E7P6J.js → chunk-3UDA5JEW.js}

@@ -18,16 +18,9 @@ import { css } from "lit";
 var componentStyles = css`:host{box-sizing:border-box}:host *,:host ::after,:host ::before{box-sizing:inherit}`;
 
 // src/styles/block-component.styles.ts
-var blockComponentStyles = css2`${componentStyles}:host{display:block}:host([hidden]){display:none}`;
-
-// src/components/autocomplete-list/context.ts
-import { createContext } from "@lit-labs/context";
-var commandListContext = createContext(
-  "prosekit-autocomplete-list-context"
-);
+var blockComponentStyles = css2`${componentStyles}:host{display:block;border-style:solid;border-width:0}:host([hidden]){display:none}`;
 
 export {
   __decorateClass,
-  blockComponentStyles,
-  commandListContext
+  blockComponentStyles
 };

package/dist/{chunk-37EPOFI5.js → chunk-AWQAU2JR.js}

@@ -1,8 +1,10 @@
 import {
-  __decorateClass,
-  blockComponentStyles,
   commandListContext
-} from "./chunk-J73E7P6J.js";
+} from "./chunk-DYEHERSG.js";
+import {
+  __decorateClass,
+  blockComponentStyles
+} from "./chunk-3UDA5JEW.js";
 
 // src/components/autocomplete-item/component.ts
 import { consume } from "@lit-labs/context";

package/dist/chunk-BMDOOASL.js

@@ -0,0 +1,57 @@
+import {
+  comboBoxContext
+} from "./chunk-HMV7TD6T.js";
+import {
+  LightBlockElement
+} from "./chunk-TRZW33VF.js";
+import {
+  __decorateClass,
+  blockComponentStyles
+} from "./chunk-3UDA5JEW.js";
+
+// src/components/combo-box-item/component.ts
+import { consume } from "@lit-labs/context";
+import "lit";
+import { customElement, property, query, state } from "lit/decorators.js";
+var propNames = [];
+var ComboBoxItem = class extends LightBlockElement {
+  constructor() {
+    super(...arguments);
+    this.selected = false;
+  }
+  updated() {
+    var _a, _b, _c, _d;
+    const content = ((_a = this.textContent) != null ? _a : "").trim();
+    const query2 = ((_c = (_b = this.comboBoxContext) == null ? void 0 : _b.inputValue) != null ? _c : "").trim();
+    const match = content.toLowerCase().includes(query2.toLowerCase());
+    this.selected = match && content === ((_d = this.comboBoxContext) == null ? void 0 : _d.selectedValue);
+    this.ariaSelected = String(this.selected);
+    this.setHidden(!match);
+  }
+};
+/** @hidden */
+ComboBoxItem.styles = blockComponentStyles;
+__decorateClass([
+  property({ attribute: false })
+], ComboBoxItem.prototype, "editor", 2);
+__decorateClass([
+  query("slot")
+], ComboBoxItem.prototype, "defaultSlot", 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-DYEHERSG.js

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

package/dist/chunk-G5KPDHDH.js

@@ -0,0 +1,120 @@
+import {
+  LightBlockElement
+} from "./chunk-TRZW33VF.js";
+import {
+  __decorateClass,
+  blockComponentStyles
+} from "./chunk-3UDA5JEW.js";
+
+// src/components/popover/options.ts
+import "@floating-ui/dom";
+
+// src/components/popover/index.ts
+import {
+  autoUpdate,
+  computePosition
+} from "@floating-ui/dom";
+import "lit";
+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 } from "@floating-ui/dom";
+var defaultPopoverOptions = {
+  placement: "bottom",
+  middleware: [offset(4), shift({ padding: 8 })]
+};
+
+// src/components/popover/index.ts
+var Popover = class extends LightBlockElement {
+  /** @hidden */
+  constructor() {
+    super();
+    this.active = false;
+    this.autoUpdate = false;
+  }
+  /** @hidden */
+  disconnectedCallback() {
+    this.cleanup();
+  }
+  /** @hidden */
+  updated() {
+    this.start();
+    this.setHidden(!this.active);
+  }
+  /** @hidden */
+  start() {
+    this.cleanup();
+    const reference = this.reference;
+    if (!reference)
+      return;
+    if (!this.active)
+      return;
+    if (this.autoUpdate) {
+      this.cleanupAutoUpdate = 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.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.top = "0";
+    this.style.left = "0";
+    this.style.position = strategy;
+    this.style.transform = `translate(${roundByDPR(x)}px,${roundByDPR(y)}px)`;
+  }
+  /** @hidden */
+  cleanup() {
+    var _a;
+    (_a = this.cleanupAutoUpdate) == null ? void 0 : _a.call(this);
+    this.cleanupAutoUpdate = void 0;
+  }
+};
+/** @hidden */
+Popover.styles = blockComponentStyles;
+__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);
+Popover = __decorateClass([
+  customElement("prosekit-popover")
+], Popover);
+
+export {
+  Popover
+};

package/dist/chunk-HMV7TD6T.js

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