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

package/types/slotted-angular-hover-card.d.ts

@@ -0,0 +1,140 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { PopoverOpenReason, SlPopover } from '@slotted/angular/popover';
+
+/**
+ * The popover's reasons, plus `blur`: focus leaving the trigger is the one
+ * way this family closes that the popover never does.
+ */
+type HoverCardOpenReason = PopoverOpenReason | 'blur';
+/**
+ * A preview of a link or a person, opened by hover and by focus.
+ *
+ * The card is `slPopover` behind a trigger the popover does not have. The
+ * directive *is* a popover — it extends `SlPopover` and provides itself as
+ * one, so every `slPopover*` part written inside it reaches the card — and it
+ * decides three things the popover leaves open: focus is never taken on open,
+ * the panel's role follows `navigable`, and the layer stands off the link by
+ * the halo the open mark draws. `slPopoverLayer`, `slPopoverBody` and the rest
+ * are the popover's own, imported as they are.
+ */
+declare class SlHoverCard extends SlPopover {
+    readonly openDelay: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    readonly closeDelay: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    readonly navigable: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    private readonly cardDefaults;
+    readonly resolvedOpenDelay: _angular_core.Signal<number>;
+    readonly resolvedCloseDelay: _angular_core.Signal<number>;
+    readonly resolvedNavigable: _angular_core.Signal<boolean>;
+    /** The card never takes focus: the reader's focus stays on the link. */
+    readonly resolvedAutoFocus: _angular_core.Signal<boolean>;
+    /** A card the keyboard cannot enter is not a dialog nobody is told about. */
+    readonly contentRole: _angular_core.Signal<string>;
+    readonly resolvedSideOffset: _angular_core.Signal<number>;
+    /** Focus the family put back on the trigger must not reopen the card. */
+    suppressFocusOpen: boolean;
+    private timer;
+    private intent;
+    constructor();
+    /** Asks to open or close. A close the keyboard caused holds the reopening back. */
+    toggle(next: boolean, reason: HoverCardOpenReason, source?: Event): void;
+    /** Cancels a pending open or close, and the grace area. */
+    cancelPending(): void;
+    /** Opens after `openDelay`, unless something cancels it first. */
+    openAfterDelay(source?: Event): void;
+    /** Closes after `closeDelay`, unless the pointer comes back first. */
+    closeAfterDelay(source?: Event): void;
+    /**
+     * The grace area: the card stays while the pointer's path from `origin`
+     * still points into the card, and closes once it does not — unless the
+     * pointer turns out to be on the trigger or the card after all.
+     */
+    graceToward(origin: () => DOMRect | null, stillOver: () => boolean, source?: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlHoverCard, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlHoverCard, "[slHoverCard]", ["slHoverCard"], { "openDelay": { "alias": "openDelay"; "required": false; "isSignal": true; }; "closeDelay": { "alias": "closeDelay"; "required": false; "isSignal": true; }; "navigable": { "alias": "navigable"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * The link the card is about. It is the family's one part: the element painted
+ * while the card shows, and the anchor the card is measured against — many
+ * triggers may share one `slHoverCard`, and the one that starts an opening
+ * registers itself.
+ *
+ * A component rather than a directive, as `slLink` and `slMenuItem` are,
+ * because a component is what can carry `styleUrl`: this is where the family's
+ * authored stylesheet enters an Angular application, and the trigger has to be
+ * painted before any card has opened.
+ *
+ * The wiring — `aria-haspopup="dialog"`, `aria-expanded`, `aria-controls` — is
+ * written only when the card is navigable. A card the keyboard cannot enter is
+ * not a popup the link has, and saying so would be a lie a screen reader
+ * repeats.
+ */
+declare class SlHoverCardTrigger {
+    protected readonly card: SlHoverCard;
+    private readonly element;
+    private readonly writtenUi;
+    private readonly writtenPart;
+    protected readonly ui: string;
+    protected readonly part: string;
+    /** Whether this trigger is the one the open card hangs from. */
+    protected readonly anchors: _angular_core.Signal<boolean>;
+    protected readonly open: _angular_core.Signal<boolean>;
+    private tapped;
+    constructor();
+    private claim;
+    private layer;
+    protected onPointerEnter(source: Event): void;
+    /**
+     * Leaving the trigger with the card open starts the grace: the card stays
+     * while the pointer's own path still points into it, and closes after
+     * `closeDelay` once the pointer has parked somewhere else. Leaving with an
+     * open still pending cancels the open.
+     */
+    protected onPointerLeave(source: Event): void;
+    /**
+     * `:focus-visible` rather than every focus: a press that focuses a link is a
+     * navigation, not a request for its preview — and focus the family itself
+     * put back after Escape or a focus guard must not reopen the card.
+     */
+    protected onFocus(event: Event): void;
+    protected onBlur(source: Event): void;
+    /**
+     * `Tab` on the open trigger enters a navigable card, which lives at the end
+     * of the document and would otherwise never be reached. The popover's focus
+     * guards bring focus back out past either end.
+     */
+    protected onKeyDown(source: Event): void;
+    /**
+     * There is no hover on a coarse pointer. A tap on a closed trigger opens the
+     * card and does not follow the link; a tap on an open one follows it.
+     */
+    protected onPointerDown(source: Event): void;
+    protected onClick(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlHoverCardTrigger, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlHoverCardTrigger, "[slHoverCardTrigger]", ["slHoverCardTrigger"], {}, {}, never, ["*"], true, never>;
+}
+
+interface HoverCardDefaults {
+    /** Milliseconds the pointer rests on the trigger before the card opens. */
+    openDelay: number;
+    /** Milliseconds after the pointer has left trigger and card before it closes. */
+    closeDelay: number;
+    /**
+     * Whether the card holds controls a keyboard reader can reach. On, `Tab`
+     * from the open trigger enters it, the panel is a `dialog` and the trigger
+     * says so; off, the card is a `presentation` the link never announces.
+     */
+    navigable: boolean;
+}
+declare const HOVER_CARD_DEFAULTS: InjectionToken<HoverCardDefaults>;
+/** The decisions an application takes once, in its bootstrap. */
+declare function provideHoverCardDefaults(defaults: Partial<HoverCardDefaults>): {
+    provide: InjectionToken<HoverCardDefaults>;
+    useFactory: () => HoverCardDefaults;
+};
+declare function injectHoverCardDefaults(): HoverCardDefaults;
+
+export { HOVER_CARD_DEFAULTS, SlHoverCard, SlHoverCardTrigger, injectHoverCardDefaults, provideHoverCardDefaults };
+export type { HoverCardDefaults, HoverCardOpenReason };
+//# sourceMappingURL=slotted-angular-hover-card.d.ts.map

package/types/slotted-angular-hover-card.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-hover-card.d.ts","sources":["../../hover-card/src/hover-card.ts","../../hover-card/src/hover-card-trigger.ts","../../hover-card/src/hover-card-defaults.ts"],"mappings":";;;;AAmBA;;;AAGG;KACS,mBAAmB,GAAG,iBAAiB;AASnD;;;;;;;;;;AAUG;AACH,cAMa,WAAY,SAAQ,SAAS;wBACtB,aAAA,CAAA,wBAAA;yBAGC,aAAA,CAAA,wBAAA;wBAGD,aAAA,CAAA,wBAAA;AAIlB;gCAE0B,aAAA,CAAA,MAAA;iCACC,aAAA,CAAA,MAAA;gCACD,aAAA,CAAA,MAAA;;AAK1B,gCAAmC,aAAA,CAAA,MAAA;;AAEnC,0BAA6B,aAAA,CAAA,MAAA;AAG7B,iCAAoC,aAAA,CAAA,MAAA;;AAGpC;;;;;AAsCS,kCAA8B,mBAAmB,WAAW,KAAK;;;;AAiB1E,4BAAwB,KAAK;;AAM7B,6BAAyB,KAAK;AAK9B;;;;AAIG;AACH,8BAA0B,OAAO,4CAA4C,KAAK;oDAnGvE,WAAW;sDAAX,WAAW;AAmHvB;;ACtJD;;;;;;;;;;;;;;;AAeG;AACH,cAwBa,kBAAkB;AAC7B,6BAAuB,WAAA;AACvB;AAKA;AACA;AACA;AACA;;AAGA,gCAA0B,aAAA,CAAA,MAAA;AAC1B,6BAAuB,aAAA,CAAA,MAAA;;;AAWvB;AAIA;AAKA,qCAAiC,KAAK;AAWtC;;;;;AAKG;AACH,qCAAiC,KAAK;AActC;;;;AAIG;AACH,6BAAyB,KAAK;AAQ9B,6BAAyB,KAAK;AAS9B;;;;AAIG;AACH,gCAA4B,KAAK;AAYjC;;;AAGG;AACH,oCAAgC,KAAK;AAIrC,6BAAyB,KAAK;oDAhHnB,kBAAkB;sDAAlB,kBAAkB;AAwH9B;;UC5KgB,iBAAiB;;;;;AAKhC;;;;AAIG;;AAEJ;AAcD,cAAa,mBAAmB,EAAA,cAAA,CAAA,iBAAA;AAKhC;AACA,iBAAgB,wBAAwB,WAAW,OAAO,CAAC,iBAAiB;;sBAGxD,iBAAiB;AAEpC;AAED,iBAAgB,uBAAuB,IAAI,iBAAiB;;","names":[]}

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

@@ -0,0 +1,46 @@
+import { InjectionToken, Signal, Provider } from '@angular/core';
+import { PartialCatalog, TranslatorOptions, SlottedMessages, Translator, MessageFamily, PartialMessages, FamilyTranslator } from '@slotted/core/i18n';
+
+type Resolve = TranslatorOptions<SlottedMessages>['resolve'];
+/** The language in force at one injector: the locale, the catalogs, and the translator over them. */
+interface SlottedI18n {
+    readonly locale: Signal<string>;
+    readonly catalogs: Signal<Readonly<Record<string, PartialCatalog>>>;
+    readonly resolve: Signal<Resolve>;
+    readonly translator: Signal<Translator<SlottedMessages>>;
+}
+declare const SL_I18N: InjectionToken<SlottedI18n>;
+interface SlottedConfig {
+    /** The locale the subtree speaks and formats in, BCP 47. A signal changes it in place. */
+    readonly locale?: string | Signal<string> | undefined;
+    /**
+     * Catalogs by locale, laid over those of an enclosing provider. A signal lets
+     * a locale imported on demand arrive after bootstrap: set it, then the locale.
+     */
+    readonly catalogs?: Readonly<Record<string, PartialCatalog>> | Signal<Readonly<Record<string, PartialCatalog>>> | undefined;
+    /** The application's own i18n, asked before any catalog. */
+    readonly resolve?: Resolve;
+}
+/**
+ * The language of everything the library writes under this injector. In
+ * `app.config.ts` it serves the application; in a component's `providers` it
+ * gives that subtree its own locale and keeps the catalogs and the `resolve`
+ * of the injector above. A factory runs in an injection context, so it can
+ * read the locale from an application service.
+ */
+declare function provideSlotted(config: SlottedConfig | (() => SlottedConfig)): Provider;
+/** The locale this injector formats numbers and dates in; `en-US` with no provider. */
+declare function injectLocale(): Signal<string>;
+/** The translator in force at this injector. */
+declare function injectTranslator(): Signal<Translator<SlottedMessages>>;
+/**
+ * A family's messages in the language in force, an instance's `messages`
+ * input laid over the catalog key by key. The function reads the locale on
+ * every call, so a template that calls it follows a change of language
+ * without the component being created again.
+ */
+declare function injectMessages<F extends keyof SlottedMessages & string>(family: MessageFamily<F, SlottedMessages[F]>, override?: Signal<PartialMessages<SlottedMessages[F]> | undefined>): FamilyTranslator<SlottedMessages[F]>;
+
+export { SL_I18N, injectLocale, injectMessages, injectTranslator, provideSlotted };
+export type { SlottedConfig, SlottedI18n };
+//# sourceMappingURL=slotted-angular-i18n.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-i18n.d.ts","sources":["../../i18n/src/i18n.ts"],"mappings":";;;AAqBA,KAAK,OAAO,GAAG,iBAAiB,CAAC,eAAe;AAEhD;UACiB,WAAW;AAC1B,qBAAiB,MAAM;AACvB,uBAAmB,MAAM,CAAC,QAAQ,CAAC,MAAM,SAAS,cAAc;AAChE,sBAAkB,MAAM,CAAC,OAAO;yBACX,MAAM,CAAC,UAAU,CAAC,eAAe;AACvD;AAUD,cAAa,OAAO,EAAA,cAAA,CAAA,WAAA;UAKH,aAAa;;AAE5B,+BAA2B,MAAM;AACjC;;;AAGG;AACH,wBACI,QAAQ,CAAC,MAAM,SAAS,cAAc,KACtC,MAAM,CAAC,QAAQ,CAAC,MAAM,SAAS,cAAc;;AAGjD,uBAAmB,OAAO;AAC3B;AAED;;;;;;AAMG;AACH,iBAAgB,cAAc,SAAS,aAAa,UAAU,aAAa,IAAI,QAAQ;AA0BvF;AACA,iBAAgB,YAAY,IAAI,MAAM;AAItC;AACA,iBAAgB,gBAAgB,IAAI,MAAM,CAAC,UAAU,CAAC,eAAe;AAIrE;;;;;AAKG;AACH,iBAAgB,cAAc,iBAAiB,eAAe,mBACpD,aAAa,IAAI,eAAe,iBAC7B,MAAM,CAAC,eAAe,CAAC,eAAe,oBAChD,gBAAgB,CAAC,eAAe;;","names":[]}

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

@@ -0,0 +1,94 @@
+import * as _angular_core from '@angular/core';
+import { GlyphDrawing } from '@slotted/core/glyph';
+export { GlyphName } from '@slotted/core/glyph';
+
+/**
+ * Glyph is the library's own artwork, drawn as a real `<svg>`: the Lucide
+ * geometry `@slotted/core/glyph` holds, stroked or filled with `currentColor`.
+ * It goes inside a `slIcon` box, which owns the size, the colour, the
+ * alignment and the name; the glyph owns only the drawing. Every family draws
+ * its own icons — a close button's cross, a pager's chevrons — with this
+ * element, and never with a pseudo-element or a mask of its own.
+ *
+ * `solid` draws a status mark the way a tone's badge reads: the glyph's first
+ * shape filled, and the symbol inside it cut out of the fill by an SVG
+ * `<mask>`, so whatever lies behind shows through the symbol on any ground.
+ *
+ * The children carry the `svg:` namespace because the template is parsed apart
+ * from its host: an unprefixed `<path>` would be created as an HTML element.
+ */
+declare class SlGlyph {
+    /** One of the library's own icons: its glyph token without `--slotted-icon-`. */
+    readonly name: _angular_core.InputSignal<"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" | "presentation" | "text-wrap" | "bell" | "trending-up" | "image-off" | "funnel" | "grip-vertical" | "grip-horizontal" | "star" | "check-check">;
+    /**
+     * The first shape filled and the symbol cut out of it — a tone's status
+     * mark. For glyphs whose first shape encloses the rest (`circle-*`,
+     * `triangle-alert`).
+     */
+    readonly solid: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly maskId: string;
+    protected readonly viewBox = "0 0 24 24";
+    protected readonly drawing: _angular_core.Signal<GlyphDrawing>;
+    protected readonly symbol: _angular_core.Signal<string[]>;
+    protected readonly stroked: _angular_core.Signal<boolean>;
+    protected readonly transform: _angular_core.Signal<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlGlyph, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlGlyph, "svg[slGlyph]", never, { "name": { "alias": "name"; "required": true; "isSignal": true; }; "solid": { "alias": "solid"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * Three steps read the control icon scale, which the theme restates per
+ * density. `text` follows the type the icon sits in, because a control-sized
+ * glyph inside a display heading is not an icon.
+ */
+type IconSize = 'text' | 'sm' | 'md' | 'lg';
+type IconTone = 'inherit' | 'default' | 'muted' | 'accent' | 'success' | 'warning' | 'danger' | 'inverse';
+
+/**
+ * Icon is the box a glyph is drawn in, not the glyph. The library ships no
+ * catalogue: the artwork is the consumer's — an `ng-icon`, an inline `svg`,
+ * anything that renders one — and this family owns the size it is drawn at,
+ * the colour it inherits, where it sits against a line of text, and whether it
+ * mirrors where reading runs the other way.
+ *
+ * The selector is the bare attribute, so the consumer writes the element. It
+ * is a component rather than a directive only because a directive carries no
+ * `styleUrl`, and that also means it cannot sit on `<ng-icon>` itself: Angular
+ * refuses two components on one element, so the box is always written.
+ */
+declare class SlIcon {
+    readonly directional: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    readonly size: _angular_core.InputSignal<IconSize | undefined>;
+    readonly tone: _angular_core.InputSignal<IconTone | undefined>;
+    /**
+     * A name the consumer wrote on the element counts as much as the input, and
+     * has to be read rather than assumed absent: a host binding that wrote
+     * `null` would delete the consumer's own `aria-label` and hide the icon it
+     * named, which is a silent defect in the likeliest mistake. `aria-labelledby`
+     * is read and never written, so the attribute the consumer put there stays
+     * exactly as written.
+     */
+    private readonly writtenLabel;
+    private readonly writtenLabelledBy;
+    private readonly writtenRole;
+    protected readonly ariaLabel: _angular_core.Signal<string | null>;
+    /**
+     * The icon is decorative when it has no name and meaningful when it has one,
+     * which is why there is no `decorative` input: named and hidden cannot both
+     * be true.
+     */
+    protected readonly named: _angular_core.Signal<boolean>;
+    /**
+     * `role="img"` requires a name, so it appears only once there is one, and a
+     * role the consumer chose is left alone.
+     */
+    protected readonly role: _angular_core.Signal<string | null>;
+    protected readonly toneAttribute: _angular_core.Signal<string | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlIcon, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlIcon, "[slIcon]", ["slIcon"], { "directional": { "alias": "directional"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { SlGlyph, SlIcon };
+export type { IconSize, IconTone };
+//# sourceMappingURL=slotted-angular-icon.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-icon.d.ts","sources":["../../icon/src/glyph.ts","../../icon/src/icon.types.ts","../../icon/src/icon.ts"],"mappings":";;;;AAYA;;;;;;;;;;;;;;AAcG;AACH,cA4Da,OAAO;;mBAEL,aAAA,CAAA,WAAA;AACb;;;;AAIG;oBACW,aAAA,CAAA,wBAAA;AAEd;AAEA;AACA,gCAA0B,aAAA,CAAA,MAAA,CAAA,YAAA;AAC1B,+BAAyB,aAAA,CAAA,MAAA;AACzB,gCAA0B,aAAA,CAAA,MAAA;AAC1B,kCAA4B,aAAA,CAAA,MAAA;oDAhBjB,OAAO;sDAAP,OAAO;AAoBnB;;AC3GD;;;;AAIG;AACG,KAAM,QAAQ;KAER,QAAQ;;ACOpB;;;;;;;;;;;AAWG;AACH,cAmBa,MAAM;0BACG,aAAA,CAAA,wBAAA;oBACN,aAAA,CAAA,WAAA;mBACD,aAAA,CAAA,WAAA,CAAA,QAAA;mBACA,aAAA,CAAA,WAAA,CAAA,QAAA;AAEb;;;;;;;AAOG;AACH;AACA;AAGA;AAEA,kCAA4B,aAAA,CAAA,MAAA;AAE5B;;;;AAIG;AACH,8BAAwB,aAAA,CAAA,MAAA;AAIxB;;;AAGG;AACH,6BAAuB,aAAA,CAAA,MAAA;AAIvB,sCAAgC,aAAA,CAAA,MAAA;oDAvCrB,MAAM;sDAAN,MAAM;AAwClB;;","names":[]}

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

@@ -0,0 +1,251 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { AspectRatioValue } from '@slotted/angular/aspect-ratio';
+import * as _slotted_angular_image from '@slotted/angular/image';
+
+/**
+ * How wide and how tall the box is. `intrinsic` is the picture's own size,
+ * shrunk to fit; `fill` is the parent's in both axes; `framed` is the
+ * column's width and the frame's height, and it is what a decided `ratio`
+ * implies.
+ */
+type ImageLayout = 'intrinsic' | 'fill' | 'framed';
+/** The five values `object-fit` has. `cover` crops; `contain` letterboxes. */
+type ImageFit = 'cover' | 'contain' | 'fill' | 'none' | 'scale-down';
+/**
+ * The focal point a crop keeps. `start` and `end` are the family's own —
+ * `object-position` has no logical keywords — and mirror under `dir="rtl"`.
+ * Any other value (`30% 20%`, a CMS focal point) is written on the instance.
+ */
+type ImagePosition = 'center' | 'top' | 'bottom' | 'start' | 'end';
+/** What the DOM says the focal point is: one of the names, or `custom`. */
+type ImagePositionAttribute = ImagePosition | 'custom';
+type ImageRadius = 'none' | 'sm' | 'md' | 'lg';
+/**
+ * What stands under the picture while it is on its way. `surface` is the
+ * sunken ground; `blur` is `placeholderSrc` scaled and blurred where the
+ * picture will be; `none` paints nothing.
+ */
+type ImagePlaceholder = 'none' | 'surface' | 'blur';
+/** Where the picture is. Four values, because a boolean cannot say why there is none. */
+type ImageStatus = 'idle' | 'loading' | 'loaded' | 'error';
+type ImageLoading = 'lazy' | 'eager';
+type ImageDecoding = 'async' | 'sync' | 'auto';
+/** One `<source>` of a `<picture>`: art direction by media, or a format by type. */
+interface ImageSource {
+    media?: string | undefined;
+    sizes?: string | undefined;
+    srcSet: string;
+    type?: string | undefined;
+}
+/** What an application sets once for every image under it. */
+interface ImageDefaults {
+    bordered: boolean;
+    decoding: ImageDecoding;
+    fit: ImageFit;
+    layout: ImageLayout;
+    loading: ImageLoading;
+    placeholder: ImagePlaceholder;
+    position: ImagePosition | (string & {});
+    radius: ImageRadius;
+}
+declare const IMAGE_DEFAULTS: InjectionToken<ImageDefaults>;
+/**
+ * An application decides once how its pictures are cut, cornered, edged and
+ * held before they arrive, rather than repeating the same inputs on every
+ * thumbnail in every grid. An image that states any of them itself still
+ * wins: an explicit input is never overridden by the token.
+ */
+declare function provideImageDefaults(defaults: Partial<ImageDefaults>): {
+    provide: InjectionToken<ImageDefaults>;
+    useFactory: () => ImageDefaults;
+};
+/** What an image renders as here, before it states anything of its own. */
+declare function injectImageDefaults(): ImageDefaults;
+
+/**
+ * The picture inside an image.
+ *
+ * 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.
+ *
+ * A projected picture keeps every attribute the consumer wrote — `alt`,
+ * `loading`, `width`, `height` — and the family writes only its part name.
+ */
+declare class SlImageMedia {
+    protected readonly host: _slotted_angular_image.ImageMediaHost;
+    private readonly element;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlImageMedia, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlImageMedia, "img[slImageMedia]", ["slImageMedia"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * A picture, and what stands in for it before it arrives and after it fails.
+ * The `<img>` is the platform's and keeps every attribute the platform gives
+ * it; the family adds the two layers under it, a fit, a focal point, a
+ * corner and an edge, and composes the frame from `slAspectRatio` when a
+ * ratio was decided.
+ *
+ * The component is written on the element the page chose — a `div`, a
+ * `figure`, an `a` that opens a page, a `button` that opens a dialog. The
+ * picture is either the `<img>` the component renders for its `src`, or the
+ * `<img slImageMedia>` the consumer projects, which is the one `ngSrc` and
+ * `NgOptimizedImage` belong on.
+ *
+ * `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 a
+ * picture 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 fits.
+ * `fallbackSrc` is tried before `error` is reported, on the component's own
+ * `<img>`; a projected picture is the consumer's to retry.
+ */
+declare class SlImage {
+    /** The picture. Absent, the component renders no `<img>` of its own and is idle. */
+    readonly src: _angular_core.InputSignal<string | undefined>;
+    /** The candidates for the component's own `<img>`, as the platform's `srcset`. */
+    readonly srcset: _angular_core.InputSignal<string | undefined>;
+    /** The platform's `sizes`, beside `srcset`. */
+    readonly sizes: _angular_core.InputSignal<string | undefined>;
+    /**
+     * What the picture shows, or `""` for a picture that is decoration beside
+     * its own text. Written on the component's own `<img>`; a projected
+     * picture carries its own.
+     */
+    readonly alt: _angular_core.InputSignal<string | undefined>;
+    /** The intrinsic width, which with `height` reserves the ratio before the picture loads. */
+    readonly width: _angular_core.InputSignal<string | number | undefined>;
+    readonly height: _angular_core.InputSignal<string | number | undefined>;
+    readonly crossOrigin: _angular_core.InputSignal<"anonymous" | "use-credentials" | undefined>;
+    readonly referrerPolicy: _angular_core.InputSignal<string | undefined>;
+    /**
+     * The proportion the box holds before the picture arrives. Renders an
+     * `slAspectRatio` inside the host and lays the picture out `framed`.
+     */
+    readonly ratio: _angular_core.InputSignal<AspectRatioValue | undefined>;
+    /** Defaults to the provider, then to `intrinsic`; a `ratio` implies `framed` unless one is stated. */
+    readonly layout: _angular_core.InputSignal<ImageLayout | undefined>;
+    /** Defaults to the provider, then to `cover`. */
+    readonly fit: _angular_core.InputSignal<ImageFit | undefined>;
+    /**
+     * A focal point: one of the five names, or any `object-position` value,
+     * written on the instance. Defaults to the provider, then to `center`.
+     */
+    readonly position: _angular_core.InputSignal<ImagePosition | (string & {}) | undefined>;
+    /** Defaults to the provider, then to `none`. */
+    readonly radius: _angular_core.InputSignal<ImageRadius | undefined>;
+    /** A subtle inset edge, for a photograph of a white wall on a white page. */
+    readonly bordered: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
+    /** Defaults to the provider, then to `surface`. */
+    readonly placeholder: _angular_core.InputSignal<ImagePlaceholder | undefined>;
+    /** The small picture `placeholder="blur"` scales and blurs. A data URI, usually. */
+    readonly placeholderSrc: _angular_core.InputSignal<string | undefined>;
+    /**
+     * A second URL to try when `src` fails. The status stays `loading` while
+     * it is tried, and `error` is reached only if it fails too.
+     */
+    readonly fallbackSrc: _angular_core.InputSignal<string | undefined>;
+    /** The `<source>`s of a `<picture>`, in order. The `<img>` is written last. */
+    readonly sources: _angular_core.InputSignal<readonly ImageSource[]>;
+    /** The platform's `loading`. Defaults to the provider, then to `lazy`; `priority` makes it `eager`. */
+    readonly loading: _angular_core.InputSignal<ImageLoading | undefined>;
+    /** The platform's `decoding`. Defaults to the provider, then to `async`. */
+    readonly decoding: _angular_core.InputSignal<ImageDecoding | undefined>;
+    /** The platform's `fetchpriority`. `priority` writes `high` unless one is stated. */
+    readonly fetchPriority: _angular_core.InputSignal<"auto" | "high" | "low" | undefined>;
+    /**
+     * The picture the page is waiting for: `loading="eager"` and
+     * `fetchpriority="high"`, unless either is stated.
+     */
+    readonly priority: _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<ImageStatus | undefined>;
+    /** Reports the derived status. Never emits for a status passed in. */
+    readonly statusChange: _angular_core.OutputEmitterRef<ImageStatus>;
+    private readonly defaults;
+    protected readonly projected: _angular_core.Signal<SlImageMedia | undefined>;
+    protected readonly resolvedLayout: _angular_core.Signal<ImageLayout>;
+    protected readonly resolvedFit: _angular_core.Signal<ImageFit>;
+    protected readonly resolvedRadius: _angular_core.Signal<ImageRadius>;
+    protected readonly resolvedBordered: _angular_core.Signal<boolean>;
+    protected readonly resolvedPlaceholder: _angular_core.Signal<ImagePlaceholder>;
+    protected readonly resolvedLoading: _angular_core.Signal<ImageLoading>;
+    protected readonly resolvedDecoding: _angular_core.Signal<ImageDecoding>;
+    protected readonly resolvedFetchPriority: _angular_core.Signal<"auto" | "high" | "low" | null>;
+    private readonly resolvedPosition;
+    protected readonly positionAttribute: _angular_core.Signal<ImagePositionAttribute>;
+    protected readonly positionToken: _angular_core.Signal<ImagePosition | (string & {}) | null>;
+    /**
+     * 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 inputs 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<ImageStatus>;
+    /** The URL the component's own `<img>` is showing: `src`, or `fallbackSrc` after `src` failed. */
+    protected readonly shownSrc: _angular_core.Signal<string | undefined>;
+    /** Called by the picture, whichever of the two elements it turned out to be. */
+    reportLoaded(): void;
+    /**
+     * The first failure is answered with the second URL when there is one, and
+     * the status stays `loading` while it is tried; `error` is what is left
+     * when nothing could be shown. Only the component's own `<img>` can be
+     * re-pointed: a projected picture belongs to the consumer.
+     */
+    reportError(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlImage, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlImage, "[slImage]", ["slImage"], { "src": { "alias": "src"; "required": false; "isSignal": true; }; "srcset": { "alias": "srcset"; "required": false; "isSignal": true; }; "sizes": { "alias": "sizes"; "required": false; "isSignal": true; }; "alt": { "alias": "alt"; "required": false; "isSignal": true; }; "width": { "alias": "width"; "required": false; "isSignal": true; }; "height": { "alias": "height"; "required": false; "isSignal": true; }; "crossOrigin": { "alias": "crossOrigin"; "required": false; "isSignal": true; }; "referrerPolicy": { "alias": "referrerPolicy"; "required": false; "isSignal": true; }; "ratio": { "alias": "ratio"; "required": false; "isSignal": true; }; "layout": { "alias": "layout"; "required": false; "isSignal": true; }; "fit": { "alias": "fit"; "required": false; "isSignal": true; }; "position": { "alias": "position"; "required": false; "isSignal": true; }; "radius": { "alias": "radius"; "required": false; "isSignal": true; }; "bordered": { "alias": "bordered"; "required": false; "isSignal": true; }; "placeholder": { "alias": "placeholder"; "required": false; "isSignal": true; }; "placeholderSrc": { "alias": "placeholderSrc"; "required": false; "isSignal": true; }; "fallbackSrc": { "alias": "fallbackSrc"; "required": false; "isSignal": true; }; "sources": { "alias": "sources"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "decoding": { "alias": "decoding"; "required": false; "isSignal": true; }; "fetchPriority": { "alias": "fetchPriority"; "required": false; "isSignal": true; }; "priority": { "alias": "priority"; "required": false; "isSignal": true; }; "status": { "alias": "status"; "required": false; "isSignal": true; }; }, { "statusChange": "statusChange"; }, ["projected"], ["img[slImageMedia]", "[slImagePlaceholder]", "[slImageFallback]"], true, never>;
+}
+
+/**
+ * What the picture tells the image 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 image
+ * 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 ImageMediaHost {
+    /** The picture arrived, or was already there. */
+    reportLoaded(): void;
+    /** The picture failed. The host decides whether a second URL is tried. */
+    reportError(): void;
+}
+declare const IMAGE_MEDIA_HOST: InjectionToken<ImageMediaHost>;
+
+/**
+ * Content over the placeholder's ground while the picture is on its way — a
+ * skeleton, a blurhash canvas. A marker rather than a bare `<ng-content>`,
+ * so the slot can be selected by name and nothing else falls into it.
+ */
+declare class SlImagePlaceholder {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlImagePlaceholder, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlImagePlaceholder, "[slImagePlaceholder]", ["slImagePlaceholder"], {}, {}, never, never, true, never>;
+}
+/**
+ * Content of the fallback, in place of the glyph, once the picture has
+ * failed: a message, a retry, a logotype. The glyph is the slot's default
+ * content, so projecting anything here replaces it.
+ */
+declare class SlImageFallback {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlImageFallback, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlImageFallback, "[slImageFallback]", ["slImageFallback"], {}, {}, never, never, true, never>;
+}
+
+export { IMAGE_DEFAULTS, IMAGE_MEDIA_HOST, SlImage, SlImageFallback, SlImageMedia, SlImagePlaceholder, injectImageDefaults, provideImageDefaults };
+export type { ImageDecoding, ImageDefaults, ImageFit, ImageLayout, ImageLoading, ImageMediaHost, ImagePlaceholder, ImagePosition, ImagePositionAttribute, ImageRadius, ImageSource, ImageStatus };
+//# sourceMappingURL=slotted-angular-image.d.ts.map

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

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