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

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

@@ -0,0 +1,174 @@
+import * as _slotted_core_keys from '@slotted/core/keys';
+import { KbdPlatformInput, KbdPlatform } from '@slotted/core/keys';
+export { KbdPlatform, KbdPlatformInput } from '@slotted/core/keys';
+import * as _angular_core from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { PartialMessages, KeysMessages } from '@slotted/core/i18n';
+
+/**
+ * Four absolute heights — 16, 20, 24 and 28 pixels — and one that reads the text
+ * around it. `inherit` is the step prose wants: an absolute cap inside a heading
+ * is a stamp, and one in fine print is a slab.
+ */
+type KbdSize = 'xs' | 'sm' | 'md' | 'lg' | 'inherit';
+/**
+ * `raised` is the only value that looks like a key. `outline` owns no ground,
+ * so it carries over any surface. `soft` is the tinted chip. `plain` is the
+ * menu-row form, and it takes the colour of the text it sits in.
+ */
+type KbdVariant = 'raised' | 'outline' | 'soft' | 'plain';
+interface KbdDefaults {
+    /**
+     * `auto` asks the runtime. State it instead where the page is rendered on a
+     * server: nothing is detected then, and the first paint is already right.
+     */
+    platform: KbdPlatformInput;
+    size: KbdSize;
+    variant: KbdVariant;
+    /** Between two simultaneous keys. A Mac joins with nothing whatever this says. */
+    separator: string;
+    /** Replaces what the eye sees, per key token: `{ ctrl: 'Strg' }`. */
+    legends: Readonly<Record<string, string>> | undefined;
+    /** Replaces what a reader hears, per key token: `{ ctrl: 'Steuerung' }`. */
+    names: Readonly<Record<string, string>> | undefined;
+}
+declare const KBD_DEFAULTS: InjectionToken<KbdDefaults>;
+/**
+ * An application decides once which platform its shortcuts are written for, how
+ * its keys are painted, and which legends and names it writes in place of the
+ * catalog's for particular keys. A key that states any of them itself still
+ * wins: an explicit input is never overridden by the token. The words come from
+ * the `keys` catalog of the language in force (`provideSlotted`).
+ */
+declare function provideKbdDefaults(defaults: Partial<KbdDefaults>): {
+    provide: InjectionToken<KbdDefaults>;
+    useFactory: () => KbdDefaults;
+};
+/** What a key renders as here, before it states anything of its own. */
+declare function injectKbdDefaults(): KbdDefaults;
+/**
+ * The reader's platform, resolved synchronously in the browser and never on the
+ * server.
+ *
+ * The asymmetry with the React binding is deliberate and is the one worth
+ * recording. React has `useSyncExternalStore`, which distinguishes a hydrating
+ * render from a plain client one, so it can be right on the first paint of a
+ * client-rendered page *and* free of hydration mismatches on a server-rendered
+ * one. Angular exposes no equivalent, so the choice is between a flash on every
+ * page and a mismatch on hydrated ones. This binding takes neither: it resolves
+ * at once in the browser, which is right for the client-rendered application,
+ * and an application that server-renders states `platform` through
+ * `provideKbdDefaults` — at which point nothing is detected at all.
+ *
+ * A development-mode warning is what stops that requirement from being
+ * discovered by a reader seeing `Ctrl` on their Mac.
+ */
+declare function injectKbdPlatform(): (stated?: KbdPlatformInput) => KbdPlatform;
+
+/**
+ * One key of a keyboard, drawn so a reader can find it on theirs.
+ *
+ * The directive is written on the consumer's own `<kbd>`, which is the element
+ * the HTML Standard defines for exactly this and the reason this binding needs
+ * no `render` prop: substituting the element is Angular's default.
+ *
+ * It is not a control: nothing here is focusable, nothing answers hover, and
+ * nothing binds a shortcut. Registering one is the application's, because WCAG
+ * 2.2 2.1.4 Character Key Shortcuts can only be answered by whoever knows
+ * whether the shortcut can be turned off.
+ */
+declare class SlKbd {
+    /**
+     * A token from the vocabulary — `mod`, `meta`, `shift`, `escape`, `up` — or
+     * any of its aliases. It resolves to the legend the reader's platform draws
+     * and the word a screen reader hears in place of it.
+     */
+    readonly keyName: _angular_core.InputSignal<string | undefined>;
+    /** Defaults to the combination, then to the provider, then to `auto`. */
+    readonly platform: _angular_core.InputSignal<KbdPlatformInput | undefined>;
+    /** Defaults to the combination, then to the provider, then to `md`. */
+    readonly size: _angular_core.InputSignal<KbdSize | undefined>;
+    /** Defaults to the combination, then to the provider, then to `raised`. */
+    readonly variant: _angular_core.InputSignal<KbdVariant | undefined>;
+    /**
+     * Dims the key without claiming the item's semantics. `kbd` may carry only
+     * the global ARIA attributes, and `aria-disabled` is not one of them, so the
+     * row this key belongs to is what says it is unavailable.
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
+    /**
+     * Words laid over the `keys` catalog of the language in force, key by key:
+     * `legends.*` for what a cap shows, `names.*` for what a reader hears.
+     */
+    readonly messages: _angular_core.InputSignal<PartialMessages<KeysMessages> | undefined>;
+    private readonly defaults;
+    private readonly platformOf;
+    private readonly t;
+    /**
+     * The combination this key sits in, when it sits in one. It is optional, so a
+     * key written on its own works, and a key written by hand inside a `Shortcut`
+     * is painted like the combination around it without repeating four inputs.
+     */
+    private readonly group;
+    protected readonly resolvedPlatform: _angular_core.Signal<_slotted_core_keys.KbdPlatform>;
+    protected readonly resolvedSize: _angular_core.Signal<KbdSize>;
+    protected readonly resolvedVariant: _angular_core.Signal<KbdVariant>;
+    protected readonly resolvedDisabled: _angular_core.Signal<boolean>;
+    protected readonly key: _angular_core.Signal<_slotted_core_keys.ResolvedKey | undefined>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlKbd, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlKbd, "kbd[slKbd]", ["slKbd"], { "keyName": { "alias": "keyName"; "required": false; "isSignal": true; }; "platform": { "alias": "platform"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * A whole key combination, and the element the HTML Standard says it is:
+ * “nesting a `kbd` element within another `kbd` element represents an actual key
+ * or other unit of input as a portion of a larger input”. shadcn's `KbdGroup` is
+ * a `div`, and Chakra and Radix put the whole combination inside one `kbd` as
+ * text; this is the markup the specification describes.
+ *
+ * `keys` is written once and rendered for the reader's platform. The modifiers
+ * are reordered into that platform's own convention — the Apple Style Guide
+ * writes Fn, Control, Option, Shift, Command, and Microsoft writes the Windows
+ * key ahead of Ctrl, Alt and Shift — so one authored string is right on both.
+ * The escape hatch is composition rather than a fifth input: keys projected into
+ * this element are rendered exactly as written.
+ */
+declare class SlShortcut {
+    /**
+     * The shortcut, written once: `+` joins keys pressed together and whitespace
+     * joins the steps of a sequence.
+     */
+    readonly keys: _angular_core.InputSignal<string | undefined>;
+    /** Defaults to the provider, then to `auto`. */
+    readonly platform: _angular_core.InputSignal<KbdPlatformInput | undefined>;
+    /** Defaults to the provider, then to `md`. */
+    readonly size: _angular_core.InputSignal<KbdSize | undefined>;
+    /** Defaults to the provider, then to `raised`. */
+    readonly variant: _angular_core.InputSignal<KbdVariant | undefined>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
+    /** Between two simultaneous keys. Defaults to the provider, then to `+`. */
+    readonly separator: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Words laid over the `keys` catalog of the language in force, key by key:
+     * `legends.*`, `names.*`, and `then` between two steps of a sequence.
+     */
+    readonly messages: _angular_core.InputSignal<PartialMessages<KeysMessages> | undefined>;
+    /** Replaces what the eye sees, per key token. Defaults to the provider. */
+    readonly legends: _angular_core.InputSignal<Readonly<Record<string, string>> | undefined>;
+    /** Replaces what a reader hears, per key token. Defaults to the provider. */
+    readonly names: _angular_core.InputSignal<Readonly<Record<string, string>> | undefined>;
+    private readonly defaults;
+    private readonly platformOf;
+    private readonly t;
+    protected readonly resolvedPlatform: _angular_core.Signal<_slotted_core_keys.KbdPlatform>;
+    protected readonly resolvedSize: _angular_core.Signal<KbdSize>;
+    protected readonly resolvedVariant: _angular_core.Signal<KbdVariant>;
+    protected readonly resolved: _angular_core.Signal<_slotted_core_keys.ResolvedShortcut | undefined>;
+    protected readonly empty: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlShortcut, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlShortcut, "kbd[slShortcut]", ["slShortcut"], { "keys": { "alias": "keys"; "required": false; "isSignal": true; }; "platform": { "alias": "platform"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "separator": { "alias": "separator"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; "legends": { "alias": "legends"; "required": false; "isSignal": true; }; "names": { "alias": "names"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { KBD_DEFAULTS, SlKbd, SlShortcut, injectKbdDefaults, injectKbdPlatform, provideKbdDefaults };
+export type { KbdDefaults, KbdSize, KbdVariant };
+//# sourceMappingURL=slotted-angular-kbd.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-kbd.d.ts","sources":["../../kbd/src/kbd-defaults.ts","../../kbd/src/kbd.ts","../../kbd/src/shortcut.ts"],"mappings":";;;;;;;AAQA;;;;AAIG;AACG,KAAM,OAAO;AAEnB;;;;AAIG;AACG,KAAM,UAAU;UAEL,WAAW;AAC1B;;;AAGG;cACO,gBAAgB;UACpB,OAAO;aACJ,UAAU;;;;AAInB,aAAS,QAAQ,CAAC,MAAM;;AAExB,WAAO,QAAQ,CAAC,MAAM;AACvB;AAWD,cAAa,YAAY,EAAA,cAAA,CAAA,WAAA;AAKzB;;;;;;AAMG;AACH,iBAAgB,kBAAkB,WAAW,OAAO,CAAC,WAAW;;sBAG5C,WAAW;AAS9B;AAED;AACA,iBAAgB,iBAAiB,IAAI,WAAW;AAIhD;;;;;;;;;;;;;;;;AAgBG;AACH,iBAAgB,iBAAiB,cAAc,gBAAgB,KAAK,WAAW;;AC9E/E;;;;;;;;;;;AAWG;AACH,cA6Ba,KAAK;AAChB;;;;AAIG;sBACa,aAAA,CAAA,WAAA;;uBAEC,aAAA,CAAA,WAAA,CAAA,gBAAA;;mBAEJ,aAAA,CAAA,WAAA,CAAA,OAAA;;sBAEG,aAAA,CAAA,WAAA,CAAA,UAAA;AAChB;;;;AAIG;uBACc,aAAA,CAAA,wBAAA;AACjB;;;AAGG;uBACc,aAAA,CAAA,WAAA,CAAA,eAAA,CAAA,YAAA;AAEjB;AACA;AACA;AACA;;;;AAIG;AACH;AAEA,yCAAmC,aAAA,CAAA,MAAA,CAAA,kBAAA,CAAA,WAAA;AAGnC,qCAA+B,aAAA,CAAA,MAAA,CAAA,OAAA;AAG/B,wCAAkC,aAAA,CAAA,MAAA,CAAA,UAAA;AAGlC,yCAAmC,aAAA,CAAA,MAAA;AAInC,4BAAsB,aAAA,CAAA,MAAA,CAAA,kBAAA,CAAA,WAAA;oDAhDX,KAAK;sDAAL,KAAK;AA0DjB;;AClGD;;;;;;;;;;;;;AAaG;AACH,cA4Ca,UAAU;AACrB;;;AAGG;mBACU,aAAA,CAAA,WAAA;;uBAEI,aAAA,CAAA,WAAA,CAAA,gBAAA;;mBAEJ,aAAA,CAAA,WAAA,CAAA,OAAA;;sBAEG,aAAA,CAAA,WAAA,CAAA,UAAA;uBACC,aAAA,CAAA,wBAAA;;wBAEC,aAAA,CAAA,WAAA;AAClB;;;AAGG;uBACc,aAAA,CAAA,WAAA,CAAA,eAAA,CAAA,YAAA;;sBAED,aAAA,CAAA,WAAA,CAAA,QAAA,CAAA,MAAA;;oBAEF,aAAA,CAAA,WAAA,CAAA,QAAA,CAAA,MAAA;AAEd;AACA;AACA;AAEA,yCAAmC,aAAA,CAAA,MAAA,CAAA,kBAAA,CAAA,WAAA;AACnC,qCAA+B,aAAA,CAAA,MAAA,CAAA,OAAA;AAC/B,wCAAkC,aAAA,CAAA,MAAA,CAAA,UAAA;AAElC,iCAA2B,aAAA,CAAA,MAAA,CAAA,kBAAA,CAAA,gBAAA;AAY3B,8BAAwB,aAAA,CAAA,MAAA;oDA7Cb,UAAU;sDAAV,UAAU;AA8CtB;;","names":[]}

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

@@ -0,0 +1,94 @@
+import * as _slotted_core_i18n from '@slotted/core/i18n';
+import { PartialMessages, LinkMessages } from '@slotted/core/i18n';
+import * as _angular_core from '@angular/core';
+import { InjectionToken } from '@angular/core';
+
+type LinkUnderline = 'always' | 'hover' | 'none';
+type LinkVariant = 'accent' | 'neutral' | 'inverse';
+
+/**
+ * Text that goes somewhere. The directive sits on the consumer's own anchor,
+ * so the role, `Enter`, the context menu, the middle click and every modified
+ * click are the platform's — and `routerLink` composes on the same element,
+ * because the element was never the family's to begin with. `button` owns the
+ * action that has no URL, and `ButtonLink` the navigation that wants the
+ * action surface.
+ *
+ * `rel` and `target` are written imperatively rather than through host
+ * bindings, and only when the anchor carries neither. A host binding writes on
+ * every change detection pass, and the value that means "leave it alone" is
+ * `null`, which removes the attribute — so an anchor whose consumer binds
+ * `[attr.target]` itself would lose it to this component. Adding what is
+ * missing and touching nothing else is the only shape that keeps the
+ * consumer's explicit value winning.
+ */
+declare class SlLink {
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly external: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Words laid over the catalog of the language in force: the warning a link
+     * to a new tab announces (`externalHint`).
+     */
+    readonly messages: _angular_core.InputSignal<PartialMessages<LinkMessages> | undefined>;
+    readonly underline: _angular_core.InputSignal<LinkUnderline | undefined>;
+    readonly variant: _angular_core.InputSignal<LinkVariant | undefined>;
+    readonly visited: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    private readonly defaults;
+    /** The family's words in the language in force, with this link's `messages` laid over them. */
+    readonly t: _slotted_core_i18n.FamilyTranslator<LinkMessages>;
+    private readonly element;
+    private readonly renderer;
+    /**
+     * What the consumer wrote on their own anchor, read once through the token
+     * that exists for exactly this: a static attribute has to survive the
+     * component that was placed on top of it.
+     */
+    private readonly ownRel;
+    private readonly ownTarget;
+    private readonly ownTabIndex;
+    /** The destination the anchor had before it was made unavailable. */
+    private withheldHref;
+    readonly underlineValue: _angular_core.Signal<LinkUnderline>;
+    readonly variantValue: _angular_core.Signal<LinkVariant>;
+    readonly visitedValue: _angular_core.Signal<boolean>;
+    /**
+     * The fact, not the prop. `external` is the way to state it, and an anchor
+     * the consumer already pointed at a new tab has stated the same thing.
+     */
+    readonly newTab: _angular_core.Signal<boolean>;
+    readonly hint: _angular_core.Signal<string>;
+    /**
+     * A disabled link keeps its place in the tab sequence: without an `href` the
+     * anchor would drop out of it, so the zero is stated rather than inherited.
+     */
+    readonly tabIndex: _angular_core.Signal<string | null>;
+    constructor();
+    /** Adds what the anchor is missing, and removes only what it added. */
+    private write;
+    private refuse;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlLink, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlLink, "a[slLink]", ["slLink"], { "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "external": { "alias": "external"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; "underline": { "alias": "underline"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "visited": { "alias": "visited"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/** What every link on the page looks like before it states anything of its own. */
+interface LinkDefaults {
+    underline?: LinkUnderline;
+    variant?: LinkVariant;
+    visited?: boolean;
+}
+declare const LINK_DEFAULTS_TOKEN: InjectionToken<LinkDefaults>;
+/**
+ * An application decides once whether its links are underlined, how they are
+ * painted, and whether a followed destination is marked. A link that states
+ * any of those itself still wins: an explicit input is never overridden by the
+ * token. Its words come from the language in force (`provideSlotted`).
+ */
+declare function provideLinkDefaults(defaults: LinkDefaults): {
+    provide: InjectionToken<LinkDefaults>;
+    useValue: LinkDefaults;
+};
+declare function injectLinkDefaults(): LinkDefaults;
+
+export { LINK_DEFAULTS_TOKEN, SlLink, injectLinkDefaults, provideLinkDefaults };
+export type { LinkDefaults, LinkUnderline, LinkVariant };
+//# sourceMappingURL=slotted-angular-link.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-link.d.ts","sources":["../../link/src/link.constants.ts","../../link/src/link.ts","../../link/src/link-defaults.ts"],"mappings":";;;;;AAAM,KAAM,aAAa;AACnB,KAAM,WAAW;;ACyBvB;;;;;;;;;;;;;;;AAeG;AACH,cAmCa,MAAM;uBACA,aAAA,CAAA,wBAAA;uBACA,aAAA,CAAA,wBAAA;AACjB;;;AAGG;uBACc,aAAA,CAAA,WAAA,CAAA,eAAA,CAAA,YAAA;wBACC,aAAA,CAAA,WAAA,CAAA,aAAA;sBACF,aAAA,CAAA,WAAA,CAAA,WAAA;sBACA,aAAA,CAAA,wBAAA;AAIhB;;gBAEU,kBAAA,CAAA,gBAAA,CAAA,YAAA;AACV;AACA;AAEA;;;;AAIG;AACH;AACA;AACA;;;6BAKuB,aAAA,CAAA,MAAA,CAAA,aAAA;2BAGF,aAAA,CAAA,MAAA,CAAA,WAAA;2BAGA,aAAA,CAAA,MAAA;AAErB;;;AAGG;qBACY,aAAA,CAAA,MAAA;mBACF,aAAA,CAAA,MAAA;AAEb;;;AAGG;uBACc,aAAA,CAAA,MAAA;;;AA4CjB;AASA;oDAxGW,MAAM;sDAAN,MAAM;AA8GlB;;ACvLD;UACiB,YAAY;gBACf,aAAa;cACf,WAAW;;AAEtB;AAED,cAAa,mBAAmB,EAAA,cAAA,CAAA,YAAA;AAKhC;;;;;AAKG;AACH,iBAAgB,mBAAmB,WAAW,YAAY;;;AAEzD;AAED,iBAAgB,kBAAkB,IAAI,YAAY;;","names":[]}

package/types/slotted-angular-list-item.d.ts

@@ -0,0 +1,210 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { ListVariant, ListMarker } from '@slotted/angular/list';
+
+/** The five the theme carries. `secondary` is the library's neutral. */
+type ListItemTone = 'secondary' | 'accent' | 'success' | 'warning' | 'danger';
+/** The room the row gets. Density is the application's choice; this is not. */
+type ListItemSize = 'sm' | 'md' | 'lg';
+/**
+ * Where the leading visual and the trailing metadata sit against a row of more
+ * than one line: on the middle of the block, or on the title's own line.
+ */
+type ListItemAlign = 'center' | 'start';
+/**
+ * What the row is the current one *of*. ARIA 1.2 lists `aria-current` as
+ * inherited by `listitem` and does not deprecate it, which makes this the one
+ * selection-shaped state a static list may announce for itself.
+ */
+type ListItemCurrent = boolean | 'page' | 'step' | 'location' | 'date' | 'time';
+interface ListItemDefaults {
+    align: ListItemAlign;
+    inset: boolean;
+    size: ListItemSize;
+    tone: ListItemTone;
+    truncate: boolean;
+}
+declare const LIST_ITEM_DEFAULTS: InjectionToken<ListItemDefaults>;
+/**
+ * An application decides once how its rows are aligned, how far they are inset
+ * and whether a title the row cannot grow for is clipped. A row that states any
+ * of them itself still wins, and so does the list between the two.
+ */
+declare function provideListItemDefaults(defaults: Partial<ListItemDefaults>): {
+    provide: InjectionToken<ListItemDefaults>;
+    useFactory: () => ListItemDefaults;
+};
+/** What a row renders as here, before the list or the row states anything. */
+declare function injectListItemDefaults(): ListItemDefaults;
+
+/**
+ * One entry of a `slList`: the `li`, and every state the row paints. The box
+ * that is read, hovered, focused and sometimes activated is `slListItemContent`
+ * on the element the page chose, and `slListItemActions` is that box's sibling
+ * — interactive content may not nest inside `a` or `button`.
+ *
+ * Four values come from the list when the row does not state them: `variant`,
+ * `size`, `marker` and `inset`. Everything else is a fact about this row.
+ *
+ * **No state attribute the roles model forbids reaches the `li`.** ARIA 1.2
+ * deprecates `aria-disabled` on `listitem`, so `disabled` is painted from
+ * `data-disabled` and the attribute that means it is written on the box.
+ * `aria-current` is inherited by the role and is not deprecated, so `current`
+ * is announced here.
+ */
+declare class SlListItem {
+    /** How the rows are told apart. Falls back to the list, then to `plain`. */
+    readonly variant: _angular_core.InputSignal<ListVariant | undefined>;
+    /** The room the row gets. Falls back to the list, then the token, then `md`. */
+    readonly size: _angular_core.InputSignal<ListItemSize | undefined>;
+    /** What is painted in the marker column. Falls back to the list, then `none`. */
+    readonly marker: _angular_core.InputSignal<ListMarker | undefined>;
+    /** Where the leading visual sits against a row of more than one line. */
+    readonly align: _angular_core.InputSignal<ListItemAlign | undefined>;
+    /** The row's ink and the wash under the pointer. Falls back to `secondary`. */
+    readonly tone: _angular_core.InputSignal<ListItemTone | undefined>;
+    /** Takes the row's inline padding away. Falls back to the list, then the token. */
+    readonly inset: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /** Clips the title and the lines under it to one line each. The string stays. */
+    readonly truncate: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /**
+     * Mirrors a selection the page owns. `aria-selected` is not valid on
+     * `listitem`, so the row paints it and the control the page puts in
+     * `slListItemStart` — a `slCheckbox` — is what announces it.
+     */
+    readonly selected: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * The row the reader is on. `true` writes `aria-current="true"`; a token
+     * writes that token, and `page` is what a navigation list wants.
+     */
+    readonly current: _angular_core.InputSignal<ListItemCurrent>;
+    /**
+     * The row dims and stops answering the pointer. The attribute that means it
+     * goes on the box inside and never on this `li`, which ARIA 1.2 forbids.
+     */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * `aria-busy` on the box, and the activation withdrawn so the command cannot
+     * run twice. The row keeps its width and its accessible name; what stands in
+     * for the content is `slSkeleton`, composed by the page.
+     */
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * The row's place in a set only part of which is in the document — a page of
+     * results, a filtered list. ARIA 1.2 is explicit that it is unnecessary while
+     * every row is present, so it is written only when stated.
+     */
+    readonly position: _angular_core.InputSignal<number | undefined>;
+    /** How many rows the set holds, when only part of it is in the document. */
+    readonly setSize: _angular_core.InputSignal<number | undefined>;
+    private readonly defaults;
+    private readonly list;
+    /** An `aria-current` the consumer wrote is never replaced by the family's. */
+    private readonly writtenCurrent;
+    readonly resolvedVariant: _angular_core.Signal<ListVariant>;
+    readonly resolvedSize: _angular_core.Signal<ListItemSize>;
+    readonly resolvedMarker: _angular_core.Signal<ListMarker>;
+    readonly resolvedAlign: _angular_core.Signal<ListItemAlign>;
+    readonly resolvedTone: _angular_core.Signal<ListItemTone>;
+    readonly resolvedInset: _angular_core.Signal<boolean>;
+    readonly resolvedTruncate: _angular_core.Signal<boolean>;
+    /** The two states the box inside has to answer, and the only pair it reads. */
+    readonly blocked: _angular_core.Signal<boolean>;
+    constructor();
+    protected readonly ariaCurrent: _angular_core.Signal<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlListItem, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlListItem, "li[slListItem]", ["slListItem"], { "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "marker": { "alias": "marker"; "required": false; "isSignal": true; }; "align": { "alias": "align"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "inset": { "alias": "inset"; "required": false; "isSignal": true; }; "truncate": { "alias": "truncate"; "required": false; "isSignal": true; }; "selected": { "alias": "selected"; "required": false; "isSignal": true; }; "current": { "alias": "current"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "setSize": { "alias": "setSize"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * The box that is read, and sometimes activated. One directive on the element
+ * the page wrote, which is what this ecosystem composes with: `<a
+ * slListItemContent [routerLink]>` is a real destination and `<button
+ * slListItemContent>` a real command, and the router link, the form ownership
+ * and the modified click a browser gives an anchor all stay the page's.
+ *
+ * React exports three components instead, because there the component owns the
+ * tag and a string that picked between three accessibility trees would turn a
+ * typo into a `div` no reader can reach. Both bindings reach the same tree.
+ *
+ * How an interaction is refused depends on the element, because the platform
+ * gives each element a different way to say so:
+ *
+ * - a `button` takes the native `disabled`, which removes it from the tab order
+ *   and stops the activation at the platform;
+ * - an `a` takes `aria-disabled="true"` and keeps its destination, because that
+ *   attribute means perceivable but not operable and leaves the element
+ *   focusable — a reader can still reach the row and hear why it is
+ *   unavailable. The activation is refused by `SlListItem`, which is also the
+ *   only place the refusal can be made to run first;
+ * - anything else takes neither, and any control the page put in
+ *   `slListItemActions` is the page's own to disable.
+ */
+declare class SlListItemContent {
+    private readonly row;
+    private readonly tag;
+    readonly loading: _angular_core.Signal<boolean>;
+    private readonly blocked;
+    protected readonly nativeDisabled: _angular_core.Signal<"" | null>;
+    protected readonly ariaDisabled: _angular_core.Signal<"true" | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlListItemContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlListItemContent, "[slListItemContent]", ["slListItemContent"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * The leading column: an icon, an avatar, a `slCheckbox`. The column is the
+ * control glyph's own width, so whatever stands in it lands on the same line as
+ * every other row's.
+ *
+ * It is the slot and not the control. A row that drew its own check would be a
+ * second answer to the question `checkbox` already owns, and a chooser here is
+ * also what announces a selection the row only paints.
+ */
+declare class SlListItemStart {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlListItemStart, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlListItemStart, "[slListItemStart]", ["slListItemStart"], {}, {}, never, never, true, never>;
+}
+/** The text column, and the one box in the row that may shrink. */
+declare class SlListItemBody {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlListItemBody, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlListItemBody, "[slListItemBody]", ["slListItemBody"], {}, {}, never, never, true, never>;
+}
+/**
+ * The title. It clips under `truncate`, isolates its own direction so a title
+ * in another script leaves the row around it alone, and breaks a single
+ * unbroken token — a URL, a commit hash — rather than pushing the metadata out.
+ */
+declare class SlListItemLabel {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlListItemLabel, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlListItemLabel, "[slListItemLabel]", ["slListItemLabel"], {}, {}, never, never, true, never>;
+}
+/** The lines under the title. They clip with it, never instead of it. */
+declare class SlListItemDescription {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlListItemDescription, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlListItemDescription, "[slListItemDescription]", ["slListItemDescription"], {}, {}, never, never, true, never>;
+}
+/**
+ * Trailing metadata that is part of what the row says — a timestamp, a count, a
+ * `slBadge`. It is inside the box, so it is part of the row's own name for a
+ * reader and part of its target for a pointer. Anything that acts is
+ * `slListItemActions`.
+ */
+declare class SlListItemEnd {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlListItemEnd, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlListItemEnd, "[slListItemEnd]", ["slListItemEnd"], {}, {}, never, never, true, never>;
+}
+/**
+ * Independent targets, and a **sibling** of the box rather than its child.
+ * Interactive content may not nest inside `a` or `button`, so a row that
+ * navigates and also deletes has to put its two controls side by side. Every
+ * surveyed implementation lets a consumer nest them instead and produces HTML
+ * no browser can make focusable.
+ */
+declare class SlListItemActions {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlListItemActions, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlListItemActions, "[slListItemActions]", ["slListItemActions"], {}, {}, never, never, true, never>;
+}
+
+export { LIST_ITEM_DEFAULTS, SlListItem, SlListItemActions, SlListItemBody, SlListItemContent, SlListItemDescription, SlListItemEnd, SlListItemLabel, SlListItemStart, injectListItemDefaults, provideListItemDefaults };
+export type { ListItemAlign, ListItemCurrent, ListItemDefaults, ListItemSize, ListItemTone };
+//# sourceMappingURL=slotted-angular-list-item.d.ts.map

package/types/slotted-angular-list-item.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-list-item.d.ts","sources":["../../list-item/src/list-item-defaults.ts","../../list-item/src/list-item.ts","../../list-item/src/list-item-content.ts","../../list-item/src/list-item-parts.ts"],"mappings":";;;;AAEA;AACM,KAAM,YAAY;AAExB;AACM,KAAM,YAAY;AAExB;;;AAGG;KACS,aAAa;AAEzB;;;;AAIG;AACG,KAAM,eAAe;UAEV,gBAAgB;WACxB,aAAa;;UAEd,YAAY;UACZ,YAAY;;AAEnB;AAUD,cAAa,kBAAkB,EAAA,cAAA,CAAA,gBAAA;AAK/B;;;;AAIG;AACH,iBAAgB,uBAAuB,WAAW,OAAO,CAAC,gBAAgB;;sBAGtD,gBAAgB;AAQnC;AAED;AACA,iBAAgB,sBAAsB,IAAI,gBAAgB;;AC9B1D;;;;;;;;;;;;;;AAcG;AACH,cAoCa,UAAU;;sBAEL,aAAA,CAAA,WAAA,CAAA,WAAA;;mBAEH,aAAA,CAAA,WAAA,CAAA,YAAA;;qBAEE,aAAA,CAAA,WAAA,CAAA,UAAA;;oBAED,aAAA,CAAA,WAAA,CAAA,aAAA;;mBAED,aAAA,CAAA,WAAA,CAAA,YAAA;;oBAEC,aAAA,CAAA,wBAAA;;uBAIG,aAAA,CAAA,wBAAA;AAGjB;;;;AAIG;uBACc,aAAA,CAAA,wBAAA;AACjB;;;AAGG;sBACa,aAAA,CAAA,WAAA,CAAA,eAAA;AAChB;;;AAGG;uBACc,aAAA,CAAA,wBAAA;AACjB;;;;AAIG;sBACa,aAAA,CAAA,wBAAA;AAChB;;;;AAIG;uBACc,aAAA,CAAA,WAAA;;sBAED,aAAA,CAAA,WAAA;AAEhB;AACA;;AAEA;8BAIwB,aAAA,CAAA,MAAA,CAAA,WAAA;2BAGH,aAAA,CAAA,MAAA,CAAA,YAAA;6BAGE,aAAA,CAAA,MAAA,CAAA,UAAA;4BACD,aAAA,CAAA,MAAA,CAAA,aAAA;2BACD,aAAA,CAAA,MAAA,CAAA,YAAA;4BACC,aAAA,CAAA,MAAA;+BAGG,aAAA,CAAA,MAAA;;sBAGT,aAAA,CAAA,MAAA;;AAkChB,oCAA8B,aAAA,CAAA,MAAA;oDA1GnB,UAAU;sDAAV,UAAU;AAgHtB;;AC9LD;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AACH,cAWa,iBAAiB;AAC5B;AACA;sBAEgB,aAAA,CAAA,MAAA;AAEhB;AAEA,uCAAiC,aAAA,CAAA,MAAA;AAIjC,qCAA+B,aAAA,CAAA,MAAA;oDAZpB,iBAAiB;sDAAjB,iBAAiB;AAe7B;;ACpDD;;;;;;;;AAQG;AACH,cAMa,eAAe;oDAAf,eAAe;sDAAf,eAAe;AAAG;AAE/B;AACA,cAMa,cAAc;oDAAd,cAAc;sDAAd,cAAc;AAAG;AAE9B;;;;AAIG;AACH,cAMa,eAAe;oDAAf,eAAe;sDAAf,eAAe;AAAG;AAE/B;AACA,cAMa,qBAAqB;oDAArB,qBAAqB;sDAArB,qBAAqB;AAAG;AAErC;;;;;AAKG;AACH,cAMa,aAAa;oDAAb,aAAa;sDAAb,aAAa;AAAG;AAE7B;;;;;;AAMG;AACH,cAMa,iBAAiB;oDAAjB,iBAAiB;sDAAjB,iBAAiB;AAAG;;","names":[]}