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

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

@@ -0,0 +1,366 @@
+import * as _slotted_core_i18n from '@slotted/core/i18n';
+import { PartialMessages, PopoverMessages } from '@slotted/core/i18n';
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Provider, OnInit, AfterViewInit } from '@angular/core';
+import { ChangeRequest } from '@slotted/core/state';
+
+/** The width and type step the panel sits at. */
+type PopoverSize = 'sm' | 'md' | 'lg';
+/**
+ * How wide the panel is. `anchor` makes it exactly as wide as the element it
+ * hangs from, which is what a filter panel under a search field wants.
+ */
+type PopoverWidth = 'auto' | 'anchor';
+/** The edge of the anchor the layer prefers. The two logical values mirror. */
+type PopoverSide = 'top' | 'bottom' | 'inline-start' | 'inline-end' | 'left' | 'right';
+/** Where the layer sits along the side it took. */
+type PopoverAlign = 'start' | 'center' | 'end';
+/** When the layer exists. `lazy` is what a panel holding an expensive form wants. */
+type PopoverMount = 'active' | 'lazy' | 'eager';
+/** `fixed` for a layer inside `overflow: hidden`, `absolute` for one inside a transform. */
+type PopoverStrategy = 'absolute' | 'fixed';
+/** Why the panel opened or closed. */
+type PopoverOpenReason = Extract<ChangeRequest<boolean>['reason'], 'pointer' | 'keyboard' | 'escape' | 'outsidePress' | 'dismiss' | 'programmatic'>;
+/** The request `openChangeRequest` emits before the panel moves, as React's `PopoverChangeRequest`. */
+type PopoverChangeRequest = ChangeRequest<boolean>;
+/** Somewhere to put the focus: an element, or a selector read inside the panel. */
+type PopoverFocusTarget = Element | string;
+/** What an application sets once for every popover under it. */
+interface PopoverDefaults {
+    align: PopoverAlign;
+    alignOffset: number;
+    arrow: boolean;
+    arrowPadding: number;
+    autoFocus: boolean;
+    closeOnEscape: boolean;
+    closeOnOutsidePress: boolean;
+    collisionPadding: number;
+    flip: boolean;
+    hideWhenDetached: boolean;
+    mount: PopoverMount;
+    portal: boolean;
+    shift: boolean;
+    side: PopoverSide;
+    sideOffset: number;
+    size: PopoverSize;
+    strategy: PopoverStrategy;
+    width: PopoverWidth;
+}
+/**
+ * `arrowPadding` is larger than the tooltip's because the panel's corner radius
+ * is larger. `hideWhenDetached` is off: a task the reader is halfway through
+ * must not blink because the row behind it scrolled.
+ */
+declare const POPOVER_FALLBACK: PopoverDefaults;
+declare const POPOVER_DEFAULTS: InjectionToken<PopoverDefaults>;
+/**
+ * An application decides once how its popovers behave and look. The close
+ * control's accessible name comes from the language in force
+ * (`provideSlotted`).
+ *
+ * What is stated here is written over the defaults already in force rather than
+ * over the fallback, which is what React's provider does: a section that sets
+ * `width` for itself keeps the application's `size`.
+ */
+declare function providePopoverDefaults(defaults: Partial<PopoverDefaults>): Provider;
+/** What a popover renders as here, before it states anything of its own. */
+declare function injectPopoverDefaults(): PopoverDefaults;
+/**
+ * Application-scoped rather than module-scoped, for the reason `field` records:
+ * a module-level counter produces colliding sequences when two applications
+ * render in one server process, and the two sequences have to match for
+ * hydration.
+ */
+declare class SlPopoverIdFactory {
+    private count;
+    next(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlPopoverIdFactory, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
+}
+
+/**
+ * Interactive, non-modal content anchored to the control that opened it.
+ *
+ * It is the APG's non-modal dialog — the pattern the tooltip page names for a
+ * surface that holds focusable elements — and it is deliberately **not** modal.
+ * Nothing behind it becomes `inert`, the page keeps scrolling, `aria-modal` is
+ * never written and focus is not contained. The modal surface is `slDialog`.
+ *
+ * Written on an `ng-container`, because it renders nothing: the trigger stays
+ * where the consumer wrote it and the layer is portalled.
+ */
+declare class SlPopover implements OnInit {
+    /** Whether the panel is showing. Two-way, so a template may bind it directly. */
+    readonly open: _angular_core.ModelSignal<boolean>;
+    /** The state an uncontrolled popover starts in, read once in `ngOnInit`. */
+    readonly defaultOpen: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The popover never opens. The trigger's own `disabled` is the consumer's. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly size: _angular_core.InputSignal<PopoverSize | undefined>;
+    readonly width: _angular_core.InputSignal<PopoverWidth | undefined>;
+    readonly side: _angular_core.InputSignal<PopoverSide | undefined>;
+    readonly align: _angular_core.InputSignal<PopoverAlign | undefined>;
+    readonly mount: _angular_core.InputSignal<PopoverMount | undefined>;
+    readonly strategy: _angular_core.InputSignal<PopoverStrategy | undefined>;
+    /**
+     * Words laid over the catalog of the language in force, key by key: the
+     * close control's accessible name (`close`).
+     */
+    readonly messages: _angular_core.InputSignal<PartialMessages<PopoverMessages> | undefined>;
+    /** What takes focus on open instead of the panel — a search field, usually. */
+    readonly initialFocus: _angular_core.InputSignal<PopoverFocusTarget | undefined>;
+    /** Where focus lands after it closes, for a trigger that is gone by then. */
+    readonly finalFocus: _angular_core.InputSignal<PopoverFocusTarget | undefined>;
+    readonly arrow: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly autoFocus: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly closeOnEscape: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly closeOnOutsidePress: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly flip: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly shift: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly hideWhenDetached: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly portal: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly sideOffset: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    readonly alignOffset: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    readonly collisionPadding: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    readonly arrowPadding: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    /** One output for one transition, carrying the reason and the event. */
+    readonly openChangeRequest: _angular_core.OutputEmitterRef<PopoverChangeRequest>;
+    private readonly defaults;
+    /** The family's words in the language in force, with this popover's `messages` laid over them. */
+    readonly t: _slotted_core_i18n.FamilyTranslator<PopoverMessages>;
+    private readonly base;
+    readonly contentId: string;
+    readonly titleId: string;
+    readonly descriptionId: string;
+    /** The elements the parts register, which the layer measures and focuses. */
+    readonly triggerNode: _angular_core.WritableSignal<HTMLElement | null>;
+    readonly anchorNode: _angular_core.WritableSignal<HTMLElement | null>;
+    readonly arrowNode: _angular_core.WritableSignal<HTMLElement | null>;
+    readonly contentNode: _angular_core.WritableSignal<HTMLElement | null>;
+    readonly hasTitle: _angular_core.WritableSignal<boolean>;
+    readonly hasDescription: _angular_core.WritableSignal<boolean>;
+    readonly isOpen: _angular_core.Signal<boolean>;
+    readonly resolvedSize: _angular_core.Signal<PopoverSize>;
+    readonly resolvedWidth: _angular_core.Signal<PopoverWidth>;
+    readonly resolvedSide: _angular_core.Signal<PopoverSide>;
+    readonly resolvedAlign: _angular_core.Signal<PopoverAlign>;
+    readonly resolvedMount: _angular_core.Signal<PopoverMount>;
+    readonly resolvedStrategy: _angular_core.Signal<PopoverStrategy>;
+    readonly resolvedArrow: _angular_core.Signal<boolean>;
+    readonly resolvedAutoFocus: _angular_core.Signal<boolean>;
+    /**
+     * The role the panel carries when the consumer wrote none. A family that
+     * provides itself as this one — `slHoverCard` — decides it here: a card
+     * nothing can enter is `presentation`, not a dialog nobody is told about.
+     */
+    readonly contentRole: _angular_core.Signal<string>;
+    readonly resolvedCloseOnEscape: _angular_core.Signal<boolean>;
+    readonly resolvedCloseOnOutsidePress: _angular_core.Signal<boolean>;
+    readonly resolvedFlip: _angular_core.Signal<boolean>;
+    readonly resolvedShift: _angular_core.Signal<boolean>;
+    readonly resolvedHideWhenDetached: _angular_core.Signal<boolean>;
+    readonly resolvedPortal: _angular_core.Signal<boolean>;
+    readonly resolvedSideOffset: _angular_core.Signal<number>;
+    readonly resolvedAlignOffset: _angular_core.Signal<number>;
+    readonly resolvedCollisionPadding: _angular_core.Signal<number>;
+    readonly resolvedArrowPadding: _angular_core.Signal<number>;
+    private readonly everOpened;
+    readonly seen: _angular_core.Signal<boolean>;
+    /**
+     * Read here rather than in the constructor, because inputs are not set yet
+     * there, and once: a later change to it is not new state.
+     */
+    ngOnInit(): void;
+    /** Opens now. One of the two imperative actions a template cannot express. */
+    show(): void;
+    /** Closes now. */
+    hide(): void;
+    toggle(next: boolean, reason: PopoverOpenReason, source?: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlPopover, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlPopover, "[slPopover]", ["slPopover"], { "open": { "alias": "open"; "required": false; "isSignal": true; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "side": { "alias": "side"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "mount": { "alias": "mount"; "required": false; "isSignal": true; }; "strategy": { "alias": "strategy"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; "initialFocus": { "alias": "initialFocus"; "required": false; "isSignal": true; }; "finalFocus": { "alias": "finalFocus"; "required": false; "isSignal": true; }; "arrow": { "alias": "arrow"; "required": false; "isSignal": true; }; "autoFocus": { "alias": "autoFocus"; "required": false; "isSignal": true; }; "closeOnEscape": { "alias": "closeOnEscape"; "required": false; "isSignal": true; }; "closeOnOutsidePress": { "alias": "closeOnOutsidePress"; "required": false; "isSignal": true; }; "flip": { "alias": "flip"; "required": false; "isSignal": true; }; "shift": { "alias": "shift"; "required": false; "isSignal": true; }; "hideWhenDetached": { "alias": "hideWhenDetached"; "required": false; "isSignal": true; }; "portal": { "alias": "portal"; "required": false; "isSignal": true; }; "sideOffset": { "alias": "sideOffset"; "required": false; "isSignal": true; }; "alignOffset": { "alias": "alignOffset"; "required": false; "isSignal": true; }; "collisionPadding": { "alias": "collisionPadding"; "required": false; "isSignal": true; }; "arrowPadding": { "alias": "arrowPadding"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "openChangeRequest": "openChangeRequest"; }, never, never, true, never>;
+}
+
+/**
+ * The control that opens the panel.
+ *
+ * The directive goes on the consumer's own control — a `button`, which is what
+ * gives `Enter` and `Space` for free. It carries the wiring and `data-open`,
+ * and **no `data-part`**: a trigger is very often another family's root, and
+ * claiming it would unstyle that family.
+ */
+declare class SlPopoverTrigger implements AfterViewInit {
+    protected readonly popover: SlPopover;
+    private readonly native;
+    private readonly destroyRef;
+    constructor();
+    /**
+     * After the view, not as a host listener. A `(click)` the consumer wrote on
+     * the same element is bound when the view is created, so a listener bound any
+     * earlier runs first and reads `defaultPrevented` before the consumer has had
+     * the chance to set it — the order `slIconButton` records.
+     */
+    ngAfterViewInit(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlPopoverTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlPopoverTrigger, "[slPopoverTrigger]", ["slPopoverTrigger"], {}, {}, never, never, true, never>;
+}
+/**
+ * What the panel points at, when that is not the button that opened it — a row
+ * whose action menu hangs off the row rather than off its own control. It
+ * carries no attributes: it is only measured.
+ */
+declare class SlPopoverAnchor {
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlPopoverAnchor, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlPopoverAnchor, "[slPopoverAnchor]", ["slPopoverAnchor"], {}, {}, never, never, true, never>;
+}
+/**
+ * The positioned layer, built from a template rather than from an element, for
+ * the reason `slTooltipLayer` sets out: `mount="active"` means the layer exists
+ * only while it is open, and a component cannot remove its own host.
+ *
+ * It also builds the two focus guards. Focus reaching one arrived by `Tab` at
+ * the edge of a layer that lives at the end of the document, so the family
+ * closes and puts focus back on the trigger, from which the reader's next `Tab`
+ * continues down the page. It is the only answer that keeps the reading order
+ * intact without trapping focus in a layer that is not modal.
+ */
+declare class SlPopoverLayer {
+    private readonly popover;
+    private readonly template;
+    private readonly viewContainer;
+    private readonly comment;
+    private readonly arrowPlaceholder;
+    /** A signal, so every effect that reads it re-runs when the layer arrives. */
+    private readonly layerNode;
+    private view;
+    private portal;
+    private positioner;
+    private dismissable;
+    private readonly status;
+    private readonly positioned;
+    private wasOpen;
+    private readonly presence;
+    readonly mounted: _angular_core.Signal<boolean>;
+    constructor();
+    /** Measures and places the layer again. */
+    reposition(): void;
+    private build;
+    private guard;
+    private teardown;
+    private place;
+    /**
+     * One layer in the single stack, and only while it is open. It is not modal:
+     * nothing outside becomes `inert` and the page keeps scrolling. The trigger
+     * and the anchor are branches, so pressing either is inside the layer.
+     */
+    private stack;
+    private paint;
+    /**
+     * The arrow the consumer wrote leaves the layer while `arrow` resolves to
+     * false, and a comment holds its place, so the layer holds no arrow — as
+     * React's `PopoverArrow` renders none — and the positioner measures none.
+     */
+    private showArrow;
+    /**
+     * Focus goes to the panel itself rather than to its first control, so a
+     * reader hears the panel's name before its contents. It waits for the first
+     * measurement, because focusing a layer still at the origin scrolls the page
+     * to it.
+     */
+    private moveFocus;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlPopoverLayer, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlPopoverLayer, "ng-template[slPopoverLayer]", ["slPopoverLayer"], {}, {}, never, never, true, never>;
+}
+/**
+ * The panel. `role="dialog"`, named by its title and described by its
+ * description when those parts are present, and `aria-modal` is never written —
+ * saying it would tell a reader the rest of the page is gone while it is not.
+ *
+ * A popover with no title gets no `aria-labelledby`; the family invents no
+ * name, and a consumer writes `aria-label` here instead — which is why the
+ * host attribute they wrote is read before the binding is computed.
+ *
+ * It is the one part written as a component, because a component is what can
+ * carry `styleUrl`: this is where the family's authored stylesheet enters an
+ * Angular application.
+ */
+declare class SlPopoverContent {
+    protected readonly popover: SlPopover;
+    private readonly writtenLabel;
+    private readonly writtenRole;
+    protected readonly role: _angular_core.Signal<string>;
+    protected readonly labelledBy: _angular_core.Signal<string | null>;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlPopoverContent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlPopoverContent, "[slPopoverContent]", ["slPopoverContent"], {}, {}, never, ["*"], true, never>;
+}
+/** The title, the description and the close control, on the row that stays put. */
+declare class SlPopoverHeader {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlPopoverHeader, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlPopoverHeader, "[slPopoverHeader]", ["slPopoverHeader"], {}, {}, never, never, true, never>;
+}
+/**
+ * The panel's accessible name. The consumer writes the element, so a heading
+ * that belongs in the document outline is theirs to choose — the reason
+ * `result-state` records for the same decision.
+ */
+declare class SlPopoverTitle {
+    protected readonly popover: SlPopover;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlPopoverTitle, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlPopoverTitle, "[slPopoverTitle]", ["slPopoverTitle"], {}, {}, never, never, true, never>;
+}
+/** One line under the title, referenced by the panel rather than announced. */
+declare class SlPopoverDescription {
+    protected readonly popover: SlPopover;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlPopoverDescription, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlPopoverDescription, "[slPopoverDescription]", ["slPopoverDescription"], {}, {}, never, never, true, never>;
+}
+/**
+ * The only part that scrolls, bounded by the height the engine says is left.
+ * Bounding the whole panel would scroll the title out of sight, which is how a
+ * reader loses track of what they are in.
+ */
+declare class SlPopoverBody {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlPopoverBody, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlPopoverBody, "[slPopoverBody]", ["slPopoverBody"], {}, {}, never, never, true, never>;
+}
+/** The actions row, which keeps its height while the body scrolls under it. */
+declare class SlPopoverFooter {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlPopoverFooter, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlPopoverFooter, "[slPopoverFooter]", ["slPopoverFooter"], {}, {}, never, never, true, never>;
+}
+/**
+ * The pointer's way out. The keyboard has Escape, and a reader on a touch
+ * device has no Escape key at all. A close control with no text of its own —
+ * the drawn cross, or the consumer's icon — is named by the catalog's `close`;
+ * one that shows words, such as "Done", is named by them, and a name the
+ * consumer wrote on the element wins over both.
+ */
+declare class SlPopoverClose {
+    protected readonly popover: SlPopover;
+    private readonly written;
+    private readonly native;
+    /** Whether the content shows text, read after every render because it may change. */
+    private readonly hasText;
+    protected readonly label: _angular_core.Signal<string | null>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlPopoverClose, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlPopoverClose, "button[slPopoverClose]", ["slPopoverClose"], {}, {}, never, ["*"], true, never>;
+}
+/**
+ * The mark that points at the anchor. The family draws it; the positioner
+ * measures it and says where it goes. It is hidden from assistive technology.
+ * While `arrow` resolves to false the layer takes it out (`slPopoverLayer`).
+ */
+declare class SlPopoverArrow {
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlPopoverArrow, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlPopoverArrow, "[slPopoverArrow]", ["slPopoverArrow"], {}, {}, never, never, true, never>;
+}
+
+export { POPOVER_DEFAULTS, POPOVER_FALLBACK, SlPopover, SlPopoverAnchor, SlPopoverArrow, SlPopoverBody, SlPopoverClose, SlPopoverContent, SlPopoverDescription, SlPopoverFooter, SlPopoverHeader, SlPopoverIdFactory, SlPopoverLayer, SlPopoverTitle, SlPopoverTrigger, injectPopoverDefaults, providePopoverDefaults };
+export type { PopoverAlign, PopoverChangeRequest, PopoverDefaults, PopoverFocusTarget, PopoverMount, PopoverOpenReason, PopoverSide, PopoverSize, PopoverStrategy, PopoverWidth };
+//# sourceMappingURL=slotted-angular-popover.d.ts.map

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

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