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

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

@@ -0,0 +1,294 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { GlyphName } from '@slotted/core/glyph';
+import { ChangeReason } from '@slotted/core/state';
+import * as _slotted_core_upload from '@slotted/core/upload';
+import { FileKind } from '@slotted/core/upload';
+import * as _slotted_core_i18n from '@slotted/core/i18n';
+import { PartialMessages, AttachmentMessages } from '@slotted/core/i18n';
+
+type AttachmentSize = 'sm' | 'md' | 'lg';
+type AttachmentOrientation = 'horizontal' | 'vertical';
+type AttachmentLayout = 'list' | 'grid' | 'strip';
+/**
+ * What the family needs to know about a file, and a `File` already is one. A
+ * record from a server needs only the name: the kind is read from the media
+ * type when there is one and from the extension when there is not.
+ */
+interface AttachmentFile {
+    readonly name: string;
+    readonly type?: string | undefined;
+    readonly size?: number | undefined;
+}
+/** How the removal was asked for: the remove control, or `Backspace` / `Delete`. */
+type AttachmentRemoveReason = Extract<ChangeReason, 'remove' | 'keyboard'>;
+/** A request to leave the consumer's list. It carries no value; nothing is committed. */
+interface AttachmentRemoveRequest {
+    readonly reason: AttachmentRemoveReason;
+    readonly file: AttachmentFile;
+    readonly source: Event;
+}
+interface AttachmentDefaults {
+    layout: AttachmentLayout;
+    orientation: AttachmentOrientation;
+    size: AttachmentSize;
+}
+declare const ATTACHMENT_DEFAULTS: InjectionToken<AttachmentDefaults>;
+/**
+ * An application decides once how large its attachments are and how a set of
+ * them is arranged. A group or an attachment that states either still wins.
+ * Their words and the locale that writes their sizes come from the language
+ * in force (`provideSlotted`).
+ */
+declare function provideAttachmentDefaults(defaults: Partial<AttachmentDefaults>): {
+    provide: InjectionToken<AttachmentDefaults>;
+    useFactory: () => AttachmentDefaults;
+};
+declare function injectAttachmentDefaults(): AttachmentDefaults;
+/**
+ * The mark knocked out of each kind's tile — `upload`'s map, restated because
+ * that one is private to `upload`. The contract test reads both contracts'
+ * `kinds` and refuses a drift.
+ */
+declare const ATTACHMENT_KIND_GLYPH: Readonly<Record<FileKind, GlyphName>>;
+/**
+ * The controls `removal-focus` counts. An attachment in a set holds the same
+ * controls as its neighbours, so the position focus had among them is the
+ * position of the same control on the attachment that took its place. A
+ * remove control of an attachment that is not removable is hidden, and is not
+ * counted.
+ */
+declare const ATTACHMENT_CONTROL_SELECTOR = "[data-part=\"trigger\"], [data-part=\"action\"], [data-part=\"remove\"]:not([hidden])";
+
+/**
+ * A set of attachments on the `ul` the page wrote: a column, a wrapping grid
+ * or one line that scrolls. It hands its size and orientation to every
+ * attachment that does not state its own.
+ *
+ * It keeps the keyboard where it was when an attachment leaves: focus goes to
+ * the control that took the removed one's place, then to the last one, then
+ * to the list itself — which is why the list takes `tabindex="-1"`.
+ * `removal-focus` observes the DOM, so it is right however the consumer
+ * removed the file.
+ */
+declare class SlAttachmentGroup {
+    /** A column, a wrapping grid, or one line that scrolls. Falls back to the token. */
+    readonly layout: _angular_core.InputSignal<AttachmentLayout | undefined>;
+    /** Handed to every attachment that does not state its own. */
+    readonly size: _angular_core.InputSignal<AttachmentSize | undefined>;
+    /** Handed to every attachment that does not state its own. */
+    readonly orientation: _angular_core.InputSignal<AttachmentOrientation | undefined>;
+    private readonly defaults;
+    /** A `tabindex` the page wrote is kept; otherwise the list takes focus only by script. */
+    protected readonly tabindex: string;
+    readonly resolvedLayout: _angular_core.Signal<AttachmentLayout>;
+    readonly resolvedSize: _angular_core.Signal<AttachmentSize>;
+    readonly resolvedOrientation: _angular_core.Signal<AttachmentOrientation>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlAttachmentGroup, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlAttachmentGroup, "[slAttachmentGroup]", ["slAttachmentGroup"], { "layout": { "alias": "layout"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * One file that already belongs to something — a message, a record, a tray —
+ * on the `li` (inside `slAttachmentGroup`) or `div` (alone) the page wrote.
+ * The parts inside read the file from here: the tile its kind, the trigger its
+ * name, the detail its size.
+ *
+ * **Removal is a request.** `removable` draws `slAttachmentRemove` and makes
+ * `Backspace` and `Delete` answer anywhere inside the attachment; `(remove)`
+ * carries the reason and the file, and the list stays the page's. A held key
+ * does not repeat the request.
+ *
+ * **The refusal runs first.** A click inside the trigger, or on a family
+ * action written on an `a`, is refused here in the capture phase while the
+ * attachment is loading or disabled: a directive's host listener and a
+ * `(click)` the page wrote on the same element run in registration order, and
+ * the page's was registered first — the ordering `list-item` found.
+ */
+declare class SlAttachment {
+    /** The file: its name, and its media type and size when they are known. */
+    readonly file: _angular_core.InputSignal<AttachmentFile>;
+    /** The room the attachment gets. Falls back to the group, then the token, then `md`. */
+    readonly size: _angular_core.InputSignal<AttachmentSize | undefined>;
+    /** A row, or a card stood on end. Falls back to the group, then the token. */
+    readonly orientation: _angular_core.InputSignal<AttachmentOrientation | undefined>;
+    /** The file failed; painted from `data-invalid`, never `aria-invalid` on a list item. */
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Still on its way: `aria-busy`, the trigger refused, remove still operable. */
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Cannot be reached: the trigger, every action and remove are refused. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Draws `slAttachmentRemove` and lets `Backspace` and `Delete` ask for removal. */
+    readonly removable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Words laid over the catalog of the language in force, key by key: the
+     * remove control's name (`remove`, with the file's `{name}`) and the tile's
+     * word for a file without an extension.
+     */
+    readonly messages: _angular_core.InputSignal<PartialMessages<AttachmentMessages> | undefined>;
+    /** Asks to be taken out of the list. Not emitted while disabled, nor for a repeated key. */
+    readonly remove: _angular_core.OutputEmitterRef<AttachmentRemoveRequest>;
+    private readonly defaults;
+    private readonly group;
+    readonly id: string;
+    readonly ids: {
+        detail: string;
+        message: string;
+    };
+    /** The language in force, which writes the size the detail line shows. */
+    readonly locale: _angular_core.Signal<string>;
+    /** The family's words in the language in force, with this attachment's `messages` laid over them. */
+    readonly t: _slotted_core_i18n.FamilyTranslator<AttachmentMessages>;
+    readonly resolvedSize: _angular_core.Signal<AttachmentSize>;
+    readonly resolvedOrientation: _angular_core.Signal<AttachmentOrientation>;
+    readonly kind: _angular_core.Signal<_slotted_core_upload.FileKind>;
+    readonly split: _angular_core.Signal<{
+        stem: string;
+        extension: string;
+    }>;
+    readonly blocked: _angular_core.Signal<boolean>;
+    /**
+     * The ids of the describing parts on the page, so the trigger names only
+     * what exists — and the id each part actually carries, which is the page's
+     * own when it wrote one.
+     */
+    readonly described: _angular_core.WritableSignal<{
+        detail: string | null;
+        message: string | null;
+    }>;
+    constructor();
+    describe(part: 'detail' | 'message', id: string | null): void;
+    request(reason: AttachmentRemoveReason, source: Event): void;
+    protected handleKeydown(event: KeyboardEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlAttachment, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlAttachment, "[slAttachment]", ["slAttachment"], { "file": { "alias": "file"; "required": true; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "removable": { "alias": "removable"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; }, { "remove": "remove"; }, never, ["*"], true, never>;
+}
+
+/**
+ * The kind's tile with the kind's mark knocked out of it, or the thumbnail the
+ * page gives. A thumbnail that fails to load returns to the tile: the failure
+ * is this part's own state, not a state of the file. Hidden from assistive
+ * technology, because the name already says what the file is.
+ */
+declare class SlAttachmentPreview {
+    /** A thumbnail. Absent, or failing to load, the kind's tile is drawn instead. */
+    readonly src: _angular_core.InputSignal<string | undefined>;
+    protected readonly owner: SlAttachment;
+    protected readonly failed: _angular_core.WritableSignal<string | undefined>;
+    protected readonly picture: _angular_core.Signal<boolean>;
+    protected readonly glyph: _angular_core.Signal<"presentation" | "check" | "minus" | "plus" | "dot" | "x" | "ellipsis" | "copy" | "eye" | "eye-off" | "chevron-right" | "chevron-down" | "chevrons-right" | "panel-open" | "panel-close" | "arrow-left" | "pin" | "pin-off" | "external" | "calendar" | "clock" | "person" | "circle" | "circle-info" | "circle-check" | "triangle-alert" | "circle-alert" | "circle-x" | "circle-question" | "inbox" | "search" | "search-x" | "lock" | "caps-lock" | "arrow-up" | "stop" | "paperclip" | "pipette" | "cloud-off" | "loader-circle" | "maximize" | "minimize" | "upload" | "file" | "trash" | "play" | "pause" | "rotate-ccw" | "file-image" | "file-text" | "file-spreadsheet" | "file-audio" | "file-video" | "file-archive" | "file-type" | "text-wrap" | "bell" | "trending-up" | "image-off" | "funnel" | "grip-vertical" | "grip-horizontal" | "star" | "check-check">;
+    protected readonly extension: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlAttachmentPreview, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlAttachmentPreview, "[slAttachmentPreview]", ["slAttachmentPreview"], { "src": { "alias": "src"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/** The text column, and the one box in the attachment that may shrink. */
+declare class SlAttachmentBody {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlAttachmentBody, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlAttachmentBody, "[slAttachmentBody]", ["slAttachmentBody"], {}, {}, never, never, true, never>;
+}
+/**
+ * The file name as two runs — the stem, which shrinks to an ellipsis, and the
+ * extension, which does not — in the name's own direction. Content the page
+ * projects replaces the two runs.
+ */
+declare class SlAttachmentFilename {
+    protected readonly owner: SlAttachment;
+    protected readonly dir: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlAttachmentFilename, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlAttachmentFilename, "[slAttachmentFilename]", ["slAttachmentFilename"], {}, {}, never, ["*"], true, never>;
+}
+/**
+ * The file's target: `<a slAttachmentTrigger [href]>` for a file with an
+ * address, so `href`, `download` and a modified click stay the platform's;
+ * `<button slAttachmentTrigger>` for a viewer the page opens. Named by the
+ * file, described by the detail and the message, and stretched over the whole
+ * attachment. A `button` takes the native `disabled` while the file is loading
+ * or unavailable; an `a` takes `aria-disabled` and keeps its destination, and
+ * `slAttachment` refuses the activation.
+ */
+declare class SlAttachmentTrigger {
+    protected readonly owner: SlAttachment;
+    protected readonly isButton: boolean;
+    protected readonly title: string | null;
+    protected readonly type: string | null;
+    /** A description the page wrote comes first; the family's ids are joined to it. */
+    private readonly written;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlAttachmentTrigger, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlAttachmentTrigger, "a[slAttachmentTrigger], button[slAttachmentTrigger]", ["slAttachmentTrigger"], {}, {}, never, ["*"], true, never>;
+}
+/**
+ * The line under the name. With nothing projected it writes the size with
+ * `formatBytes` in the language in force; anything the page writes replaces it.
+ */
+declare class SlAttachmentDetail {
+    protected readonly wiring: {
+        owner: SlAttachment;
+        id: string;
+    };
+    protected readonly owner: SlAttachment;
+    protected readonly bytes: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlAttachmentDetail, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlAttachmentDetail, "[slAttachmentDetail]", ["slAttachmentDetail"], {}, {}, never, ["*"], true, never>;
+}
+/** Why the file failed, or anything longer than a line the page must say about it. */
+declare class SlAttachmentMessage {
+    protected readonly wiring: {
+        owner: SlAttachment;
+        id: string;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlAttachmentMessage, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlAttachmentMessage, "[slAttachmentMessage]", ["slAttachmentMessage"], {}, {}, never, never, true, never>;
+}
+/**
+ * The transfer, as the attachment's bottom edge: `slProgressBar`, named by the
+ * file so a reader hears the name and the percentage together. Without a
+ * `value` the bar is indeterminate.
+ */
+declare class SlAttachmentProgress {
+    /** Per cent, 0 to 100. Absent, the bar is indeterminate. */
+    readonly value: _angular_core.InputSignal<number | null | undefined>;
+    protected readonly owner: SlAttachment;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlAttachmentProgress, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlAttachmentProgress, "[slAttachmentProgress]", ["slAttachmentProgress"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * The controls the application offers on the file, beside the trigger and
+ * above its stretched target: interactive content may not nest inside `a` or
+ * `button`.
+ */
+declare class SlAttachmentActions {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlAttachmentActions, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlAttachmentActions, "[slAttachmentActions]", ["slAttachmentActions"], {}, {}, never, never, true, never>;
+}
+/**
+ * One icon control of the application's own, on the `button` or the `a` the
+ * page wrote — an `a` with `download` is a download. It needs an
+ * `aria-label`. An unavailable attachment disables it: the native `disabled`
+ * on a button, `aria-disabled` on a link, whose activation `slAttachment`
+ * refuses.
+ */
+declare class SlAttachmentAction {
+    protected readonly owner: SlAttachment;
+    protected readonly isButton: boolean;
+    protected readonly type: string | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlAttachmentAction, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlAttachmentAction, "button[slAttachmentAction], a[slAttachmentAction]", ["slAttachmentAction"], {}, {}, never, never, true, never>;
+}
+/**
+ * Asks to take the attachment out of its list, on the `button` the page
+ * wrote. Hidden unless the attachment is `removable`, so a read-only thread
+ * shows no control that does nothing. Its name is the word and the file,
+ * `Remove claim-form.pdf`, unless the page wrote its own `aria-label`.
+ */
+declare class SlAttachmentRemove {
+    protected readonly owner: SlAttachment;
+    private readonly written;
+    protected readonly label: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlAttachmentRemove, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlAttachmentRemove, "button[slAttachmentRemove]", ["slAttachmentRemove"], {}, {}, never, ["*"], true, never>;
+}
+
+export { ATTACHMENT_CONTROL_SELECTOR, ATTACHMENT_DEFAULTS, ATTACHMENT_KIND_GLYPH, SlAttachment, SlAttachmentAction, SlAttachmentActions, SlAttachmentBody, SlAttachmentDetail, SlAttachmentFilename, SlAttachmentGroup, SlAttachmentMessage, SlAttachmentPreview, SlAttachmentProgress, SlAttachmentRemove, SlAttachmentTrigger, injectAttachmentDefaults, provideAttachmentDefaults };
+export type { AttachmentDefaults, AttachmentFile, AttachmentLayout, AttachmentOrientation, AttachmentRemoveReason, AttachmentRemoveRequest, AttachmentSize };
+//# sourceMappingURL=slotted-angular-attachment.d.ts.map

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

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

package/types/slotted-angular-avatar-group.d.ts

@@ -0,0 +1,119 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, Signal } from '@angular/core';
+import { AvatarGroupLayout, AvatarSize, AvatarShape, AvatarVariant } from '@slotted/angular/avatar';
+
+/**
+ * What a member is, to the group that holds it: a name, and a place in the row.
+ *
+ * The token exists so an item can ask the group whether it is beyond the limit
+ * without importing the group, which imports the item for its own content
+ * query. One direction each way is what keeps the two files out of a cycle.
+ */
+interface AvatarGroupMember {
+    /** The member's own name, read from the avatar inside it. */
+    readonly memberName: Signal<string | undefined>;
+}
+interface AvatarGroupHost {
+    isHiddenMember(member: AvatarGroupMember): boolean;
+}
+declare const AVATAR_GROUP: InjectionToken<AvatarGroupHost>;
+
+/**
+ * A list of faces, overlapped or apart, ending in a summary of the ones it does
+ * not show.
+ *
+ * It is written on a real `<ul>` whose members are real `<li>`s, so assistive
+ * technology announces a list of N without the family inventing a role. There
+ * is no `label` input: the element already accepts `aria-label`, and a second
+ * way to name one thing is a second thing to get wrong — the decision
+ * `button-group` took for the same question.
+ *
+ * The summary is an avatar rather than a fourth part painted to look like one,
+ * so it takes the group's size, shape, edge and ring from the same rules as
+ * every member beside it. Its accessible name is the hidden members' names,
+ * joined for the locale: Atlassian's default there is the English string “N
+ * more people”, and MUI, Ant, Fluent, Chakra and HeroUI leave `+3` as the whole
+ * announcement.
+ */
+declare class SlAvatarGroup {
+    /** `stack` overlaps the members; `spread` lays them apart and wraps. */
+    readonly layout: _angular_core.InputSignal<AvatarGroupLayout>;
+    /**
+     * The largest number of discs the group draws, the summary included. Above
+     * it, one fewer member is shown and the rest are summarised. `false` shows
+     * every member.
+     */
+    readonly max: _angular_core.InputSignal<number | false>;
+    /**
+     * How many members there really are, when the page renders fewer than it
+     * has — a server-paged list showing three of forty. Defaults to the number of
+     * items written.
+     */
+    readonly total: _angular_core.InputSignal<number | undefined>;
+    /**
+     * What the summary is called. Defaults to the hidden members' names, joined
+     * for the locale — which is only possible while every hidden member is in the
+     * DOM, so a group given a larger `total` supplies this itself.
+     */
+    readonly overflowLabel: _angular_core.InputSignal<string | undefined>;
+    /** Provided to every member. An avatar that states its own still wins. */
+    readonly size: _angular_core.InputSignal<AvatarSize | undefined>;
+    /** Provided to every member. An avatar that states its own still wins. */
+    readonly shape: _angular_core.InputSignal<AvatarShape | undefined>;
+    /** Provided to every member. An avatar that states its own still wins. */
+    readonly variant: _angular_core.InputSignal<AvatarVariant | undefined>;
+    /** BCP 47, for the digits of the summary and for joining the hidden names. */
+    readonly locale: _angular_core.InputSignal<string | undefined>;
+    private readonly inherited;
+    private readonly items;
+    protected readonly resolvedSize: _angular_core.Signal<AvatarSize>;
+    protected readonly resolvedShape: _angular_core.Signal<AvatarShape>;
+    private readonly resolvedLocale;
+    private readonly count;
+    /**
+     * `max` counts the discs the group draws, the summary included, so a limit of
+     * five never puts six circles in a row. Below the limit nothing is
+     * summarised: a `+1` beside four faces is one more circle than showing the
+     * fifth, and says less.
+     */
+    private readonly shownCount;
+    protected readonly surplus: _angular_core.Signal<number>;
+    protected readonly summary: _angular_core.Signal<string | undefined>;
+    /**
+     * The names of the members that were not drawn. They are only complete while
+     * every hidden member is in the DOM: a group told it stands for forty and
+     * given three items knows three names and no more, so it says nothing rather
+     * than naming a third of them.
+     */
+    protected readonly overflowName: _angular_core.Signal<string | undefined>;
+    /** Read from each item's own `computed`, so a member hides itself. */
+    isHiddenMember(member: AvatarGroupMember): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlAvatarGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlAvatarGroup, "ul[slAvatarGroup]", ["slAvatarGroup"], { "layout": { "alias": "layout"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "total": { "alias": "total"; "required": false; "isSignal": true; }; "overflowLabel": { "alias": "overflowLabel"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; }, {}, ["items"], ["*"], true, never>;
+}
+
+/**
+ * One member of the group: the list item that holds an avatar.
+ *
+ * React wraps each child itself, because it can. Angular cannot wrap projected
+ * content one node at a time, so the item is written in the template — which is
+ * the more honest of the two anyway: the `<li>` is the consumer's element, and
+ * `*ngFor` puts it where the data says.
+ *
+ * A member past the group's limit is `hidden`, which takes it out of the layout
+ * and out of the accessibility tree in one attribute. Its name is not lost: the
+ * group reads it from here and puts it on the summary.
+ */
+declare class SlAvatarGroupItem {
+    private readonly group;
+    private readonly avatar;
+    /** What the group calls this member when it has to summarise it away. */
+    readonly memberName: _angular_core.Signal<string | undefined>;
+    protected readonly hidden: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlAvatarGroupItem, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlAvatarGroupItem, "li[slAvatarGroupItem]", ["slAvatarGroupItem"], {}, {}, ["avatar"], never, true, never>;
+}
+
+export { AVATAR_GROUP, SlAvatarGroup, SlAvatarGroupItem };
+export type { AvatarGroupHost, AvatarGroupMember };
+//# sourceMappingURL=slotted-angular-avatar-group.d.ts.map

package/types/slotted-angular-avatar-group.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-avatar-group.d.ts","sources":["../../avatar-group/src/avatar-group-host.ts","../../avatar-group/src/avatar-group.ts","../../avatar-group/src/avatar-group-item.ts"],"mappings":";;;;AAGA;;;;;;AAMG;UACc,iBAAiB;;yBAEX,MAAM;AAC5B;UAEgB,eAAe;AAC9B,2BAAuB,iBAAiB;AACzC;AAED,cAAa,YAAY,EAAA,cAAA,CAAA,eAAA;;AC+CzB;;;;;;;;;;;;;;;;AAgBG;AACH,cA2Ba,aAAa;;qBAET,aAAA,CAAA,WAAA,CAAA,iBAAA;AACf;;;;AAIG;kBACS,aAAA,CAAA,WAAA;AACZ;;;;AAIG;oBACW,aAAA,CAAA,WAAA;AACd;;;;AAIG;4BACmB,aAAA,CAAA,WAAA;;mBAET,aAAA,CAAA,WAAA,CAAA,UAAA;;oBAEC,aAAA,CAAA,WAAA,CAAA,WAAA;;sBAEE,aAAA,CAAA,WAAA,CAAA,aAAA;;qBAED,aAAA,CAAA,WAAA;AAEf;AACA;AAEA,qCAA+B,aAAA,CAAA,MAAA,CAAA,UAAA;AAC/B,sCAAgC,aAAA,CAAA,MAAA,CAAA,WAAA;AAChC;AAEA;AAEA;;;;;AAKG;AACH;AAOA,gCAA0B,aAAA,CAAA,MAAA;AAE1B,gCAA0B,aAAA,CAAA,MAAA;AAI1B;;;;;AAKG;AACH,qCAA+B,aAAA,CAAA,MAAA;;2BAcR,iBAAiB;oDA9E7B,aAAa;sDAAb,aAAa;AAiFzB;;AC1LD;;;;;;;;;;;AAWG;AACH,cASa,iBAAiB;AAC5B;AACA;;yBAGmB,aAAA,CAAA,MAAA;AAEnB,+BAAyB,aAAA,CAAA,MAAA;oDAPd,iBAAiB;sDAAjB,iBAAiB;AAQ7B;;","names":[]}

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

@@ -0,0 +1,202 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import * as _slotted_angular_avatar from '@slotted/angular/avatar';
+
+/**
+ * Which of the five semantic colours the fallback is painted in. `auto` derives
+ * it from the name, so the same person keeps the same colour in a list that is
+ * re-sorted and in a table that is paged.
+ */
+type AvatarTone = 'auto' | 'accent' | 'secondary' | 'success' | 'warning' | 'danger';
+/** The palette `auto` chooses from, in the order the hash indexes it. */
+type AvatarResolvedTone = Exclude<AvatarTone, 'auto'>;
+/** How that colour is painted. `soft` is the tinted disc an avatar usually is. */
+type AvatarVariant = 'soft' | 'solid';
+type AvatarSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+/** A circle is a person; a square is a team, an organisation or a bot. */
+type AvatarShape = 'circle' | 'square';
+/** Where the picture is. Four values, because a boolean cannot say why there is none. */
+type AvatarStatus = 'idle' | 'loading' | 'loaded' | 'error';
+type AvatarGroupLayout = 'stack' | 'spread';
+interface AvatarDefaults {
+    /** BCP 47. Used to case the initials, and by the group to join names. */
+    locale: string | undefined;
+    shape: AvatarShape;
+    size: AvatarSize;
+    tone: AvatarTone;
+    variant: AvatarVariant;
+}
+declare const AVATAR_DEFAULTS: InjectionToken<AvatarDefaults>;
+/**
+ * An application decides once how its avatars are shaped, how large they are,
+ * how they are painted and — the one that matters most — which locale cases
+ * their initials, rather than repeating four inputs on every avatar. An avatar
+ * that states any of them itself still wins: an explicit input is never
+ * overridden by the token.
+ *
+ * `SlAvatarGroup` provides the same token rather than a channel of its own,
+ * which is what keeps a member's explicit `size` winning over the group's.
+ */
+declare function provideAvatarDefaults(defaults: Partial<AvatarDefaults>): {
+    provide: InjectionToken<AvatarDefaults>;
+    useFactory: () => AvatarDefaults;
+};
+/** What an avatar renders as here, before it states anything of its own. */
+declare function injectAvatarDefaults(): AvatarDefaults;
+
+/**
+ * Content that stands in for the picture, in place of the initials and the
+ * glyph: a company mark, a product logo, an `sl-icon`.
+ *
+ * It is a marker rather than a bare `<ng-content>` because Angular cannot ask
+ * whether anything was projected, and an avatar that wrote its initials
+ * *and* the consumer's logo into the same disc would be drawing two fallbacks.
+ * React answers the same question by looking at `children`.
+ */
+declare class SlAvatarFallback {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlAvatarFallback, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlAvatarFallback, "[slAvatarFallback]", ["slAvatarFallback"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * A picture of a person or an entity, and what stands in when there is none:
+ * the initials taken from the name, then a glyph the family owns. A request
+ * that fails never paints the browser's torn-page mark, because the picture is
+ * out of sight until it reports that it arrived.
+ *
+ * The component is written on the element the page chose, so a `span` in a
+ * table cell, an `a` that opens a profile and a `button` that opens a menu are
+ * all the same avatar.
+ *
+ * The name lives on the root and the picture takes an empty `alt`, so the
+ * avatar announces the same thing before and after the photograph loads. Every
+ * surveyed implementation names the image instead, which makes the same avatar
+ * “Ada Lovelace” once the picture arrives and “AL” before it.
+ *
+ * `status` is an input with an output beside it rather than a `model()`. A
+ * `model()` promises a two-way binding for a value the browser owns: the
+ * component would write over whatever the consumer passed the first time an
+ * image loaded. Here the consumer's value simply wins, and the output reports
+ * the derivation — a load event is a fact rather than a request, so there is
+ * nothing to cancel and no reason from the closed vocabulary that fits it.
+ */
+declare class SlAvatar {
+    /**
+     * The person or entity this is a picture of. It is the accessible name in
+     * every status, the source of the initials, and the seed of the colour.
+     */
+    readonly name: _angular_core.InputSignal<string | undefined>;
+    /** The picture. Absent, the avatar is its fallback and nothing is requested. */
+    readonly src: _angular_core.InputSignal<string | undefined>;
+    /**
+     * The letters to draw, in place of the ones derived from the name. Two
+     * graphemes at most is what the box holds; `xs` draws one.
+     */
+    readonly initialsOverride: _angular_core.InputSignal<string | undefined>;
+    /**
+     * A stable identifier to derive the colour from, when the name is not stable
+     * or two people share one. Defaults to `name`.
+     */
+    readonly idFor: _angular_core.InputSignal<string | undefined>;
+    /** BCP 47, for the case of the initials. Defaults to the provider, then to the runtime. */
+    readonly locale: _angular_core.InputSignal<string | undefined>;
+    /** Defaults to the provider, then to `md`. */
+    readonly size: _angular_core.InputSignal<AvatarSize | undefined>;
+    /** Defaults to the provider, then to `circle`. */
+    readonly shape: _angular_core.InputSignal<AvatarShape | undefined>;
+    /** Defaults to the provider, then to `auto`, which derives it from the name. */
+    readonly tone: _angular_core.InputSignal<AvatarTone | undefined>;
+    /** Defaults to the provider, then to `soft`. */
+    readonly variant: _angular_core.InputSignal<AvatarVariant | undefined>;
+    /** A deactivated account, or an avatar inside a control the page has turned off. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Takes the avatar out of the accessibility tree. For an avatar beside the
+     * name it belongs to, where announcing it would read the person twice.
+     */
+    readonly decorative: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Where the picture is. Supplied, it wins over what the component derives
+     * from the element — for a server that already knows, or a loader the family
+     * cannot see.
+     */
+    readonly status: _angular_core.InputSignal<AvatarStatus | undefined>;
+    /** Reports the derived status. Never emits for a status passed in. */
+    readonly statusChange: _angular_core.OutputEmitterRef<AvatarStatus>;
+    private readonly defaults;
+    /** An explicit role the consumer wrote is never replaced by an inferred one. */
+    private readonly writtenRole;
+    protected readonly custom: _angular_core.Signal<SlAvatarFallback | undefined>;
+    private readonly projected;
+    protected readonly resolvedSize: _angular_core.Signal<AvatarSize>;
+    protected readonly resolvedShape: _angular_core.Signal<AvatarShape>;
+    protected readonly resolvedVariant: _angular_core.Signal<AvatarVariant>;
+    private readonly resolvedLocale;
+    /**
+     * The derivation, and the picture it belongs to. A new request makes the
+     * previous answer describe nothing, so the status starts again from what the
+     * props alone can say — which is also what a server render and the hydration
+     * after it both compute, so nothing flashes between them.
+     */
+    private readonly derived;
+    protected readonly resolvedStatus: _angular_core.Signal<AvatarStatus>;
+    protected readonly resolvedTone: _angular_core.Signal<AvatarResolvedTone>;
+    protected readonly initials: _angular_core.Signal<string>;
+    /**
+     * The W3C `alt` decision tree, in this library's vocabulary and with the rule
+     * `icon` already took: a name present decides `role="img"`, an absent one
+     * decides `aria-hidden`. `decorative` is the third case — a name that is
+     * written beside the avatar, where announcing it reads the person twice.
+     */
+    private readonly silent;
+    protected readonly role: _angular_core.Signal<string | null>;
+    protected readonly ariaLabel: _angular_core.Signal<string | null>;
+    protected readonly ariaHidden: _angular_core.Signal<"true" | null>;
+    /** Called by the picture, whichever of the two elements it turned out to be. */
+    reportStatus(status: AvatarStatus): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlAvatar, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlAvatar, "[slAvatar]", ["slAvatar"], { "name": { "alias": "name"; "required": false; "isSignal": true; }; "src": { "alias": "src"; "required": false; "isSignal": true; }; "initialsOverride": { "alias": "initials"; "required": false; "isSignal": true; }; "idFor": { "alias": "idFor"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "shape": { "alias": "shape"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "decorative": { "alias": "decorative"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; }, { "statusChange": "statusChange"; }, ["custom", "projected"], ["img", "[slAvatarFallback]"], true, never>;
+}
+
+/**
+ * The picture inside an avatar.
+ *
+ * It is written on an `<img>` the consumer owns, which is what lets
+ * `NgOptimizedImage` do its work: `ngSrc`, the priority hint, the generated
+ * `srcset` and the size warnings all belong to a real `<img>` in the
+ * consumer's template, and none of them survive being handed a `src` string
+ * through an input. React has no equivalent, and its `renderImage` is the other
+ * half of the same idea.
+ *
+ * `alt` is written empty only when the consumer wrote none: the avatar's name
+ * is on the root, so naming the picture as well would read the person twice —
+ * and would name them differently before the picture arrives.
+ */
+declare class SlAvatarImage {
+    protected readonly avatar: _slotted_angular_avatar.AvatarImageHost;
+    /** A static `alt` the consumer wrote is read before the host binding writes one. */
+    protected readonly alt: string;
+    private readonly element;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlAvatarImage, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlAvatarImage, "img[slAvatarImage]", ["slAvatarImage"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * What the picture tells the avatar it sits in.
+ *
+ * It is a token rather than the component's own class so that one directive can
+ * serve both pictures the family knows about: the `<img>` the avatar renders
+ * for its own `src`, and the `<img>` the consumer projects — which is the one
+ * that carries `ngSrc`, and therefore the one `NgOptimizedImage` can reach. A
+ * directive that injected the component directly would put a cycle between the
+ * two files, and the component imports the directive for its own template.
+ */
+interface AvatarImageHost {
+    reportStatus(status: AvatarStatus): void;
+}
+declare const AVATAR_IMAGE_HOST: InjectionToken<AvatarImageHost>;
+
+export { AVATAR_DEFAULTS, AVATAR_IMAGE_HOST, SlAvatar, SlAvatarFallback, SlAvatarImage, injectAvatarDefaults, provideAvatarDefaults };
+export type { AvatarDefaults, AvatarGroupLayout, AvatarImageHost, AvatarResolvedTone, AvatarShape, AvatarSize, AvatarStatus, AvatarTone, AvatarVariant };
+//# sourceMappingURL=slotted-angular-avatar.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-avatar.d.ts","sources":["../../avatar/src/avatar-defaults.ts","../../avatar/src/avatar-fallback.ts","../../avatar/src/avatar.ts","../../avatar/src/avatar-image.ts","../../avatar/src/avatar-image-host.ts"],"mappings":";;;;AAEA;;;;AAIG;AACG,KAAM,UAAU;AAEtB;AACM,KAAM,kBAAkB,GAAG,OAAO,CAAC,UAAU;AAEnD;KACY,aAAa;AAEnB,KAAM,UAAU;AAEtB;KACY,WAAW;AAEvB;AACM,KAAM,YAAY;KAEZ,iBAAiB;UAEZ,cAAc;;AAE7B;WACO,WAAW;UACZ,UAAU;UACV,UAAU;aACP,aAAa;AACvB;AAUD,cAAa,eAAe,EAAA,cAAA,CAAA,cAAA;AAK5B;;;;;;;;;AASG;AACH,iBAAgB,qBAAqB,WAAW,OAAO,CAAC,cAAc;;sBAGlD,cAAc;AAQjC;AAED;AACA,iBAAgB,oBAAoB,IAAI,cAAc;;ACrEtD;;;;;;;;AAQG;AACH,cAKa,gBAAgB;oDAAhB,gBAAgB;sDAAhB,gBAAgB;AAAG;;AC4ChC;;;;;;;;;;;;;;;;;;;;;AAqBG;AACH,cA0Ca,QAAQ;AACnB;;;AAGG;mBACU,aAAA,CAAA,WAAA;;kBAED,aAAA,CAAA,WAAA;AACZ;;;AAGG;+BACsB,aAAA,CAAA,WAAA;AACzB;;;AAGG;oBACW,aAAA,CAAA,WAAA;;qBAEC,aAAA,CAAA,WAAA;;mBAEF,aAAA,CAAA,WAAA,CAAA,UAAA;;oBAEC,aAAA,CAAA,WAAA,CAAA,WAAA;;mBAED,aAAA,CAAA,WAAA,CAAA,UAAA;;sBAEG,aAAA,CAAA,WAAA,CAAA,aAAA;;uBAEC,aAAA,CAAA,wBAAA;AACjB;;;AAGG;yBACgB,aAAA,CAAA,wBAAA;AACnB;;;;AAIG;qBACY,aAAA,CAAA,WAAA,CAAA,YAAA;;2BAGM,aAAA,CAAA,gBAAA,CAAA,YAAA;AAErB;;AAEA;AAEA,+BAAyB,aAAA,CAAA,MAAA,CAAA,gBAAA;AACzB;AAEA,qCAA+B,aAAA,CAAA,MAAA,CAAA,UAAA;AAC/B,sCAAgC,aAAA,CAAA,MAAA,CAAA,WAAA;AAChC,wCAAkC,aAAA,CAAA,MAAA,CAAA,aAAA;AAClC;AAEA;;;;;AAKG;AACH;AAKA,uCAAiC,aAAA,CAAA,MAAA,CAAA,YAAA;AAEjC,qCAA+B,aAAA,CAAA,MAAA,CAAA,kBAAA;AAM/B,iCAA2B,aAAA,CAAA,MAAA;AAU3B;;;;;AAKG;AACH;AAKA,6BAAuB,aAAA,CAAA,MAAA;AACvB,kCAA4B,aAAA,CAAA,MAAA;AAC5B,mCAA6B,aAAA,CAAA,MAAA;;yBAGR,YAAY;oDAtGtB,QAAQ;sDAAR,QAAQ;AA0GpB;;AClOD;;;;;;;;;;;;;AAaG;AACH,cAWa,aAAa;AACxB,+BAAyB,uBAAA,CAAA,eAAA;;AAGzB;AAEA;;oDANW,aAAa;sDAAb,aAAa;AAqBzB;;AC9CD;;;;;;;;;AASG;UACc,eAAe;AAC9B,yBAAqB,YAAY;AAClC;AAED,cAAa,iBAAiB,EAAA,cAAA,CAAA,eAAA;;","names":[]}