@qalma/kit 0.1.0-beta.0

package/types/qalma-kit.d.ts

@@ -0,0 +1,530 @@
+import { ClassValue } from 'clsx';
+import * as _angular_core from '@angular/core';
+import { TemplateRef, DestroyRef, ElementRef, Signal } from '@angular/core';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import { DragHandleMoveCommandValue, DragHandleCommandValue, QalmaEditorController, QalmaCommandValue } from '@qalma/editor';
+import * as _qalma_kit from '@qalma/kit';
+
+declare function cn(...inputs: ClassValue[]): string;
+
+declare const buttonVariants: (props?: ({
+    variant?: "default" | "secondary" | "outline" | "ghost" | "accent" | "link" | null | undefined;
+    size?: "default" | "sm" | "lg" | "icon" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ButtonVariant = NonNullable<VariantProps<typeof buttonVariants>['variant']>;
+type ButtonSize = NonNullable<VariantProps<typeof buttonVariants>['size']>;
+/**
+ * Headless-styled button directive so it composes onto native `<button>` and
+ * `<a>` elements while reading from the host's Tailwind design tokens.
+ */
+declare class QalmaButton {
+    private readonly host;
+    private readonly initialClass;
+    readonly variant: _angular_core.InputSignal<ButtonVariant>;
+    readonly size: _angular_core.InputSignal<ButtonSize>;
+    protected readonly computedClass: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<QalmaButton, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<QalmaButton, "button[qalmaBtn], a[qalmaBtn]", never, { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Default styling for a toolbar command button. Icon-only, square, and driven
+ * entirely by the host's shadcn-style design tokens (`text-muted-foreground`,
+ * `bg-secondary`, `bg-accent-subtle`…) so it themes with the surrounding app.
+ * The `qalma-command-active` class is toggled by the `QalmaCommand` directive
+ * when the underlying command is active.
+ */
+declare const TOOLBAR_BUTTON_CLASS = "inline-flex h-[1.85rem] w-[1.85rem] cursor-pointer items-center justify-center rounded-[0.4rem] border border-transparent text-muted-foreground transition hover:bg-secondary hover:text-foreground disabled:cursor-not-allowed disabled:opacity-45 [&.qalma-command-active]:border-accent/40 [&.qalma-command-active]:bg-accent-subtle [&.qalma-command-active]:text-accent";
+/**
+ * Generic, declarative toolbar button for a single editor command.
+ *
+ * Renders a native `<button>` wired to the `QalmaCommand` directive (execute /
+ * active / disabled / aria) with an `<ng-icon>`, so a whole toolbar becomes a
+ * list of `<qalma-toolbar-button command icon label />` instead of the
+ * six-line `<button qalmaCommand><ng-icon></button>` block repeated per
+ * command. The host uses `display: contents` so the inner button participates
+ * directly in the surrounding toolbar's flex layout.
+ *
+ * Icons resolve from the `NgIcon` provider scope of the surrounding component
+ * (register them with `provideIcons({ … })` as usual).
+ */
+declare class QalmaToolbarButton {
+    /** Command name to execute, e.g. `toggleBold`. */
+    readonly command: _angular_core.InputSignal<string>;
+    /** Optional command payload (forwarded to `qalmaCommandValue`). */
+    readonly value: _angular_core.InputSignal<unknown>;
+    /** Lucide (or any registered) icon name, e.g. `lucideBold`. */
+    readonly icon: _angular_core.InputSignal<string>;
+    /** Accessible name — used for both `title` and `aria-label`. */
+    readonly label: _angular_core.InputSignal<string>;
+    /** Optional icon-size class override (default: `text-[0.9rem]`). */
+    readonly iconClass: _angular_core.InputSignal<string>;
+    protected readonly buttonClass = "inline-flex h-[1.85rem] w-[1.85rem] cursor-pointer items-center justify-center rounded-[0.4rem] border border-transparent text-muted-foreground transition hover:bg-secondary hover:text-foreground disabled:cursor-not-allowed disabled:opacity-45 [&.qalma-command-active]:border-accent/40 [&.qalma-command-active]:bg-accent-subtle [&.qalma-command-active]:text-accent";
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<QalmaToolbarButton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<QalmaToolbarButton, "qalma-toolbar-button", never, { "command": { "alias": "command"; "required": true; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "icon": { "alias": "icon"; "required": true; "isSignal": true; }; "label": { "alias": "label"; "required": true; "isSignal": true; }; "iconClass": { "alias": "iconClass"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * A single command button in a toolbar registry: which editor command to run,
+ * which icon to show, and its accessible label. `value` is forwarded to the
+ * command as its payload when present.
+ */
+interface ToolbarCommandItem {
+    readonly command: string;
+    readonly icon: string;
+    readonly label: string;
+    readonly value?: unknown;
+}
+/**
+ * An escape hatch for controls that are not a plain command button (color
+ * pickers, upload buttons, a language `<select>`…). The consumer supplies an
+ * `<ng-template>` and the toolbar renders it inline at this position.
+ */
+interface ToolbarTemplateItem {
+    readonly template: TemplateRef<unknown>;
+}
+type ToolbarItem = ToolbarCommandItem | ToolbarTemplateItem;
+/** One separator-delimited run of items. Empty groups render nothing. */
+type ToolbarGroup = readonly ToolbarItem[];
+declare function isToolbarCommandItem(item: ToolbarItem): item is ToolbarCommandItem;
+declare const QALMA_TOOLBAR_HEADINGS: readonly ToolbarCommandItem[];
+declare const QALMA_TOOLBAR_INLINE_MARKS: readonly ToolbarCommandItem[];
+declare const QALMA_TOOLBAR_ALIGN: readonly ToolbarCommandItem[];
+declare const QALMA_TOOLBAR_LISTS: readonly ToolbarCommandItem[];
+/** Always-available table entry point (inserting a new table). */
+declare const QALMA_TOOLBAR_TABLE_INSERT: ToolbarCommandItem;
+/** Table editing commands — only meaningful while the selection is in a table. */
+declare const QALMA_TOOLBAR_TABLE_OPS: readonly ToolbarCommandItem[];
+declare const QALMA_TOOLBAR_HISTORY: readonly ToolbarCommandItem[];
+/** Standalone command that usually sits alongside the color controls. */
+declare const QALMA_TOOLBAR_CLEAR_FORMATTING: ToolbarCommandItem;
+/** Standalone command that usually sits alongside the link/insert controls. */
+declare const QALMA_TOOLBAR_UNSET_LINK: ToolbarCommandItem;
+
+/** Vertical divider rendered between non-empty toolbar groups. */
+declare const TOOLBAR_SEPARATOR_CLASS = "mx-0.5 h-5 w-px shrink-0 self-center bg-border";
+/**
+ * Renders a declarative toolbar registry: an ordered list of groups, each a
+ * list of command buttons and/or inline custom-control templates, with a
+ * separator drawn between non-empty groups.
+ *
+ * Meant to sit inside the editor's `<qalma-toolbar>` (which owns the
+ * `role="toolbar"` semantics); the host uses `display: contents` so the
+ * rendered buttons participate directly in that container's flex layout.
+ *
+ * ```html
+ * <qalma-toolbar class="flex …">
+ *   <ng-template #colors> … custom controls … </ng-template>
+ *   <qalma-toolbar-registry [groups]="[headings, marks, [{ template: colors }]]" />
+ * </qalma-toolbar>
+ * ```
+ */
+declare class QalmaToolbarRegistry {
+    readonly groups: _angular_core.InputSignal<readonly ToolbarGroup[]>;
+    readonly separatorClass: _angular_core.InputSignal<string>;
+    /** Drop empty groups so they neither render content nor a dangling separator. */
+    protected readonly visibleGroups: _angular_core.Signal<ToolbarGroup[]>;
+    protected asCommand(item: ToolbarItem): ToolbarCommandItem | null;
+    protected asTemplate(item: ToolbarItem): TemplateRef<unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<QalmaToolbarRegistry, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<QalmaToolbarRegistry, "qalma-toolbar-registry", never, { "groups": { "alias": "groups"; "required": true; "isSignal": true; }; "separatorClass": { "alias": "separatorClass"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Registers the Lucide icons referenced by the default toolbar command
+ * fragments (`QALMA_TOOLBAR_*`), so consumers can wire the standard toolbar
+ * without re-declaring the icon set:
+ *
+ * ```ts
+ * providers: [provideQalmaToolbarIcons()]
+ * ```
+ *
+ * Add your own `provideIcons({ … })` alongside it for any custom controls
+ * (color pickers, upload buttons…) that live outside the command registry.
+ */
+declare function provideQalmaToolbarIcons(): _angular_core.Provider[];
+
+interface AnchorRect {
+    readonly top: number;
+    readonly bottom: number;
+    readonly left: number;
+    readonly right: number;
+}
+interface AnchorSize {
+    readonly width: number;
+    readonly height: number;
+}
+type AnchorPlacement = 'top' | 'bottom' | 'left' | 'right';
+type AnchorAlign = 'start' | 'center' | 'end';
+interface AnchorToRectOptions {
+    /** Which side of the anchor rect the floating element renders on. */
+    readonly placement: AnchorPlacement;
+    /** Rect (viewport or scroll surface) the result is clamped within. */
+    readonly boundary: AnchorRect;
+    /** Size of the floating element being positioned. */
+    readonly size: AnchorSize;
+    /** Distance between the anchor rect and the floating element. Default 8. */
+    readonly gap?: number;
+    /** Minimum distance kept from the boundary edges. Default 8. */
+    readonly edgeMargin?: number;
+    /**
+     * Cross-axis alignment relative to the anchor rect. `start` | `center` |
+     * `end` align to the anchor rect itself; a number instead pins the
+     * floating element's center to that viewport coordinate (clamped within
+     * the anchor rect), e.g. to follow a pointer's Y while hovering a tall
+     * block. Defaults to `start`.
+     */
+    readonly align?: AnchorAlign | number;
+}
+interface AnchorPosition {
+    readonly top: number;
+    readonly left: number;
+}
+declare function anchorToRect(anchor: AnchorRect, options: AnchorToRectOptions): AnchorPosition;
+
+interface DismissibleOverlayOptions {
+    /** Returns true when the event target is part of the overlay/trigger and should not dismiss it. */
+    isInside: (target: EventTarget | null) => boolean;
+    onDismiss: () => void;
+}
+/**
+ * Shared outside-click / Escape dismiss behavior for floating overlays
+ * (popovers, contextual menus, autocomplete lists). Generalizes the
+ * ad-hoc click-outside/Escape handling that used to be reimplemented
+ * separately per feature.
+ */
+declare class DismissibleOverlay {
+    private readonly options;
+    private readonly pointerDown;
+    private readonly keydown;
+    constructor(options: DismissibleOverlayOptions);
+    connect(destroyRef: DestroyRef): void;
+}
+
+interface KeyboardNavigableListOptions<T> {
+    items: () => readonly T[];
+    activeIndex: () => number;
+    setActiveIndex: (index: number) => void;
+    onSelect: (item: T, index: number) => void;
+}
+/**
+ * Arrow-key navigation + Enter-to-select for autocomplete-style popovers
+ * (mention menu, slash command menu). Shared so both features stop
+ * reimplementing the same wrap-around index math.
+ *
+ * Takes a plain key string rather than a `KeyboardEvent` — some callers
+ * relay keys through a `CustomEvent` (no real `KeyboardEvent` to read),
+ * so preventing the default action is left to the caller.
+ */
+declare class KeyboardNavigableList<T> {
+    private readonly options;
+    constructor(options: KeyboardNavigableListOptions<T>);
+    /** Returns true when the key was handled (caller should stop further propagation / preventDefault). */
+    handleKey(key: string): boolean;
+}
+
+interface QalmaDragHandleView {
+    target: DragHandleCommandValue;
+    transform: string;
+    blockType: string;
+    canMoveUp: boolean;
+    canMoveDown: boolean;
+}
+interface QalmaDragDropIndicator {
+    target: DragHandleMoveCommandValue;
+    transform: string;
+    width: number;
+}
+interface QalmaDragBlockHighlight {
+    transform: string;
+    width: number;
+    height: number;
+}
+declare class QalmaDragHandleController {
+    private readonly editor;
+    private readonly handleState;
+    private readonly dropIndicatorState;
+    private readonly draggedBlockHighlightState;
+    readonly handle: _angular_core.Signal<QalmaDragHandleView | null>;
+    readonly dropIndicator: _angular_core.Signal<QalmaDragDropIndicator | null>;
+    readonly draggedBlockHighlight: _angular_core.Signal<QalmaDragBlockHighlight | null>;
+    private surface;
+    private currentBlock;
+    private pendingBlock;
+    private lastPointerClientY;
+    private refreshFrame;
+    private handleKey;
+    private dragSession;
+    constructor(editor: () => QalmaEditorController);
+    connect(surface: HTMLElement, destroyRef: DestroyRef): void;
+    hide(): void;
+    startDrag(event: PointerEvent, handle: QalmaDragHandleView): void;
+    private handlePointerMove;
+    private handlePointerLeave;
+    private handleDragPointerMove;
+    private handleDragPointerUp;
+    private activateDragSession;
+    private updateDropIndicator;
+    private updateDraggedBlockHighlight;
+    private finishDrag;
+    private scheduleRefresh;
+    private refresh;
+    private updateFromBlock;
+    private cancelScheduledRefresh;
+    private setHandle;
+    private setDropIndicator;
+}
+
+declare class QalmaDragHandleDirective {
+    readonly editor: _angular_core.InputSignal<QalmaEditorController>;
+    private readonly destroyRef;
+    private readonly host;
+    private readonly controller;
+    readonly handle: _angular_core.Signal<QalmaDragHandleView | null>;
+    readonly dropIndicator: _angular_core.Signal<_qalma_kit.QalmaDragDropIndicator | null>;
+    readonly draggedBlockHighlight: _angular_core.Signal<_qalma_kit.QalmaDragBlockHighlight | null>;
+    constructor();
+    hide(): void;
+    startDrag(event: PointerEvent, handle: QalmaDragHandleView): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<QalmaDragHandleDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<QalmaDragHandleDirective, "[qalmaDragHandle]", ["qalmaDragHandle"], { "editor": { "alias": "qalmaDragHandle"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface QalmaDragStart {
+    event: PointerEvent;
+    handle: QalmaDragHandleView;
+}
+declare class QalmaDragHandle {
+    readonly editor: _angular_core.InputSignal<QalmaEditorController>;
+    readonly handle: _angular_core.InputSignal<QalmaDragHandleView | null>;
+    readonly dropIndicator: _angular_core.InputSignal<QalmaDragDropIndicator | null>;
+    readonly draggedBlockHighlight: _angular_core.InputSignal<QalmaDragBlockHighlight | null>;
+    readonly dismiss: _angular_core.OutputEmitterRef<void>;
+    readonly dragStart: _angular_core.OutputEmitterRef<QalmaDragStart>;
+    protected readonly menuOpen: _angular_core.WritableSignal<boolean>;
+    constructor();
+    protected toggleMenu(): void;
+    protected startDrag(event: PointerEvent, handle: QalmaDragHandleView): void;
+    protected canExecute(command: string, handle: QalmaDragHandleView): boolean;
+    protected execute(command: string, handle: QalmaDragHandleView): void;
+    protected preserveSelection(event: MouseEvent): void;
+    protected dismissFromKeyboard(event: Event): void;
+    protected dismissHandle(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<QalmaDragHandle, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<QalmaDragHandle, "qalma-drag-handle", never, { "editor": { "alias": "editor"; "required": true; "isSignal": true; }; "handle": { "alias": "handle"; "required": false; "isSignal": true; }; "dropIndicator": { "alias": "dropIndicator"; "required": false; "isSignal": true; }; "draggedBlockHighlight": { "alias": "draggedBlockHighlight"; "required": false; "isSignal": true; }; }, { "dismiss": "dismiss"; "dragStart": "dragStart"; }, never, never, true, never>;
+}
+
+/**
+ * Fixed-position coordinates for a suggestion menu anchored to a caret/range
+ * rect. Exactly one of `top`/`bottom` is a number (the other is `null`): the
+ * menu is pinned below the anchor by `top`, or above it by `bottom`.
+ */
+interface SuggestionMenuPlacement {
+    readonly left: number;
+    readonly top: number | null;
+    readonly bottom: number | null;
+    readonly maxHeight: number;
+}
+interface FlipAbovePlacementOptions {
+    /** Menu width, used to clamp `left` within the viewport. */
+    readonly width: number;
+    /** Ideal menu height for the current option count. */
+    readonly desiredHeight: number;
+    /** Floor for the computed `maxHeight` (e.g. one option / a loading row). */
+    readonly minHeight: number;
+    /** Viewport edge margin (default 12). */
+    readonly margin?: number;
+    /** Gap between the anchor and the menu (default 8). */
+    readonly gap?: number;
+}
+/**
+ * Positions a floating list under an anchor rect, flipping it above when there
+ * is not enough room below, and clamping its height and horizontal position to
+ * the viewport. Shared by the mention and slash-command menus, whose flip
+ * behavior `anchorToRect` does not cover (it has no flip / dynamic max-height).
+ */
+declare function flipAbovePlacement(rect: {
+    readonly top: number;
+    readonly bottom: number;
+    readonly left: number;
+}, options: FlipAbovePlacementOptions): SuggestionMenuPlacement;
+
+/** Option buttons carry this attribute so the base can focus/scroll to one by index. */
+declare const SUGGESTION_OPTION_INDEX_ATTR = "data-suggestion-index";
+/** The scrollable options container carries this attribute (optional). */
+declare const SUGGESTION_OPTIONS_SCROLLER_ATTR = "data-suggestion-options";
+/**
+ * Shared behavior for caret-anchored suggestion menus (mention, slash command):
+ * flip-above placement input, active-option highlighting, and in-menu keyboard
+ * handling (Escape dismisses, Arrow moves + focuses, Enter/Space picks) with
+ * wrap-around and optional scroll-into-view. Concrete menus only supply their
+ * own item markup and expose their option list via `optionList`.
+ */
+declare abstract class QalmaSuggestionMenu<TOption extends {
+    readonly id: string;
+}> {
+    protected readonly elementRef: ElementRef<HTMLElement>;
+    readonly placement: _angular_core.InputSignal<SuggestionMenuPlacement | null>;
+    readonly activeIndex: _angular_core.InputSignal<number>;
+    readonly activate: _angular_core.OutputEmitterRef<number>;
+    readonly pick: _angular_core.OutputEmitterRef<TOption>;
+    readonly dismiss: _angular_core.OutputEmitterRef<void>;
+    /** The rendered options, bound by the concrete menu (`options`/`suggestions`). */
+    protected abstract readonly optionList: Signal<readonly TOption[]>;
+    protected preserveSelection(event: MouseEvent): void;
+    protected handleOptionKeydown(event: KeyboardEvent, option: TOption, index: number): void;
+    protected focusOption(index: number): void;
+    protected scrollOptionIntoView(index: number): void;
+    private getNextIndex;
+    private optionElement;
+    private optionsScroller;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<QalmaSuggestionMenu<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<QalmaSuggestionMenu<any>, never, never, { "placement": { "alias": "placement"; "required": false; "isSignal": true; }; "activeIndex": { "alias": "activeIndex"; "required": false; "isSignal": true; }; }, { "activate": "activate"; "pick": "pick"; "dismiss": "dismiss"; }, never, never, true, never>;
+}
+
+interface QalmaMentionOption {
+    readonly id: string;
+    readonly label: string;
+    readonly description: string;
+}
+/**
+ * Caret-anchored mention suggestion menu: an avatar-initial list with a loading
+ * state. Positioning, keyboard handling and active highlighting come from
+ * {@link QalmaSuggestionMenu}; feed it a `placement` (see `flipAbovePlacement`)
+ * and the filtered `suggestions`.
+ */
+declare class QalmaMentionMenu extends QalmaSuggestionMenu<QalmaMentionOption> {
+    readonly suggestions: _angular_core.InputSignal<readonly QalmaMentionOption[]>;
+    readonly loading: _angular_core.InputSignal<boolean>;
+    protected readonly optionList: _angular_core.InputSignal<readonly QalmaMentionOption[]>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<QalmaMentionMenu, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<QalmaMentionMenu, "qalma-mention-menu", never, { "suggestions": { "alias": "suggestions"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface QalmaSlashCommandOption {
+    readonly id: string;
+    readonly label: string;
+    readonly description: string;
+    readonly icon: string;
+    readonly shortcut: string;
+    /** Editor command to run when the option is picked. */
+    readonly command: string;
+    readonly value?: QalmaCommandValue;
+    readonly placement?: 'block' | 'inline';
+    /** Extra terms the consumer can match against when filtering. */
+    readonly keywords: readonly string[];
+}
+/**
+ * Caret-anchored slash-command menu: an icon + shortcut list with a "Commands"
+ * header and an Escape hint footer, scrolling the active option into view.
+ * Positioning, keyboard handling and active highlighting come from
+ * {@link QalmaSuggestionMenu}; feed it a `placement` (see `flipAbovePlacement`)
+ * and the filtered `options`. Ships the default block-command icon set.
+ */
+declare class QalmaSlashCommandMenu extends QalmaSuggestionMenu<QalmaSlashCommandOption> {
+    readonly options: _angular_core.InputSignal<readonly QalmaSlashCommandOption[]>;
+    protected readonly optionList: _angular_core.InputSignal<readonly QalmaSlashCommandOption[]>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<QalmaSlashCommandMenu, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<QalmaSlashCommandMenu, "qalma-slash-command-menu", never, { "options": { "alias": "options"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+interface LinkPopover extends LinkPopoverPlacement {
+    editing: boolean;
+    element: HTMLAnchorElement | null;
+    href: string;
+    rel: string | null;
+    target: '_blank' | null;
+    text: string;
+}
+interface LinkPopoverPlacement {
+    left: number;
+    top: number;
+}
+declare function createLinkPopoverPlacement(element: HTMLElement): LinkPopoverPlacement;
+declare function findEditorLinkElement(target: EventTarget | null): HTMLAnchorElement | null;
+
+declare class LinkPopoverController {
+    private readonly editor;
+    readonly popover: _angular_core.WritableSignal<LinkPopover | null>;
+    readonly href: _angular_core.WritableSignal<string>;
+    private hideTimeout;
+    constructor(editor: QalmaEditorController);
+    showToolbarEditor(event: MouseEvent): void;
+    showPreview(event: Event): void;
+    scheduleHideFromEvent(event: MouseEvent | FocusEvent): void;
+    edit(popover: LinkPopover): void;
+    save(popover: LinkPopover): void;
+    remove(popover: LinkPopover): void;
+    hide(): void;
+    keepOpen(): void;
+    scheduleHide(): void;
+    private selectLink;
+    private clearHideTimeout;
+}
+
+declare class QalmaLinkPopover {
+    readonly popover: _angular_core.InputSignal<LinkPopover | null>;
+    readonly href: _angular_core.InputSignal<string>;
+    readonly hrefChange: _angular_core.OutputEmitterRef<string>;
+    readonly edit: _angular_core.OutputEmitterRef<LinkPopover>;
+    readonly save: _angular_core.OutputEmitterRef<LinkPopover>;
+    readonly remove: _angular_core.OutputEmitterRef<LinkPopover>;
+    readonly dismiss: _angular_core.OutputEmitterRef<void>;
+    readonly keepOpen: _angular_core.OutputEmitterRef<void>;
+    readonly scheduleHide: _angular_core.OutputEmitterRef<void>;
+    protected updateHref(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<QalmaLinkPopover, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<QalmaLinkPopover, "qalma-link-popover", never, { "popover": { "alias": "popover"; "required": false; "isSignal": true; }; "href": { "alias": "href"; "required": true; "isSignal": true; }; }, { "hrefChange": "hrefChange"; "edit": "edit"; "save": "save"; "remove": "remove"; "dismiss": "dismiss"; "keepOpen": "keepOpen"; "scheduleHide": "scheduleHide"; }, never, never, true, never>;
+}
+
+interface QalmaContextualToolbarPlacement {
+    transform: string;
+}
+declare class QalmaContextualToolbar {
+    readonly editor: _angular_core.InputSignal<QalmaEditorController>;
+    readonly placement: _angular_core.InputSignal<QalmaContextualToolbarPlacement | null>;
+    readonly requestLink: _angular_core.OutputEmitterRef<MouseEvent>;
+    readonly dismiss: _angular_core.OutputEmitterRef<void>;
+    protected readonly canSetLink: _angular_core.Signal<boolean>;
+    protected readonly linkActive: _angular_core.Signal<boolean>;
+    protected preserveSelection(event: MouseEvent): void;
+    protected dismissFromKeyboard(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<QalmaContextualToolbar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<QalmaContextualToolbar, "qalma-contextual-toolbar", never, { "editor": { "alias": "editor"; "required": true; "isSignal": true; }; "placement": { "alias": "placement"; "required": false; "isSignal": true; }; }, { "requestLink": "requestLink"; "dismiss": "dismiss"; }, never, never, true, never>;
+}
+
+declare class QalmaSelectionToolbarController {
+    private readonly editor;
+    private readonly placementState;
+    readonly placement: _angular_core.Signal<QalmaContextualToolbarPlacement | null>;
+    private surface;
+    private refreshFrame;
+    private placementKey;
+    constructor(editor: () => QalmaEditorController);
+    connect(surface: HTMLElement, destroyRef: DestroyRef): void;
+    refresh(): void;
+    hide(): void;
+    handleKeydown(event: Event): void;
+    private scheduleRefresh;
+    private cancelScheduledRefresh;
+    private setPlacement;
+}
+
+declare class QalmaSelectionToolbarDirective {
+    readonly editor: _angular_core.InputSignal<QalmaEditorController>;
+    private readonly destroyRef;
+    private readonly host;
+    private readonly controller;
+    readonly placement: _angular_core.Signal<_qalma_kit.QalmaContextualToolbarPlacement | null>;
+    constructor();
+    refresh(): void;
+    hide(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<QalmaSelectionToolbarDirective, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<QalmaSelectionToolbarDirective, "[qalmaSelectionToolbar]", ["qalmaSelectionToolbar"], { "editor": { "alias": "qalmaSelectionToolbar"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { DismissibleOverlay, KeyboardNavigableList, LinkPopoverController, QALMA_TOOLBAR_ALIGN, QALMA_TOOLBAR_CLEAR_FORMATTING, QALMA_TOOLBAR_HEADINGS, QALMA_TOOLBAR_HISTORY, QALMA_TOOLBAR_INLINE_MARKS, QALMA_TOOLBAR_LISTS, QALMA_TOOLBAR_TABLE_INSERT, QALMA_TOOLBAR_TABLE_OPS, QALMA_TOOLBAR_UNSET_LINK, QalmaButton, QalmaContextualToolbar, QalmaDragHandle, QalmaDragHandleController, QalmaDragHandleDirective, QalmaLinkPopover, QalmaMentionMenu, QalmaSelectionToolbarController, QalmaSelectionToolbarDirective, QalmaSlashCommandMenu, QalmaSuggestionMenu, QalmaToolbarButton, QalmaToolbarRegistry, SUGGESTION_OPTIONS_SCROLLER_ATTR, SUGGESTION_OPTION_INDEX_ATTR, TOOLBAR_BUTTON_CLASS, TOOLBAR_SEPARATOR_CLASS, anchorToRect, buttonVariants, cn, createLinkPopoverPlacement, findEditorLinkElement, flipAbovePlacement, isToolbarCommandItem, provideQalmaToolbarIcons };
+export type { AnchorAlign, AnchorPlacement, AnchorPosition, AnchorRect, AnchorSize, AnchorToRectOptions, ButtonSize, ButtonVariant, DismissibleOverlayOptions, FlipAbovePlacementOptions, KeyboardNavigableListOptions, LinkPopover, LinkPopoverPlacement, QalmaContextualToolbarPlacement, QalmaDragBlockHighlight, QalmaDragDropIndicator, QalmaDragHandleView, QalmaDragStart, QalmaMentionOption, QalmaSlashCommandOption, SuggestionMenuPlacement, ToolbarCommandItem, ToolbarGroup, ToolbarItem, ToolbarTemplateItem };
+//# sourceMappingURL=qalma-kit.d.ts.map

package/types/qalma-kit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"qalma-kit.d.ts","sources":["../../../../libs/ui-kit/src/lib/cn.ts","../../../../libs/ui-kit/src/lib/button.ts","../../../../libs/ui-kit/src/lib/toolbar-button.ts","../../../../libs/ui-kit/src/lib/toolbar-commands.ts","../../../../libs/ui-kit/src/lib/toolbar-registry.ts","../../../../libs/ui-kit/src/lib/toolbar-icons.ts","../../../../libs/ui-kit/src/lib/anchor-to-rect.ts","../../../../libs/ui-kit/src/lib/dismissible-overlay.ts","../../../../libs/ui-kit/src/lib/keyboard-navigable-list.ts","../../../../libs/ui-kit/src/lib/drag-handle-controller.ts","../../../../libs/ui-kit/src/lib/drag-handle-directive.ts","../../../../libs/ui-kit/src/lib/drag-handle.ts","../../../../libs/ui-kit/src/lib/flip-above-placement.ts","../../../../libs/ui-kit/src/lib/suggestion-menu-base.ts","../../../../libs/ui-kit/src/lib/mention-menu.ts","../../../../libs/ui-kit/src/lib/slash-command-menu.ts","../../../../libs/ui-kit/src/lib/link-popover.model.ts","../../../../libs/ui-kit/src/lib/link-popover-controller.ts","../../../../libs/ui-kit/src/lib/link-popover.ts","../../../../libs/ui-kit/src/lib/contextual-toolbar.ts","../../../../libs/ui-kit/src/lib/selection-toolbar-controller.ts","../../../../libs/ui-kit/src/lib/selection-toolbar-directive.ts"],"mappings":"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","names":[]}