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

package/types/slotted-angular-app-shell.d.ts

@@ -0,0 +1,549 @@
+import * as _slotted_angular_progress_indicator from '@slotted/angular/progress-indicator';
+import { ProgressTone, ProgressSize } from '@slotted/angular/progress-indicator';
+import * as _slotted_core_i18n from '@slotted/core/i18n';
+import { PartialMessages, AppShellMessages } from '@slotted/core/i18n';
+import * as _angular_core from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { PresenceStatus } from '@slotted/core/presence';
+
+/**
+ * Which region reaches the corner of the screen. `banner` spans the full width
+ * and the navigation starts below it; `nav` spans the full height and the
+ * banner starts beside it; `main` spans the navigation the full height as well
+ * and puts the banner in the plane of the content, inside the card that holds
+ * it. The grid changes where a region is drawn and never where it is written,
+ * so the focus order is the same under all three.
+ */
+type AppShellPrimary = 'banner' | 'nav' | 'main';
+/**
+ * Which surface carries which plane, for every region at once. `inset` paints
+ * the frame with the sunken ground and makes the content a raised card;
+ * `flush` runs every region edge to edge, separated at its seams; `floating`
+ * makes the navigation a card as well as the content; `panel` holds the
+ * navigation, the content and the pane in one card, the banner on the frame
+ * above it.
+ */
+type AppShellCanvas = 'inset' | 'flush' | 'floating' | 'panel';
+/**
+ * What draws a seam where two regions touch without a gutter. `rule` is a
+ * line; `tone` is a ground of its own on the chrome regions, 0.036 OKLab L
+ * from the surface, with the subtle tones inside them recomputed from it.
+ */
+type AppShellSeparation = 'rule' | 'tone';
+/**
+ * How the navigation region occupies space. `auto` is `inline` at or above the
+ * shell's own `APP_SHELL_OVERLAY_AT` inline size and `overlay` below it.
+ */
+type AppShellNavMode = 'inline' | 'overlay' | 'auto';
+/** How the secondary pane occupies space: the navigation's pair, resolved on the same width. */
+type AppShellAsideMode = 'inline' | 'overlay' | 'auto';
+/** Which end of the line the navigation region sits at. Logical, so the layout mirrors. */
+type AppShellNavSide = 'start' | 'end';
+/** What a closed inline navigation leaves behind. */
+type AppShellCollapsedTo = 'rail' | 'hidden';
+/** A step on the region's own width scale. */
+type AppShellSize = 'sm' | 'md' | 'lg';
+/** Who scrolls: the content column, or the document. */
+type AppShellScroll = 'content' | 'document';
+/** Whether a dismissal source closes the overlaid navigation. */
+type AppShellDismissPolicy = 'close' | 'none';
+/** Why the navigation region opened or closed. */
+type AppShellOpenReason = 'pointer' | 'keyboard' | 'escape' | 'outsidePress' | 'back' | 'select' | 'resize' | 'programmatic';
+/** Why the secondary pane opened or closed. No `select`: a pane has no destinations. */
+type AppShellAsideOpenReason = Exclude<AppShellOpenReason, 'select'>;
+/** Why the pane's extent moved. */
+type AppShellAsideExtentReason = 'pointer' | 'keyboard' | 'programmatic';
+/**
+ * The request the shell makes before the pane's extent moves. `undefined` is
+ * the pane back on the measure its size step gives it.
+ */
+interface AppShellAsideExtentRequest {
+    readonly value: number | undefined;
+    readonly previous: number | undefined;
+    readonly reason: AppShellAsideExtentReason;
+    readonly source?: unknown;
+    readonly cancelled: boolean;
+    cancel(): void;
+}
+/** The request the shell makes before the region moves. Cancel it and nothing commits. */
+interface AppShellOpenRequest {
+    readonly value: boolean;
+    readonly previous: boolean;
+    readonly reason: AppShellOpenReason;
+    readonly source?: unknown;
+    readonly cancelled: boolean;
+    cancel(): void;
+}
+interface AppShellDefaults {
+    asideMode: AppShellAsideMode;
+    asideSize: AppShellSize;
+    canvas: AppShellCanvas;
+    closeOnNavigate: boolean;
+    collapsedTo: AppShellCollapsedTo;
+    escape: AppShellDismissPolicy;
+    /** The platform's way back — a phone's gesture, a browser's button — closes a modal layer. */
+    back: AppShellDismissPolicy;
+    modal: boolean;
+    navMode: AppShellNavMode;
+    navSide: AppShellNavSide;
+    navSize: AppShellSize;
+    outsidePress: AppShellDismissPolicy;
+    primary: AppShellPrimary;
+    scroll: AppShellScroll;
+    separation: AppShellSeparation;
+}
+declare const APP_SHELL_DEFAULTS: InjectionToken<AppShellDefaults>;
+/**
+ * An application decides once how its shell is arranged — which region reaches
+ * the corner, which plane the content sits on, how the navigation behaves when
+ * the space runs out — rather than repeating the same inputs on every route. A
+ * shell that states any of them itself still wins. Its words come from the
+ * language in force (`provideSlotted`).
+ */
+declare function provideAppShellDefaults(defaults: Partial<AppShellDefaults>): {
+    provide: InjectionToken<AppShellDefaults>;
+    useFactory: () => AppShellDefaults;
+};
+/** What a shell renders as here, before it states anything of its own. */
+declare function injectAppShellDefaults(): AppShellDefaults;
+
+/**
+ * The inline size the navigation stops being a column at. The stylesheet needs
+ * it literal — `@container (inline-size: var(--x))` is invalid CSS — and the
+ * script needs it to know whether `Escape`, the focus scope and `inert` are in
+ * play. It is the limit of the compact size class, `COMPACT_BELOW`;
+ * `specs/components/app-shell/contract.json` states it once, and
+ * `app-shell.styles.test.mjs` compares the stylesheet's own condition to it.
+ */
+declare const APP_SHELL_OVERLAY_AT = 600;
+/**
+ * The outer frame of a route: the regions that do not change when the content
+ * does.
+ *
+ * **The layer is composed from `packages/core` and rewritten nowhere.**
+ * `measure` answers the shell's own inline size, `dismissable-layer` owns
+ * `Escape`, the outside press and the single stack, `focus` contains the
+ * keyboard and gives it back to the toggle, and `portal` is told once that this
+ * shell is where an overlay belongs.
+ *
+ * **The element is the consumer's.** `<div slAppShell>` is the frame and the
+ * directive adds the grid, the skip links, the veil and the portal root around
+ * whatever is projected into it.
+ */
+declare class SlAppShell {
+    /** Whether the navigation region is showing its full panel. Two-way. */
+    readonly navOpen: _angular_core.ModelSignal<boolean>;
+    /** Whether the secondary pane is showing. Two-way. */
+    readonly asideOpen: _angular_core.ModelSignal<boolean>;
+    /**
+     * How much of the shell's inline size the pane takes as a column, in
+     * `[0, 1]`. Unset means `asideSize` decides. Two-way.
+     */
+    readonly asideExtent: _angular_core.ModelSignal<number | undefined>;
+    /** The smallest extent the reader may give the pane. */
+    readonly minAsideExtent: _angular_core.InputSignal<number>;
+    /** The largest extent the reader may give the pane. */
+    readonly maxAsideExtent: _angular_core.InputSignal<number>;
+    /** Defaults to the provider, then `banner`. */
+    readonly primary: _angular_core.InputSignal<AppShellPrimary | undefined>;
+    /** Defaults to the provider, then `inset`. */
+    readonly canvas: _angular_core.InputSignal<AppShellCanvas | undefined>;
+    /** Defaults to the provider, then `auto`. */
+    readonly navMode: _angular_core.InputSignal<AppShellNavMode | undefined>;
+    /** Defaults to the provider, then `start`. */
+    readonly navSide: _angular_core.InputSignal<AppShellNavSide | undefined>;
+    /** Defaults to the provider, then `md`. */
+    readonly navSize: _angular_core.InputSignal<AppShellSize | undefined>;
+    /** Defaults to the provider, then `auto`. */
+    readonly asideMode: _angular_core.InputSignal<AppShellAsideMode | undefined>;
+    /** Defaults to the provider, then `md`. */
+    readonly asideSize: _angular_core.InputSignal<AppShellSize | undefined>;
+    /** Defaults to the provider, then `rail`. */
+    readonly collapsedTo: _angular_core.InputSignal<AppShellCollapsedTo | undefined>;
+    /** Defaults to the provider, then `content`. */
+    readonly scroll: _angular_core.InputSignal<AppShellScroll | undefined>;
+    /** What draws a seam where two regions touch without a gutter. Defaults to the provider, then `rule`. */
+    readonly separation: _angular_core.InputSignal<AppShellSeparation | undefined>;
+    /** Defaults to the provider, then `true`. */
+    readonly modal: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
+    /** Defaults to the provider, then `close`. */
+    readonly escape: _angular_core.InputSignal<AppShellDismissPolicy | undefined>;
+    /** Defaults to the provider, then `close`. */
+    readonly outsidePress: _angular_core.InputSignal<AppShellDismissPolicy | undefined>;
+    /**
+     * The platform's way back — a phone's gesture, a browser's button — closes
+     * a modal layer instead of leaving the page. Defaults to the provider, then `close`.
+     */
+    readonly back: _angular_core.InputSignal<AppShellDismissPolicy | undefined>;
+    /** Defaults to the provider, then `true`. */
+    readonly closeOnNavigate: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
+    /**
+     * Words laid over the catalog of the language in force, key by key: the
+     * landmarks' names, the toggles and the skip links. A static `aria-label`
+     * on a part still wins.
+     */
+    readonly messages: _angular_core.InputSignal<PartialMessages<AppShellMessages> | undefined>;
+    /**
+     * The request, before anything commits. `reason` is what tells the reader's
+     * own choice from the one the layout forced, which is the line
+     * `docs/component-features.md` §15 asks for when it says sidebar persistence
+     * belongs to the product.
+     */
+    readonly navOpenChangeRequest: _angular_core.OutputEmitterRef<AppShellOpenRequest>;
+    /** The pane's request, with the same shape and the reasons a pane can carry. */
+    readonly asideOpenChangeRequest: _angular_core.OutputEmitterRef<AppShellOpenRequest>;
+    /** The request before the pane's extent moves, already held inside the limits. */
+    readonly asideExtentChangeRequest: _angular_core.OutputEmitterRef<AppShellAsideExtentRequest>;
+    private readonly defaults;
+    private readonly host;
+    private readonly narrow;
+    /** Whether a pointer is moving the pane's edge, which the host reports as `data-dragging`. */
+    readonly asideDragging: _angular_core.WritableSignal<boolean>;
+    /** The limits, ordered and inside `[0, 1]`. */
+    readonly asideBounds: _angular_core.Signal<{
+        min: number;
+        max: number;
+    }>;
+    /**
+     * Stable ids, and not `crypto.randomUUID()`: a server render and the
+     * hydration that follows it have to produce the same string, and a random one
+     * produces two.
+     */
+    private readonly seq;
+    readonly navId: string;
+    readonly mainId: string;
+    readonly asideId: string;
+    readonly toggleId: string;
+    readonly asideToggleId: string;
+    /** The nodes the layer, the focus scope and the `inert` pass need. */
+    readonly nodes: {
+        aside: HTMLElement | null;
+        asideToggle: HTMLElement | null;
+        banner: HTMLElement | null;
+        footer: HTMLElement | null;
+        main: HTMLElement | null;
+        nav: HTMLElement | null;
+        toggle: HTMLElement | null;
+    };
+    private readonly regions;
+    readonly resolvedPrimary: _angular_core.Signal<AppShellPrimary>;
+    readonly resolvedCanvas: _angular_core.Signal<AppShellCanvas>;
+    readonly resolvedNavSide: _angular_core.Signal<AppShellNavSide>;
+    readonly resolvedNavSize: _angular_core.Signal<AppShellSize>;
+    readonly resolvedAsideSize: _angular_core.Signal<AppShellSize>;
+    private readonly wantedAsideMode;
+    /** The pane's mode, resolved the same way against the same width. */
+    readonly resolvedAsideMode: _angular_core.Signal<"inline" | "overlay" | null>;
+    readonly asideOverlay: _angular_core.Signal<boolean>;
+    readonly resolvedCollapsedTo: _angular_core.Signal<AppShellCollapsedTo>;
+    readonly resolvedScroll: _angular_core.Signal<AppShellScroll>;
+    readonly resolvedSeparation: _angular_core.Signal<AppShellSeparation>;
+    readonly resolvedModal: _angular_core.Signal<boolean>;
+    readonly resolvedEscape: _angular_core.Signal<AppShellDismissPolicy>;
+    readonly resolvedBack: _angular_core.Signal<AppShellDismissPolicy>;
+    readonly resolvedOutsidePress: _angular_core.Signal<AppShellDismissPolicy>;
+    readonly resolvedCloseOnNavigate: _angular_core.Signal<boolean>;
+    /** The family's words in the language in force, with this shell's `messages` laid over them. */
+    readonly t: _slotted_core_i18n.FamilyTranslator<AppShellMessages>;
+    /** Whether the bar on the content's edge is painted, which `main` reports as `aria-busy`. */
+    readonly busy: _angular_core.WritableSignal<boolean>;
+    private readonly wantedMode;
+    /**
+     * `null` until the gate has measured, which is what keeps `data-nav-mode` off
+     * the host through a server render: below the breakpoint the stylesheet shows
+     * the overlaid panel only under `[data-nav-mode='overlay'][data-open]`, so the
+     * frame before hydration draws the narrow shell closed.
+     */
+    readonly resolvedMode: _angular_core.Signal<"inline" | "overlay" | null>;
+    readonly overlay: _angular_core.Signal<boolean>;
+    /**
+     * The veil has a presence of its own, as a dialog's backdrop does. The
+     * stylesheet fades it in from `entering` and out through `exiting`, and a
+     * veil mounted straight at `open` gave that transition no closed style to
+     * start from: it appeared in one frame beside a panel that took two hundred
+     * milliseconds to arrive, and left the same way. One presence for both
+     * layers, because there is one veil: with both regions overlaid and both
+     * open it stays, and it leaves when the last of them does.
+     */
+    private readonly veil;
+    protected readonly veilStatus: _angular_core.WritableSignal<PresenceStatus>;
+    private readonly veilRef;
+    /** Created on the first resolved value, so a veil the template opens with does not fade in. */
+    private veilPresence;
+    protected readonly skipTargets: _angular_core.Signal<{
+        href: string;
+        label: string;
+    }[]>;
+    constructor();
+    /** The root, which the pane's extent is a fraction of. */
+    get element(): HTMLElement;
+    /**
+     * Asks to move the pane's extent, held inside the limits. `undefined`
+     * travels whole: it is the pane back on its size step.
+     */
+    requestAsideExtent(next: number | undefined, reason: AppShellAsideExtentReason, source: unknown): void;
+    /** A region says it exists, so a skip link is never written to a target nobody rendered. */
+    registerRegion(region: 'nav' | 'main' | 'aside'): () => void;
+    /** Asks to move the region, carrying the reason and the originating event. */
+    request(next: boolean, reason: AppShellOpenReason, source: unknown): void;
+    /** Asks to move the pane, carrying the reason and the originating event. */
+    requestAside(next: boolean, reason: AppShellAsideOpenReason, source: unknown): void;
+    /** Asks to show the pane, with the reason `programmatic`. */
+    openAside(): void;
+    /** Asks to hide it, with the reason `programmatic`. */
+    closeAside(): void;
+    /** Asks to show the region, with the reason `programmatic`. */
+    openNav(): void;
+    /** Asks to hide it, with the reason `programmatic`. */
+    closeNav(): void;
+    /** Moves focus into the content region, which is where a skip link sends it. */
+    focusMain(): void;
+    /**
+     * A click that lands on an `a[href]` inside the region asks to close, in the
+     * overlaid mode only. Vaadin and PatternFly both do it, and without it a
+     * phone costs two taps per destination. `defaultPrevented` is no refusal
+     * here: a client-side router prevents the native navigation of every link it
+     * routes. A disabled destination (`aria-disabled="true"`) stays open; any
+     * other refusal cancels the request.
+     */
+    protected onClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlAppShell, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlAppShell, "[slAppShell]", ["slAppShell"], { "navOpen": { "alias": "navOpen"; "required": false; "isSignal": true; }; "asideOpen": { "alias": "asideOpen"; "required": false; "isSignal": true; }; "asideExtent": { "alias": "asideExtent"; "required": false; "isSignal": true; }; "minAsideExtent": { "alias": "minAsideExtent"; "required": false; "isSignal": true; }; "maxAsideExtent": { "alias": "maxAsideExtent"; "required": false; "isSignal": true; }; "primary": { "alias": "primary"; "required": false; "isSignal": true; }; "canvas": { "alias": "canvas"; "required": false; "isSignal": true; }; "navMode": { "alias": "navMode"; "required": false; "isSignal": true; }; "navSide": { "alias": "navSide"; "required": false; "isSignal": true; }; "navSize": { "alias": "navSize"; "required": false; "isSignal": true; }; "asideMode": { "alias": "asideMode"; "required": false; "isSignal": true; }; "asideSize": { "alias": "asideSize"; "required": false; "isSignal": true; }; "collapsedTo": { "alias": "collapsedTo"; "required": false; "isSignal": true; }; "scroll": { "alias": "scroll"; "required": false; "isSignal": true; }; "separation": { "alias": "separation"; "required": false; "isSignal": true; }; "modal": { "alias": "modal"; "required": false; "isSignal": true; }; "escape": { "alias": "escape"; "required": false; "isSignal": true; }; "outsidePress": { "alias": "outsidePress"; "required": false; "isSignal": true; }; "back": { "alias": "back"; "required": false; "isSignal": true; }; "closeOnNavigate": { "alias": "closeOnNavigate"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; }, { "navOpen": "navOpenChange"; "asideOpen": "asideOpenChange"; "asideExtent": "asideExtentChange"; "navOpenChangeRequest": "navOpenChangeRequest"; "asideOpenChangeRequest": "asideOpenChangeRequest"; "asideExtentChangeRequest": "asideExtentChangeRequest"; }, never, ["*"], true, never>;
+}
+/**
+ * The `banner` landmark: a `header` in the context of the `body`, so it needs
+ * no `role`.
+ */
+declare class SlAppShellBanner {
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlAppShellBanner, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlAppShellBanner, "header[slAppShellBanner]", ["slAppShellBanner"], {}, {}, never, never, true, never>;
+}
+/** The start cluster of the banner: the toggle, the mark, the name of the workspace. */
+declare class SlAppShellBrand {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlAppShellBrand, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlAppShellBrand, "[slAppShellBrand]", ["slAppShellBrand"], {}, {}, never, never, true, never>;
+}
+/** The middle of the bar, and the one cluster that grows: a search, a trail, a route title. */
+declare class SlAppShellCentre {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlAppShellCentre, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlAppShellCentre, "[slAppShellCentre]", ["slAppShellCentre"], {}, {}, never, never, true, never>;
+}
+/** The end cluster, pushed there by the space it takes. */
+declare class SlAppShellActions {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlAppShellActions, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlAppShellActions, "[slAppShellActions]", ["slAppShellActions"], {}, {}, never, never, true, never>;
+}
+/**
+ * The `navigation` landmark, and the one element all three modes share. A
+ * document with more than one `navigation` needs a unique label on each, so
+ * this one carries the family's unless the consumer wrote another.
+ */
+declare class SlAppShellNav {
+    private readonly shell;
+    private readonly written;
+    private readonly writtenId;
+    protected readonly elementId: string;
+    protected readonly label: _angular_core.Signal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlAppShellNav, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlAppShellNav, "nav[slAppShellNav]", ["slAppShellNav"], {}, {}, never, never, true, never>;
+}
+/**
+ * A strip of marks before the column: the first level of a two-level
+ * navigation, inside the one navigation landmark and under its one open state.
+ * Closed to `rail`, the region keeps this strip and lets the column go.
+ */
+declare class SlAppShellNavRail {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlAppShellNavRail, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlAppShellNavRail, "[slAppShellNavRail]", ["slAppShellNavRail"], {}, {}, never, never, true, never>;
+}
+/** The pinned top of the navigation column. */
+declare class SlAppShellNavHeader {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlAppShellNavHeader, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlAppShellNavHeader, "[slAppShellNavHeader]", ["slAppShellNavHeader"], {}, {}, never, never, true, never>;
+}
+/** The middle, and the only part of the column that scrolls. */
+declare class SlAppShellNavBody {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlAppShellNavBody, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlAppShellNavBody, "[slAppShellNavBody]", ["slAppShellNavBody"], {}, {}, never, never, true, never>;
+}
+/** The pinned bottom: the account, the collapse control. */
+declare class SlAppShellNavFooter {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlAppShellNavFooter, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlAppShellNavFooter, "[slAppShellNavFooter]", ["slAppShellNavFooter"], {}, {}, never, never, true, never>;
+}
+/**
+ * The `main` landmark, and the skip link's destination.
+ *
+ * `tabindex="-1"` is not decoration: a `main` without it takes the scroll and
+ * leaves the focus behind in Safari and in Firefox, so the link appears to work
+ * and moves nothing a screen reader follows.
+ */
+declare class SlAppShellMain {
+    private readonly shell;
+    private readonly writtenId;
+    protected readonly elementId: string;
+    /** The wait on this region's edge; an `aria-busy` the consumer wrote wins. */
+    private readonly writtenBusy;
+    protected readonly busy: _angular_core.Signal<string | null>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlAppShellMain, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlAppShellMain, "main[slAppShellMain]", ["slAppShellMain"], {}, {}, never, never, true, never>;
+}
+/**
+ * The wait for the next page, on the line between the chrome and the content.
+ * The element is the consumer's, anywhere inside the shell: the stylesheet
+ * lays it over `main` in every arrangement as a frame, and it holds one bar
+ * at `edge-start`. Where the line is — the card's border, the banner's seam —
+ * is the stylesheet's to know, not the consumer's.
+ *
+ * `main` is busy for exactly as long as the bar is painted, which the bar
+ * itself reports: not from the moment `loading` turns, because a fast answer
+ * draws nothing, and not after the bar has gone. `size` defaults to `sm`,
+ * `delay` to 200 and `minDuration` to 400 milliseconds; an input, then
+ * `provideProgressIndicatorDefaults()`, wins.
+ */
+declare class SlAppShellProgress {
+    protected readonly shell: SlAppShell;
+    protected readonly defaults: _slotted_angular_progress_indicator.ProgressIndicatorDefaults;
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly value: _angular_core.InputSignal<number | null | undefined>;
+    readonly min: _angular_core.InputSignal<number | undefined>;
+    readonly max: _angular_core.InputSignal<number | undefined>;
+    readonly buffer: _angular_core.InputSignal<number | null | undefined>;
+    readonly valueText: _angular_core.InputSignal<string | undefined>;
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    readonly tone: _angular_core.InputSignal<ProgressTone | undefined>;
+    readonly size: _angular_core.InputSignal<ProgressSize | undefined>;
+    readonly delay: _angular_core.InputSignal<number | undefined>;
+    readonly minDuration: _angular_core.InputSignal<number | undefined>;
+    /** The bar was painted and has been withdrawn. */
+    readonly withdraw: _angular_core.OutputEmitterRef<void>;
+    private readonly bar;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlAppShellProgress, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlAppShellProgress, "[slAppShellProgress]", ["slAppShellProgress"], { "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "buffer": { "alias": "buffer"; "required": false; "isSignal": true; }; "valueText": { "alias": "valueText"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "delay": { "alias": "delay"; "required": false; "isSignal": true; }; "minDuration": { "alias": "minDuration"; "required": false; "isSignal": true; }; }, { "withdraw": "withdraw"; }, never, never, true, never>;
+}
+/**
+ * The `complementary` landmark. It opens and closes the way the navigation
+ * region does — a column beside the content or a layer over it, by
+ * `asideMode` — and carries its own `data-open`, because the host's is the
+ * navigation's and every selector written over it still reads the navigation.
+ */
+declare class SlAppShellAside {
+    protected readonly shell: SlAppShell;
+    private readonly written;
+    private readonly writtenId;
+    protected readonly elementId: string;
+    protected readonly label: _angular_core.Signal<string>;
+    protected readonly extentLength: _angular_core.Signal<string | null>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlAppShellAside, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlAppShellAside, "aside[slAppShellAside]", ["slAppShellAside"], {}, {}, never, never, true, never>;
+}
+/** The pinned top of the pane: its title, and the control that closes it. */
+declare class SlAppShellAsideHeader {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlAppShellAsideHeader, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlAppShellAsideHeader, "[slAppShellAsideHeader]", ["slAppShellAsideHeader"], {}, {}, never, never, true, never>;
+}
+/**
+ * The middle, and the only part of the pane that scrolls. It stands on the
+ * pane's inset; `inset="none"` drops it for content that brings its own.
+ */
+declare class SlAppShellAsideBody {
+    /** `none` drops the body's own padding, for content that brings its own inset. */
+    readonly inset: _angular_core.InputSignal<"none" | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlAppShellAsideBody, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlAppShellAsideBody, "[slAppShellAsideBody]", ["slAppShellAsideBody"], { "inset": { "alias": "inset"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * The pane's inner edge, from the WAI-ARIA Window Splitter pattern: a focusable
+ * `separator` whose three values are the extent as whole percentages of the
+ * shell. **Rendering it is the capability**; there is no `resizable` input.
+ *
+ * It moves the column alone. Under `asideMode="overlay"` the layer keeps its
+ * size step and a closed pane has nothing to resize, so the element is
+ * `hidden` there; below the breakpoint the stylesheet hides it, because a row
+ * under the content has no inline edge.
+ *
+ * The arrows are physical, the pattern's own reading: `ArrowLeft` grows an end
+ * pane in a left-to-right document, and shrinks it where `navSide="end"` or a
+ * mirrored line puts the pane at the start.
+ */
+declare class SlAppShellAsideResizer {
+    protected readonly shell: SlAppShell;
+    private readonly native;
+    private readonly written;
+    /** Where the press began and how far the edge was from the pointer then. */
+    private press;
+    /** What the document looked like before the drag, and how to put it back. */
+    private gesture;
+    /** The pane's measure while the size step decides it, read from the layout. */
+    private readonly rest;
+    protected readonly label: _angular_core.Signal<string>;
+    protected readonly shown: _angular_core.Signal<boolean>;
+    private readonly side;
+    protected readonly current: _angular_core.Signal<number>;
+    constructor();
+    protected percent(value: number): number;
+    private isRtl;
+    private pointAt;
+    protected pointerDown(event: PointerEvent): void;
+    protected pointerMove(event: PointerEvent): void;
+    protected endDrag(event: PointerEvent): void;
+    protected keyDown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlAppShellAsideResizer, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlAppShellAsideResizer, "[slAppShellAsideResizer]", ["slAppShellAsideResizer"], {}, {}, never, never, true, never>;
+}
+/** The pinned bottom: the actions that close the task the pane holds. */
+declare class SlAppShellAsideFooter {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlAppShellAsideFooter, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlAppShellAsideFooter, "[slAppShellAsideFooter]", ["slAppShellAsideFooter"], {}, {}, never, never, true, never>;
+}
+/**
+ * The pane's disclosure control, with the navigation control's wiring: it can
+ * stand in the pane's own header, in the banner's actions, or anywhere else,
+ * and there is still exactly one control carrying the pane's state.
+ */
+declare class SlAppShellAsideToggle {
+    protected readonly shell: SlAppShell;
+    private readonly written;
+    private readonly writtenId;
+    private readonly writtenControls;
+    protected readonly elementId: string;
+    protected readonly controls: string;
+    protected readonly label: _angular_core.Signal<string>;
+    protected press(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlAppShellAsideToggle, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlAppShellAsideToggle, "button[slAppShellAsideToggle]", ["slAppShellAsideToggle"], {}, {}, never, ["*"], true, never>;
+}
+/** The `contentinfo` landmark: the application's footer, not the page's action bar. */
+declare class SlAppShellFooter {
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlAppShellFooter, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlAppShellFooter, "footer[slAppShellFooter]", ["slAppShellFooter"], {}, {}, never, never, true, never>;
+}
+/**
+ * The disclosure control, by the APG's Disclosure pattern: a `button` carrying
+ * `aria-expanded` and `aria-controls`, which `Enter` and `Space` activate
+ * natively. It takes its wiring from the shell rather than from its position,
+ * so it can stand in the banner, in the navigation's own footer, or anywhere
+ * else, and there is still exactly one control carrying the state.
+ */
+declare class SlAppShellNavToggle {
+    protected readonly shell: SlAppShell;
+    private readonly written;
+    private readonly writtenId;
+    private readonly writtenControls;
+    protected readonly elementId: string;
+    protected readonly controls: string;
+    protected readonly label: _angular_core.Signal<string>;
+    protected press(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlAppShellNavToggle, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlAppShellNavToggle, "button[slAppShellNavToggle]", ["slAppShellNavToggle"], {}, {}, never, ["*"], true, never>;
+}
+
+export { APP_SHELL_DEFAULTS, APP_SHELL_OVERLAY_AT, SlAppShell, SlAppShellActions, SlAppShellAside, SlAppShellAsideBody, SlAppShellAsideFooter, SlAppShellAsideHeader, SlAppShellAsideResizer, SlAppShellAsideToggle, SlAppShellBanner, SlAppShellBrand, SlAppShellCentre, SlAppShellFooter, SlAppShellMain, SlAppShellNav, SlAppShellNavBody, SlAppShellNavFooter, SlAppShellNavHeader, SlAppShellNavRail, SlAppShellNavToggle, SlAppShellProgress, injectAppShellDefaults, provideAppShellDefaults };
+export type { AppShellAsideExtentReason, AppShellAsideExtentRequest, AppShellAsideMode, AppShellAsideOpenReason, AppShellCanvas, AppShellCollapsedTo, AppShellDefaults, AppShellDismissPolicy, AppShellNavMode, AppShellNavSide, AppShellOpenReason, AppShellOpenRequest, AppShellPrimary, AppShellScroll, AppShellSeparation, AppShellSize };
+//# sourceMappingURL=slotted-angular-app-shell.d.ts.map

package/types/slotted-angular-app-shell.d.ts.map

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

package/types/slotted-angular-aspect-ratio.d.ts

@@ -0,0 +1,57 @@
+import * as _angular_core from '@angular/core';
+
+/**
+ * The five ratios a product decides once, named for what they hold rather
+ * than for their numbers, so the decision reads in the DOM.
+ */
+type AspectRatioName = 'square' | 'landscape' | 'portrait' | 'video' | 'wide';
+/**
+ * A name, a number (`16 / 9`), or the pair the number came from (`[16, 9]`).
+ * The pair is written into the stylesheet exactly, where a number would be
+ * written as its quotient.
+ */
+type AspectRatioValue = AspectRatioName | number | readonly [number, number];
+/** What the DOM says the ratio is: one of the names, or `custom` for a number. */
+type AspectRatioAttribute = AspectRatioName | 'custom';
+/**
+ * The attribute the stylesheet keys on, and the token the instance writes
+ * when the ratio is a number rather than a name. A pair is written as it was
+ * given, `16 / 9`, so the DOM says what the consumer said; a number is its
+ * own quotient. A name writes no token: the stylesheet holds the five.
+ */
+declare function resolveAspectRatio(ratio: AspectRatioValue): {
+    attribute: AspectRatioAttribute;
+    token: string | null;
+};
+/**
+ * A box that is a stated proportion of its own width before anything is in
+ * it, so a picture, a map or an embedded player arrives into room already
+ * held for it and moves nothing below.
+ *
+ * It is the platform's `aspect-ratio`, not the padding hack, and the
+ * difference is what happens to content taller than the box: the frame keeps
+ * the ratio while the content fits and grows when it does not. Nothing is
+ * clipped and nothing escapes. The frame reserves; the crop is `slImage`'s
+ * decision.
+ *
+ * The component is written on the element the page chose — a `div`, a
+ * `figure`, an `li` — and projects whatever the consumer put in it.
+ */
+declare class SlAspectRatio {
+    /**
+     * The proportion the box holds before anything is in it. Required: the
+     * ratio is the consumer's decision, and a frame that named none is a frame
+     * nobody thought about.
+     */
+    readonly ratio: _angular_core.InputSignal<AspectRatioValue>;
+    protected readonly resolved: _angular_core.Signal<{
+        attribute: AspectRatioAttribute;
+        token: string | null;
+    }>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlAspectRatio, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlAspectRatio, "[slAspectRatio]", ["slAspectRatio"], { "ratio": { "alias": "ratio"; "required": true; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { SlAspectRatio, resolveAspectRatio };
+export type { AspectRatioAttribute, AspectRatioName, AspectRatioValue };
+//# sourceMappingURL=slotted-angular-aspect-ratio.d.ts.map

package/types/slotted-angular-aspect-ratio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-aspect-ratio.d.ts","sources":["../../aspect-ratio/src/aspect-ratio.ts"],"mappings":";;AAQA;;;AAGG;AACG,KAAM,eAAe;AAE3B;;;;AAIG;AACG,KAAM,gBAAgB,GAAG,eAAe;AAE9C;KACY,oBAAoB,GAAG,eAAe;AAIlD;;;;;AAKG;AACH,iBAAgB,kBAAkB,QAAQ,gBAAgB;eAC7C,oBAAoB;AAC/B;;AAYF;;;;;;;;;;;;;AAaG;AACH,cAea,aAAa;AACxB;;;;AAIG;oBACW,aAAA,CAAA,WAAA,CAAA,gBAAA;iCAEa,aAAA,CAAA,MAAA;mBAlDhB,oBAAoB;AACxB;AAiDwE;oDARpE,aAAa;sDAAb,aAAa;AASzB;;","names":[]}