@slotted/angular 0.0.0-stage → 0.1.0-beta.1

package/types/slotted-angular-command-palette.d.ts

@@ -0,0 +1,256 @@
+import * as _slotted_core_commands from '@slotted/core/commands';
+import { CommandItem, CommandGroup, CommandRanker } from '@slotted/core/commands';
+export { CommandGroup, CommandRanker } from '@slotted/core/commands';
+import * as _slotted_core_i18n from '@slotted/core/i18n';
+import { PartialMessages, CommandPaletteMessages } from '@slotted/core/i18n';
+import * as _angular_core from '@angular/core';
+import { InjectionToken, TemplateRef, Provider } from '@angular/core';
+import { DialogDismissPolicy, SlDialog, DialogChangeRequest } from '@slotted/angular/dialog';
+import { ChangeRequest } from '@slotted/core/state';
+
+/**
+ * Where the panel stands. `dialog` composes the dialog family; `inline` draws
+ * the panel where it was written — the filtered menu `menu` refused.
+ */
+type CommandPalettePresentation = 'dialog' | 'inline';
+type CommandPaletteSize = 'sm' | 'md' | 'lg';
+type CommandPaletteOpenReason = 'pointer' | 'keyboard' | 'escape' | 'outsidePress' | 'select' | 'dismiss' | 'programmatic';
+type CommandPaletteQueryReason = 'keyboard' | 'clear' | 'select' | 'programmatic';
+type CommandPaletteHighlightReason = 'pointer' | 'keyboard' | 'programmatic';
+type CommandPalettePagesReason = 'select' | 'keyboard' | 'pointer' | 'programmatic';
+type CommandPaletteSelectReason = 'pointer' | 'keyboard';
+/**
+ * What an executed item is handed. `keepOpen()` holds the palette open after
+ * the handler returns.
+ */
+interface CommandPaletteSelectRequest<Item extends CommandPaletteItem = CommandPaletteItem> {
+    readonly item: Item;
+    readonly reason: CommandPaletteSelectReason;
+    readonly source: Event | undefined;
+    keepOpen: () => void;
+}
+/**
+ * One command. `id`, `label` and `keywords` are what the ranker reads; the rest
+ * is what the row draws. `children` opens a page; `href` is a destination.
+ * The mark in the first column comes from the item template, which is where
+ * an Angular consumer writes an icon.
+ */
+interface CommandPaletteItem extends CommandItem {
+    readonly meta?: string | undefined;
+    /** In the library's notation, `mod+shift+p`; drawn by `kbd` and announced. */
+    readonly shortcut?: string | undefined;
+    readonly href?: string | undefined;
+    readonly target?: string | undefined;
+    /** Runs before the root's `select` output. A promise keeps the palette open. */
+    readonly onSelect?: ((request: CommandPaletteSelectRequest) => void | Promise<unknown>) | undefined;
+    readonly children?: readonly CommandPaletteItem[] | undefined;
+}
+/** What the item template receives. */
+interface CommandPaletteItemContext<Item extends CommandPaletteItem = CommandPaletteItem> {
+    $implicit: Item;
+    current: boolean;
+    disabled: boolean;
+    pending: boolean;
+    query: string;
+    /** The label's runs, marked where the query matched. */
+    runs: readonly {
+        text: string;
+        matched: boolean;
+    }[];
+}
+type CommandPaletteItemTemplate<Item extends CommandPaletteItem = CommandPaletteItem> = TemplateRef<CommandPaletteItemContext<Item>>;
+interface CommandPaletteDefaults {
+    presentation: CommandPalettePresentation;
+    size: CommandPaletteSize;
+    outsidePress: DialogDismissPolicy;
+    loop: boolean;
+    autoHighlight: boolean;
+    closeOnSelect: boolean;
+    clearOnClose: boolean;
+    highlightMatch: boolean;
+    /** The chord that opens the palette anywhere in the document; `null` for none. */
+    hotkey: string | null;
+    recentLimit: number;
+}
+/**
+ * The numbers, and why they are these numbers: the React binding's
+ * `COMMAND_PALETTE_FALLBACK` records them, and the two lists are one list.
+ */
+declare const COMMAND_PALETTE_FALLBACK: CommandPaletteDefaults;
+declare const COMMAND_PALETTE_DEFAULTS: InjectionToken<CommandPaletteDefaults>;
+/**
+ * The decisions an application takes once. The sentences the family speaks
+ * come from the language in force (`provideSlotted`).
+ */
+declare function provideCommandPaletteDefaults(defaults: Partial<CommandPaletteDefaults>): Provider;
+declare function injectCommandPaletteDefaults(): CommandPaletteDefaults;
+
+/** The content of a row, written by the consumer on an `ng-template`. */
+declare class SlCommandPaletteItem<Item extends CommandPaletteItem = CommandPaletteItem> {
+    readonly template: TemplateRef<CommandPaletteItemContext<Item>>;
+    static ngTemplateContextGuard<Item extends CommandPaletteItem>(_directive: SlCommandPaletteItem<Item>, context: unknown): context is CommandPaletteItemContext<Item>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlCommandPaletteItem<any>, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlCommandPaletteItem<any>, "ng-template[slCommandPaletteItem]", never, {}, {}, never, never, true, never>;
+}
+/** The footer's content, in place of the family's hints. */
+declare class SlCommandPaletteFooter {
+    readonly template: TemplateRef<unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlCommandPaletteFooter, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlCommandPaletteFooter, "ng-template[slCommandPaletteFooter]", never, {}, {}, never, never, true, never>;
+}
+/** The empty message, in place of the catalog's `empty`. */
+declare class SlCommandPaletteEmpty {
+    readonly template: TemplateRef<unknown>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlCommandPaletteEmpty, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlCommandPaletteEmpty, "ng-template[slCommandPaletteEmpty]", never, {}, {}, never, never, true, never>;
+}
+declare class SlCommandPalette<Item extends CommandPaletteItem = CommandPaletteItem> {
+    private static flag;
+    private static count;
+    private readonly defaults;
+    private readonly platformOf;
+    private readonly document;
+    private readonly destroyRef;
+    private readonly host;
+    protected readonly baseId: string;
+    protected readonly inputId: string;
+    protected readonly listId: string;
+    readonly items: _angular_core.InputSignal<readonly Item[]>;
+    readonly groups: _angular_core.InputSignal<readonly CommandGroup[] | undefined>;
+    /** The adapter. Absent takes the core ranker; `null` shows the items as they came. */
+    readonly rank: _angular_core.InputSignal<CommandRanker<Item> | null | undefined>;
+    /** BCP 47, for the comparison the default ranker makes. Defaults to the language in force. */
+    readonly locale: _angular_core.InputSignal<string | undefined>;
+    readonly limit: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    readonly presentation: _angular_core.InputSignal<CommandPalettePresentation | undefined>;
+    readonly size: _angular_core.InputSignal<CommandPaletteSize | undefined>;
+    readonly outsidePress: _angular_core.InputSignal<DialogDismissPolicy | undefined>;
+    readonly loop: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
+    readonly autoHighlight: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
+    readonly closeOnSelect: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
+    readonly clearOnClose: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
+    readonly highlightMatch: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
+    /** `null` turns the hotkey off; absent takes the provider's. */
+    readonly hotkey: _angular_core.InputSignal<string | null | undefined>;
+    readonly recentLimit: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** A parent for the layer alone, instead of the portal root the dialog makes beside this host. */
+    readonly container: _angular_core.InputSignal<Element | null | undefined>;
+    /** Removes the footer. An `ng-template[slCommandPaletteFooter]` replaces it instead. */
+    readonly hideFooter: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Words laid over the catalog of the language in force, key by key: the
+     * dialog's name (`label`), the input's name and placeholder, the empty,
+     * loading, count and error sentences, the recents heading, the clear, close
+     * and back controls, and the footer's hints.
+     */
+    readonly messages: _angular_core.InputSignal<PartialMessages<CommandPaletteMessages> | undefined>;
+    readonly open: _angular_core.ModelSignal<boolean>;
+    readonly openChangeRequest: _angular_core.OutputEmitterRef<ChangeRequest<boolean>>;
+    readonly query: _angular_core.ModelSignal<string>;
+    readonly queryChangeRequest: _angular_core.OutputEmitterRef<ChangeRequest<string>>;
+    readonly highlightedId: _angular_core.ModelSignal<string | null>;
+    readonly highlightedIdChangeRequest: _angular_core.OutputEmitterRef<ChangeRequest<string | null>>;
+    readonly pages: _angular_core.ModelSignal<readonly string[]>;
+    readonly pagesChangeRequest: _angular_core.OutputEmitterRef<ChangeRequest<readonly string[]>>;
+    readonly recent: _angular_core.ModelSignal<readonly string[]>;
+    readonly recentChangeRequest: _angular_core.OutputEmitterRef<ChangeRequest<readonly string[]>>;
+    /** Every executed item, after the item's own handler. */
+    readonly select: _angular_core.OutputEmitterRef<CommandPaletteSelectRequest<Item>>;
+    protected readonly itemTemplate: _angular_core.Signal<SlCommandPaletteItem<any> | undefined>;
+    protected readonly footerTemplate: _angular_core.Signal<SlCommandPaletteFooter | undefined>;
+    protected readonly emptyTemplate: _angular_core.Signal<SlCommandPaletteEmpty | undefined>;
+    /** The layer, while there is one; the trigger registers itself on it. */
+    readonly dialog: _angular_core.Signal<SlDialog | undefined>;
+    private readonly field;
+    private readonly list;
+    protected readonly resolvedPresentation: _angular_core.Signal<CommandPalettePresentation>;
+    protected readonly inline: _angular_core.Signal<boolean>;
+    protected readonly resolvedSize: _angular_core.Signal<CommandPaletteSize>;
+    protected readonly resolvedOutsidePress: _angular_core.Signal<DialogDismissPolicy>;
+    protected readonly resolvedLoop: _angular_core.Signal<boolean>;
+    protected readonly resolvedAutoHighlight: _angular_core.Signal<boolean>;
+    protected readonly resolvedCloseOnSelect: _angular_core.Signal<boolean>;
+    protected readonly resolvedClearOnClose: _angular_core.Signal<boolean>;
+    protected readonly resolvedHighlightMatch: _angular_core.Signal<boolean>;
+    protected readonly resolvedHotkey: _angular_core.Signal<string | null>;
+    protected readonly resolvedRecentLimit: _angular_core.Signal<number>;
+    /** The family's words in the language in force, with this palette's `messages` laid over them. */
+    readonly t: _slotted_core_i18n.FamilyTranslator<CommandPaletteMessages>;
+    private readonly appLocale;
+    protected readonly resolvedLocale: _angular_core.Signal<string>;
+    /** Open for the stylesheet and the dialog: an inline palette is always open. */
+    protected readonly isOpen: _angular_core.Signal<boolean>;
+    protected readonly inputElement: _angular_core.Signal<HTMLInputElement | undefined>;
+    private readonly ranker;
+    protected readonly rows: _angular_core.Signal<_slotted_core_commands.ResolvedCommands<Item>>;
+    private readonly rowIds;
+    private readonly enabled;
+    protected readonly isEmpty: _angular_core.Signal<boolean>;
+    protected readonly activeDescendant: _angular_core.Signal<string | null>;
+    protected readonly pending: _angular_core.WritableSignal<ReadonlySet<string>>;
+    private readonly error;
+    protected readonly status: _angular_core.Signal<string>;
+    constructor();
+    setOpen(next: boolean, reason: CommandPaletteOpenReason, source?: Event): void;
+    setQuery(next: string, reason: CommandPaletteQueryReason, source?: Event): void;
+    setHighlighted(next: string | null, reason: CommandPaletteHighlightReason, source?: Event): void;
+    setPages(next: readonly string[], reason: CommandPalettePagesReason, source?: Event): void;
+    private setRecent;
+    openPalette(): void;
+    close(): void;
+    toggle(): void;
+    /** Focuses the input and selects the query. */
+    focus(): void;
+    /** Highlights the row with this id and scrolls it into view. */
+    scrollToId(id: string): void;
+    private execute;
+    protected domId(id: string): string;
+    protected headingOf(section: {
+        recent: boolean;
+        label: string | undefined;
+    }): string | undefined;
+    /** Whether the rows mark the query: the family's own switch, and a query to mark. */
+    protected readonly marking: _angular_core.Signal<boolean>;
+    /**
+     * The runs of a row's label, handed to a consumer's own row template as
+     * `runs`. The default row renders the `highlight` family instead; the
+     * context keeps the runs for a template written before wave 10.
+     */
+    protected runsOf(item: Item): readonly {
+        text: string;
+        matched: boolean;
+    }[];
+    protected keyshortcuts(item: Item): string | null;
+    protected onInput(event: Event): void;
+    protected clear(event: Event): void;
+    protected returnTo(index: number, event: Event): void;
+    protected hover(item: Item, event: Event): void;
+    protected press(item: Item, event: MouseEvent): void;
+    protected onDialogRequest(request: DialogChangeRequest): void;
+    private move;
+    protected onKeyDown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlCommandPalette<any>, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlCommandPalette<any>, "sl-command-palette", ["slCommandPalette"], { "items": { "alias": "items"; "required": true; "isSignal": true; }; "groups": { "alias": "groups"; "required": false; "isSignal": true; }; "rank": { "alias": "rank"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "limit": { "alias": "limit"; "required": false; "isSignal": true; }; "presentation": { "alias": "presentation"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "outsidePress": { "alias": "outsidePress"; "required": false; "isSignal": true; }; "loop": { "alias": "loop"; "required": false; "isSignal": true; }; "autoHighlight": { "alias": "autoHighlight"; "required": false; "isSignal": true; }; "closeOnSelect": { "alias": "closeOnSelect"; "required": false; "isSignal": true; }; "clearOnClose": { "alias": "clearOnClose"; "required": false; "isSignal": true; }; "highlightMatch": { "alias": "highlightMatch"; "required": false; "isSignal": true; }; "hotkey": { "alias": "hotkey"; "required": false; "isSignal": true; }; "recentLimit": { "alias": "recentLimit"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "container": { "alias": "container"; "required": false; "isSignal": true; }; "hideFooter": { "alias": "hideFooter"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "query": { "alias": "query"; "required": false; "isSignal": true; }; "highlightedId": { "alias": "highlightedId"; "required": false; "isSignal": true; }; "pages": { "alias": "pages"; "required": false; "isSignal": true; }; "recent": { "alias": "recent"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "openChangeRequest": "openChangeRequest"; "query": "queryChange"; "queryChangeRequest": "queryChangeRequest"; "highlightedId": "highlightedIdChange"; "highlightedIdChangeRequest": "highlightedIdChangeRequest"; "pages": "pagesChange"; "pagesChangeRequest": "pagesChangeRequest"; "recent": "recentChange"; "recentChangeRequest": "recentChangeRequest"; "select": "select"; }, ["itemTemplate", "footerTemplate", "emptyTemplate"], never, true, never>;
+}
+/**
+ * The control that opens the palette, on the consumer's own element. The
+ * dialog family's trigger is not composed here because it needs the dialog
+ * instance, which lives inside this component's template; what the trigger
+ * needs from it — the open, the `aria-expanded`, the `aria-haspopup` — is
+ * written from the palette instead, and the focus returns to the element
+ * that held it when the layer opened, which is this one.
+ */
+declare class SlCommandPaletteTrigger {
+    readonly palette: _angular_core.InputSignal<SlCommandPalette<CommandPaletteItem>>;
+    private readonly native;
+    constructor();
+    protected onClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlCommandPaletteTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlCommandPaletteTrigger, "[slCommandPaletteTrigger]", ["slCommandPaletteTrigger"], { "palette": { "alias": "slCommandPaletteTrigger"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { COMMAND_PALETTE_DEFAULTS, COMMAND_PALETTE_FALLBACK, SlCommandPalette, SlCommandPaletteEmpty, SlCommandPaletteFooter, SlCommandPaletteItem, SlCommandPaletteTrigger, injectCommandPaletteDefaults, provideCommandPaletteDefaults };
+export type { CommandPaletteDefaults, CommandPaletteHighlightReason, CommandPaletteItem, CommandPaletteItemContext, CommandPaletteItemTemplate, CommandPaletteOpenReason, CommandPalettePagesReason, CommandPalettePresentation, CommandPaletteQueryReason, CommandPaletteSelectReason, CommandPaletteSelectRequest, CommandPaletteSize };
+//# sourceMappingURL=slotted-angular-command-palette.d.ts.map

package/types/slotted-angular-command-palette.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-command-palette.d.ts","sources":["../../command-palette/src/command-palette-defaults.ts","../../command-palette/src/command-palette.ts"],"mappings":"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","names":[]}

package/types/slotted-angular-container.d.ts

@@ -0,0 +1,84 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken } from '@angular/core';
+
+/**
+ * What the column bounds, rather than how big it is. `sm`/`md`/`lg` is this
+ * library's word for control geometry; a container's maximum is chosen by what
+ * is inside it, and a letter hides the choice.
+ *
+ * `measure` is the comfortable reading line, counted in characters so it
+ * follows the inherited type and the reader's zoom. `full` removes the
+ * maximum and keeps the inset.
+ */
+type ContainerSize = 'measure' | 'content' | 'wide' | 'full' | 'bleed';
+/**
+ * The gap between the column and the edge of the space the container was
+ * given, as a step on the space scale — the same scale Stack, Inline and Grid
+ * take their `gap` from. `0` is the absence of an inset.
+ */
+type ContainerInset = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
+/** Where the column sits when there is space left over. */
+type ContainerAlign = 'center' | 'start' | 'end';
+interface ContainerDefaults {
+    align: ContainerAlign;
+    inset: ContainerInset;
+    size: ContainerSize;
+}
+declare const CONTAINER_DEFAULTS: InjectionToken<ContainerDefaults>;
+/**
+ * An application decides once what its pages are bounded to and how far they
+ * are inset, rather than repeating three inputs on every container. A
+ * container that states any of them itself still wins: an explicit input is
+ * never overridden by the token.
+ */
+declare function provideContainerDefaults(defaults: Partial<ContainerDefaults>): {
+    provide: InjectionToken<ContainerDefaults>;
+    useFactory: () => ContainerDefaults;
+};
+/** What a container bounds here, before it states anything of its own. */
+declare function injectContainerDefaults(): ContainerDefaults;
+
+/**
+ * Bounds the inline size of a region, insets it from the edge of the space it
+ * was given, and places it inside that space. It paints nothing, separates
+ * nothing and claims no semantics: the directive is written on the element the
+ * page chose, so a `main`, a `section` and an `article` are all the same
+ * container.
+ *
+ * The root is a three-track grid rather than a box with a maximum, because a
+ * `slContainerBreakout` child needs a track to span. A run of text written
+ * directly inside it becomes an item nothing can select and is placed in the
+ * start gutter; wrap text in an element, as every layout family in this
+ * library already requires.
+ */
+declare class SlContainer {
+    /** What the column bounds. Falls back to the injected default. */
+    readonly size: _angular_core.InputSignal<ContainerSize | undefined>;
+    /** The gap between the column and the edge, as a step on the space scale. */
+    readonly inset: _angular_core.InputSignal<ContainerInset | undefined>;
+    /** Where the column sits when there is space left over. */
+    readonly align: _angular_core.InputSignal<ContainerAlign | undefined>;
+    private readonly defaults;
+    protected readonly resolvedSize: _angular_core.Signal<ContainerSize>;
+    protected readonly resolvedInset: _angular_core.Signal<string>;
+    protected readonly resolvedAlign: _angular_core.Signal<ContainerAlign>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlContainer, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlContainer, "[slContainer]", ["slContainer"], { "size": { "alias": "size"; "required": false; "isSignal": true; }; "inset": { "alias": "inset"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * A child that leaves the bound behind and reaches both edges of the
+ * container: a table, a banner, a strip of media inside a page of prose.
+ *
+ * It answers the container rather than the viewport, so it is still correct
+ * nested, inside a scroll region, and in a container that does not fill the
+ * page. Bounded content returns inside it by nesting another `slContainer`.
+ */
+declare class SlContainerBreakout {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlContainerBreakout, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlContainerBreakout, "[slContainerBreakout]", ["slContainerBreakout"], {}, {}, never, never, true, never>;
+}
+
+export { CONTAINER_DEFAULTS, SlContainer, SlContainerBreakout, injectContainerDefaults, provideContainerDefaults };
+export type { ContainerAlign, ContainerDefaults, ContainerInset, ContainerSize };
+//# sourceMappingURL=slotted-angular-container.d.ts.map

package/types/slotted-angular-container.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-container.d.ts","sources":["../../container/src/container-defaults.ts","../../container/src/container.ts","../../container/src/container-breakout.ts"],"mappings":";;;AAEA;;;;;;;;AAQG;AACG,KAAM,aAAa;AAEzB;;;;AAIG;AACG,KAAM,cAAc;AAE1B;AACM,KAAM,cAAc;UAET,iBAAiB;WACzB,cAAc;WACd,cAAc;UACf,aAAa;AACpB;AAWD,cAAa,kBAAkB,EAAA,cAAA,CAAA,iBAAA;AAK/B;;;;;AAKG;AACH,iBAAgB,wBAAwB,WAAW,OAAO,CAAC,iBAAiB;;sBAGxD,iBAAiB;AAMpC;AAED;AACA,iBAAgB,uBAAuB,IAAI,iBAAiB;;AChD5D;;;;;;;;;;;;AAYG;AACH,cAgBa,WAAW;;mBAET,aAAA,CAAA,WAAA,CAAA,aAAA;;oBAEC,aAAA,CAAA,WAAA,CAAA,cAAA;;oBAEA,aAAA,CAAA,WAAA,CAAA,cAAA;AAEd;AAEA,qCAA+B,aAAA,CAAA,MAAA,CAAA,aAAA;AAC/B,sCAAgC,aAAA,CAAA,MAAA;AAChC,sCAAgC,aAAA,CAAA,MAAA,CAAA,cAAA;oDAZrB,WAAW;sDAAX,WAAW;AAavB;;ACrDD;;;;;;;AAOG;AACH,cAMa,mBAAmB;oDAAnB,mBAAmB;sDAAnB,mBAAmB;AAAG;;","names":[]}

package/types/slotted-angular-context-menu.d.ts

@@ -0,0 +1,84 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { SlMenu } from '@slotted/angular/menu';
+
+/**
+ * The target of a context menu: the region a secondary click, a long press or
+ * `Shift+F10` opens an `sl-menu` on.
+ *
+ * It is written on the consumer's own element — a row, a card, a canvas — and
+ * it is the family's one part: the menu it opens is `sl-menu`, imported as it
+ * is, the way `sl-menubar` holds its menus. The state is the menu's `[(open)]`
+ * and this component only asks it to move, so there is no second owner.
+ *
+ * A component rather than a directive, as `slMenuItem` and `slLink` are,
+ * because a component is what can carry `styleUrl`: this is where the family's
+ * authored stylesheet enters an Angular application.
+ *
+ * It writes no `aria-haspopup`, which is not permitted on a generic element,
+ * and no `tabindex`, which would add a tab stop to every wrapped region. A
+ * target the consumer made focusable can be opened from the keyboard.
+ */
+declare class SlContextMenuTrigger {
+    /** The menu this target opens. */
+    readonly menu: _angular_core.InputSignal<SlMenu>;
+    readonly longPress: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly longPressDelay: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    private readonly element;
+    private readonly defaults;
+    /**
+     * Two directives on one element write host attributes into the same slot,
+     * and a host that already carries a part — a `slTableRow` — keeps it: the
+     * rule `menu-trigger.ts` records, read from the other side.
+     */
+    private readonly writtenUi;
+    private readonly writtenPart;
+    private readonly writtenId;
+    protected readonly ui: string;
+    protected readonly part: string;
+    /** The menu names its surface after this element unless given `aria-label`. */
+    protected get id(): string;
+    protected readonly pressed: _angular_core.WritableSignal<boolean>;
+    private press;
+    private openedByKeyboardAt;
+    protected readonly resolvedLongPress: _angular_core.Signal<boolean>;
+    protected readonly resolvedLongPressDelay: _angular_core.Signal<number>;
+    constructor();
+    /**
+     * Opens, or moves. The way back is captured now: the element that held focus
+     * when the reader pressed, and the target itself when nothing did. While the
+     * surface is already open the anchor moves and no request is emitted.
+     */
+    private openAt;
+    protected onContextMenu(source: Event): void;
+    protected onKeyDown(source: Event): void;
+    /**
+     * A primary press on the target while the menu shows closes it: the target
+     * is a branch of the layer, so the layer would not, and from the reader's
+     * side the target is elsewhere. On touch and pen the same press may also be
+     * the start of a long one.
+     */
+    protected onPointerDown(source: Event): void;
+    protected onPointerMove(source: Event): void;
+    protected cancelPress(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlContextMenuTrigger, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlContextMenuTrigger, "[slContextMenuTriggerFor]", ["slContextMenuTrigger"], { "menu": { "alias": "slContextMenuTriggerFor"; "required": true; "isSignal": true; }; "longPress": { "alias": "longPress"; "required": false; "isSignal": true; }; "longPressDelay": { "alias": "longPressDelay"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+interface ContextMenuDefaults {
+    /** Whether a long press on touch and pen opens the menu. */
+    longPress: boolean;
+    /** How long the press is held before the menu opens, in milliseconds. */
+    longPressDelay: number;
+}
+declare const CONTEXT_MENU_DEFAULTS: InjectionToken<ContextMenuDefaults>;
+/** The decisions an application takes once, in its bootstrap. */
+declare function provideContextMenuDefaults(defaults: Partial<ContextMenuDefaults>): {
+    provide: InjectionToken<ContextMenuDefaults>;
+    useFactory: () => ContextMenuDefaults;
+};
+declare function injectContextMenuDefaults(): ContextMenuDefaults;
+
+export { CONTEXT_MENU_DEFAULTS, SlContextMenuTrigger, injectContextMenuDefaults, provideContextMenuDefaults };
+export type { ContextMenuDefaults };
+//# sourceMappingURL=slotted-angular-context-menu.d.ts.map

package/types/slotted-angular-context-menu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-context-menu.d.ts","sources":["../../context-menu/src/context-menu-trigger.ts","../../context-menu/src/context-menu-defaults.ts"],"mappings":";;;;AAoCA;;;;;;;;;;;;;;;;AAgBG;AACH,cAuBa,oBAAoB;;mBAElB,aAAA,CAAA,WAAA,CAAA,MAAA;wBAEK,aAAA,CAAA,wBAAA;6BAGK,aAAA,CAAA,wBAAA;AAIvB;AACA;AAEA;;;;AAIG;AACH;AACA;AACA;AAEA;AACA;;AAEA;AAIA,gCAA0B,aAAA,CAAA,cAAA;;;AAI1B,0CAAoC,aAAA,CAAA,MAAA;AAGpC,+CAAyC,aAAA,CAAA,MAAA;;AAoCzC;;;;AAIG;AACH;AAeA,oCAAgC,KAAK;AAUrC,gCAA4B,KAAK;AASjC;;;;;AAKG;AACH,oCAAgC,KAAK;AAqBrC,oCAAgC,KAAK;AAUrC;oDArJW,oBAAoB;sDAApB,oBAAoB;AA2JhC;;UCrOgB,mBAAmB;;;;;AAKnC;AAaD,cAAa,qBAAqB,EAAA,cAAA,CAAA,mBAAA;AAKlC;AACA,iBAAgB,0BAA0B,WAAW,OAAO,CAAC,mBAAmB;;sBAG5D,mBAAmB;AAEtC;AAED,iBAAgB,yBAAyB,IAAI,mBAAmB;;","names":[]}