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

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

@@ -0,0 +1,197 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, OnInit } from '@angular/core';
+import { ChangeRequest } from '@slotted/core/state';
+import { ControlValueAccessor } from '@angular/forms';
+
+/** The type step the control sits at, matching the group or field around it. */
+type CheckboxSize = 'sm' | 'md' | 'lg';
+/**
+ * Whether the choice is a box beside a line of text or a framed surface whose
+ * whole area is the target. `tile` is the name Carbon and Cloudscape give the
+ * framed choice; Mantine and Chakra call it a card, which is a family here.
+ */
+type CheckboxVariant = 'plain' | 'tile';
+/**
+ * Which side of its own label the box is on. It is never inherited from a
+ * `field`: that family's `labelPlacement` answers where a field's label sits
+ * relative to its control, and a checkbox's label is its own.
+ */
+type CheckboxLabelPlacement = 'end' | 'start';
+interface CheckboxDefaults {
+    labelPlacement: CheckboxLabelPlacement;
+    variant: CheckboxVariant;
+    size: CheckboxSize;
+}
+declare const CHECKBOX_DEFAULTS: InjectionToken<CheckboxDefaults>;
+/**
+ * An application decides once what its checkboxes look like, rather than
+ * repeating the same inputs on every box in a form. A box that states either of
+ * them itself still wins, and so does the group or field around it.
+ */
+declare function provideCheckboxDefaults(defaults: Partial<CheckboxDefaults>): {
+    provide: InjectionToken<CheckboxDefaults>;
+    useFactory: () => CheckboxDefaults;
+};
+/** What a checkbox renders as here, before it states anything of its own. */
+declare function injectCheckboxDefaults(): CheckboxDefaults;
+/**
+ * Application-scoped rather than module-scoped, for the reason `field` records:
+ * a module-level counter produces colliding sequences when two applications
+ * render in one server process, and the server and the client sequences must
+ * match for hydration.
+ */
+declare class SlCheckboxIdFactory {
+    private count;
+    next(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlCheckboxIdFactory, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
+}
+
+/** Why the box moved. A checkbox can produce exactly these two. */
+type CheckboxCheckedReason = 'pointer' | 'keyboard';
+declare class SlCheckbox implements ControlValueAccessor, OnInit {
+    /** Present means the consumer owns the state. */
+    readonly checked: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /** Whether the box starts ticked, when the control is uncontrolled. */
+    readonly defaultChecked: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * The mixed state. It is a state and never a third value of `checked`: the
+     * submitted value stays boolean, and the platform agrees — `indeterminate` is
+     * an IDL property that leaves `checked` alone.
+     */
+    readonly indeterminate: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Commands the whole set its group was given in `allValues`. Outside such a
+     * group it does nothing, because there is no set to command.
+     */
+    readonly parent: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** What this box selects inside a group, and what it submits in a form. */
+    readonly value: _angular_core.InputSignal<string | undefined>;
+    readonly name: _angular_core.InputSignal<string | undefined>;
+    readonly size: _angular_core.InputSignal<CheckboxSize | undefined>;
+    readonly labelPlacement: _angular_core.InputSignal<CheckboxLabelPlacement | undefined>;
+    readonly variant: _angular_core.InputSignal<CheckboxVariant | undefined>;
+    /** Unstated rather than `false`, so the box defers to its group or field. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly readOnly: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly invalid: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /**
+     * One output for one transition, carrying the new state, the state it
+     * replaces, the reason, the originating event and `cancel()`. There is no
+     * `[(checked)]`, because a two-way binding has one slot and can carry none of
+     * those; a form gets the same movement through `ControlValueAccessor`.
+     */
+    readonly checkedChange: _angular_core.OutputEmitterRef<ChangeRequest<boolean>>;
+    private readonly group;
+    private readonly field;
+    private readonly fieldGroup;
+    private readonly defaults;
+    private readonly writtenId;
+    private readonly writtenDescribedBy;
+    private readonly writtenRequired;
+    private readonly element;
+    private readonly label;
+    /**
+     * Whether the label shows nothing: its only content is hidden text, the name
+     * a table row or a data list gives a bare box. Read from the projected DOM,
+     * and read again when it changes.
+     */
+    protected readonly labelHidden: _angular_core.WritableSignal<boolean>;
+    private readonly description;
+    private readonly own;
+    private readonly formDisabled;
+    /** Whether a form directive owns the value through `ControlValueAccessor`. */
+    private readonly formBound;
+    private onChangeFn;
+    private onTouchedFn;
+    /** The identifier the label points at. A consumer's own wins. */
+    readonly controlId: string;
+    /**
+     * Three ways a box can know whether it is ticked, decided by what is around
+     * it rather than by a mode input: a parent reads the whole set, a member
+     * reads whether the selection holds its own value, and a box on its own reads
+     * the consumer's `checked` or the state it keeps.
+     */
+    private readonly isParent;
+    private readonly memberValue;
+    readonly resolvedChecked: _angular_core.Signal<boolean>;
+    readonly resolvedIndeterminate: _angular_core.Signal<boolean>;
+    readonly resolvedSize: _angular_core.Signal<"sm" | "md" | "lg">;
+    readonly resolvedLabelPlacement: _angular_core.Signal<CheckboxLabelPlacement>;
+    /**
+     * One step shorter than `size`: a box states it, else the group around it,
+     * else the provider. It never comes from the field — a field decides how its
+     * own row is laid out, and a framed choice is a decision about the choice.
+     */
+    readonly resolvedVariant: _angular_core.Signal<CheckboxVariant>;
+    readonly resolvedDisabled: _angular_core.Signal<boolean | undefined>;
+    readonly resolvedReadOnly: _angular_core.Signal<boolean | undefined>;
+    readonly resolvedInvalid: _angular_core.Signal<boolean | undefined>;
+    readonly resolvedRequired: _angular_core.Signal<boolean | undefined>;
+    /**
+     * Whether the box keeps its own state and starts it from `defaultChecked`:
+     * nobody passed `checked`, no group holds it, and no form directive bound it.
+     */
+    private readonly ownsDefault;
+    /**
+     * The content attribute `checked`, which is what a native form reset puts
+     * the element back to. A box that owns its state writes `defaultChecked`
+     * there, the attribute React writes for the same prop. A box whose state
+     * belongs to a consumer, a group or a form directive writes its current
+     * state, so a native reset leaves the element showing what its owner holds.
+     */
+    protected readonly defaultAttribute: _angular_core.Signal<"" | null>;
+    protected readonly resolvedName: _angular_core.Signal<string | null>;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    protected readonly ariaInvalid: _angular_core.Signal<"true" | null>;
+    protected readonly ariaReadOnly: _angular_core.Signal<"true" | null>;
+    protected readonly ariaRequired: _angular_core.Signal<"true" | null>;
+    protected readonly disabledAttribute: _angular_core.Signal<"" | null>;
+    /** The element's own attribute, passed through and never written by the family. */
+    protected readonly requiredAttribute: _angular_core.Signal<string | null>;
+    constructor();
+    ngOnInit(): void;
+    /** The native element, for `focus()` and `click()`. */
+    get inputElement(): HTMLInputElement;
+    writeValue(value: boolean | null | undefined): void;
+    registerOnChange(fn: (checked: boolean) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    /**
+     * One handler for the pointer and for `Space`, because the platform fires one
+     * `click` for both — and refusing the default is the only way to refuse a
+     * change a checkbox has no `readonly` to refuse.
+     *
+     * Nothing here writes the element. The HTML standard's canceled activation
+     * behaviour for a checkbox is `checked = !checked` rather than a restore of a
+     * saved value, so a family that corrected the element inside the listener
+     * would have that correction toggled back out from under it. Refusing the
+     * default and letting the platform undo its own pre-click toggle is both
+     * shorter and the only version that is right: it was measured, in the first
+     * run of this family's Angular spec, as a controlled box that stayed ticked
+     * after its consumer had said no.
+     */
+    protected onClick(event: MouseEvent): void;
+    protected onBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlCheckbox, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlCheckbox, "[slCheckbox]", ["slCheckbox"], { "checked": { "alias": "checked"; "required": false; "isSignal": true; }; "defaultChecked": { "alias": "defaultChecked"; "required": false; "isSignal": true; }; "indeterminate": { "alias": "indeterminate"; "required": false; "isSignal": true; }; "parent": { "alias": "parent"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "labelPlacement": { "alias": "labelPlacement"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "readOnly": { "alias": "readOnly"; "required": false; "isSignal": true; }; "invalid": { "alias": "invalid"; "required": false; "isSignal": true; }; }, { "checkedChange": "checkedChange"; }, ["description"], ["*", "[slCheckboxDescription]"], true, never>;
+}
+
+/**
+ * Help text under a box's label.
+ *
+ * It is a directive on the consumer's own element, so a `p`, a `span` or an
+ * `inline-message` all work and none of them loses its own semantics. It
+ * carries an identifier the box points `aria-describedby` at, which is what
+ * makes the sentence a description rather than part of the name — and it is
+ * projected outside the `label` for the same reason.
+ */
+declare class SlCheckboxDescription {
+    readonly id: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlCheckboxDescription, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlCheckboxDescription, "[slCheckboxDescription]", ["slCheckboxDescription"], {}, {}, never, never, true, never>;
+}
+
+export { CHECKBOX_DEFAULTS, SlCheckbox, SlCheckboxDescription, SlCheckboxIdFactory, injectCheckboxDefaults, provideCheckboxDefaults };
+export type { CheckboxCheckedReason, CheckboxDefaults, CheckboxLabelPlacement, CheckboxSize };
+//# sourceMappingURL=slotted-angular-checkbox.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-checkbox.d.ts","sources":["../../checkbox/src/checkbox-defaults.ts","../../checkbox/src/checkbox.ts","../../checkbox/src/checkbox-parts.ts"],"mappings":";;;;;AAEA;AACM,KAAM,YAAY;AAExB;;;;AAIG;KACS,eAAe;AAE3B;;;;AAIG;KACS,sBAAsB;UAEjB,gBAAgB;oBACf,sBAAsB;aAC7B,eAAe;UAClB,YAAY;AACnB;AAID,cAAa,iBAAiB,EAAA,cAAA,CAAA,gBAAA;AAK9B;;;;AAIG;AACH,iBAAgB,uBAAuB,WAAW,OAAO,CAAC,gBAAgB;;sBAGtD,gBAAgB;AAEnC;AAED;AACA,iBAAgB,sBAAsB,IAAI,gBAAgB;AAI1D;;;;;AAKG;AACH,cACa,mBAAmB;;;oDAAnB,mBAAmB;;AAO/B;;ACvBD;KACY,qBAAqB;AA2CjC,cAgDa,UAAW,YAAW,oBAAoB,EAAE,MAAM;;sBAE7C,aAAA,CAAA,wBAAA;;6BAIO,aAAA,CAAA,wBAAA;AACvB;;;;AAIG;4BACmB,aAAA,CAAA,wBAAA;AACtB;;;AAGG;qBACY,aAAA,CAAA,wBAAA;;oBAED,aAAA,CAAA,WAAA;mBACD,aAAA,CAAA,WAAA;mBACA,aAAA,CAAA,WAAA,CAAA,YAAA;6BACU,aAAA,CAAA,WAAA,CAAA,sBAAA;sBACP,aAAA,CAAA,WAAA,CAAA,eAAA;;uBAEC,aAAA,CAAA,wBAAA;uBAGA,aAAA,CAAA,wBAAA;sBAGD,aAAA,CAAA,wBAAA;AAIhB;;;;;AAKG;4BACmB,aAAA,CAAA,gBAAA,CAAA,aAAA;AAEtB;AACA;AACA;AACA;AACA;AACA;AAGA;AAIA;AACA;AACA;;;;AAIG;AACH,oCAA8B,aAAA,CAAA,cAAA;AAC9B;AAEA;AACA;;AAEA;;;;;AAOA;;;;;AAKG;AACH;AACA;8BAIwB,aAAA,CAAA,MAAA;oCAWM,aAAA,CAAA,MAAA;2BAOT,aAAA,CAAA,MAAA;qCAQU,aAAA,CAAA,MAAA,CAAA,sBAAA;AAI/B;;;;AAIG;8BACqB,aAAA,CAAA,MAAA,CAAA,eAAA;+BAGC,aAAA,CAAA,MAAA;+BAOA,aAAA,CAAA,MAAA;8BAGD,aAAA,CAAA,MAAA;+BAGC,aAAA,CAAA,MAAA;AAIzB;;;AAGG;AACH;AAGA;;;;;;AAMG;AACH,yCAAmC,aAAA,CAAA,MAAA;AAInC,qCAA+B,aAAA,CAAA,MAAA;AAC/B,oCAA8B,aAAA,CAAA,MAAA;AAQ9B,oCAA8B,aAAA,CAAA,MAAA;AAG9B,qCAA+B,aAAA,CAAA,MAAA;AAG/B,qCAA+B,aAAA,CAAA,MAAA;AAG/B,0CAAoC,aAAA,CAAA,MAAA;;AAIpC,0CAAoC,aAAA,CAAA,MAAA;;;;wBA0ChB,gBAAgB;AAIpC;;AASA;;AAQA;;;;;;;;;;;;;AAaG;AACH,6BAAyB,UAAU;AA+CnC;oDAjTW,UAAU;sDAAV,UAAU;AAqTtB;;ACrbD;;;;;;;;AAQG;AACH,cASa,qBAAqB;;oDAArB,qBAAqB;sDAArB,qBAAqB;AAEjC;;","names":[]}

package/types/slotted-angular-code-block.d.ts

@@ -0,0 +1,158 @@
+import * as _slotted_core_code from '@slotted/core/code';
+import { CodeHighlighter, CodeLine, LineMark, CodeMarks } from '@slotted/core/code';
+import * as _slotted_core_i18n from '@slotted/core/i18n';
+import { PartialMessages, CodeBlockMessages } from '@slotted/core/i18n';
+import * as _angular_core from '@angular/core';
+import { InjectionToken, TemplateRef } from '@angular/core';
+import { ChangeRequest } from '@slotted/core/state';
+import { ScrollEdgesState } from '@slotted/angular/scroll-area';
+
+type CodeBlockWrapReason = 'pointer' | 'keyboard' | 'programmatic';
+type CodeBlockRevealedReason = 'pointer' | 'keyboard' | 'escape' | 'programmatic';
+
+interface CodeBlockCopyRequest {
+    readonly value: string;
+    readonly reason: 'pointer' | 'keyboard';
+    readonly copied: boolean;
+    readonly source?: Event | undefined;
+}
+interface CodeBlockDefaults {
+    highlight?: CodeHighlighter;
+    lineNumbers?: boolean;
+    copy?: boolean;
+}
+declare const CODE_BLOCK_DEFAULTS_TOKEN: InjectionToken<CodeBlockDefaults>;
+/**
+ * An application that has loaded an engine once hands it to every block here,
+ * along with whether blocks number their lines and carry a copy control. A
+ * block that states any of those itself still wins. Its words come from the
+ * language in force (`provideSlotted`).
+ */
+declare function provideCodeBlockDefaults(defaults: CodeBlockDefaults): {
+    provide: InjectionToken<CodeBlockDefaults>;
+    useValue: CodeBlockDefaults;
+};
+declare function injectCodeBlockDefaults(): CodeBlockDefaults;
+
+/** A control of the consumer's own, projected beside copy and wrap. */
+declare class SlCodeBlockAction {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlCodeBlockAction, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlCodeBlockAction, "[slCodeBlockAction]", never, {}, {}, never, never, true, never>;
+}
+/** What a `slCodeBlockLine` template is handed for one line. */
+interface CodeBlockLineContext {
+    $implicit: CodeLine;
+    number: number;
+    mark: LineMark['mark'];
+    dim: boolean;
+}
+/** Replaces the run of tokens a line draws. The gutter stays the family's. */
+declare class SlCodeBlockLine {
+    readonly template: TemplateRef<CodeBlockLineContext>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlCodeBlockLine, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlCodeBlockLine, "ng-template[slCodeBlockLine]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * A block of source: a header that names the file and holds the two controls,
+ * a body that is a `scroll-area`, and inside it a `pre` whose every line is a
+ * grid row. Tokens come in from an engine outside the family and are drawn as
+ * text in spans; HTML never does.
+ */
+declare class SlCodeBlock {
+    /** The source, as text. Never HTML. */
+    readonly code: _angular_core.InputSignal<string>;
+    readonly language: _angular_core.InputSignal<string>;
+    /** The engine, outside the family. `null` refuses the one the provider set. */
+    readonly highlight: _angular_core.InputSignal<CodeHighlighter | null | undefined>;
+    /** Already-tokenised lines, when the consumer ran the engine itself. */
+    readonly tokens: _angular_core.InputSignal<readonly CodeLine[] | undefined>;
+    readonly title: _angular_core.InputSignal<string | undefined>;
+    /** The file's name, for the glyph beside the title. Defaults to `title`. */
+    readonly fileName: _angular_core.InputSignal<string | undefined>;
+    readonly lineNumbers: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly start: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly marks: _angular_core.InputSignal<CodeMarks | undefined>;
+    /** Present is controlled, for the life of the block. */
+    readonly wrap: _angular_core.ModelSignal<boolean | undefined>;
+    /** Where an uncontrolled block starts, read once. */
+    readonly defaultWrap: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly collapseAfter: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    readonly revealed: _angular_core.ModelSignal<boolean | undefined>;
+    readonly defaultRevealed: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly isWrapped: _angular_core.Signal<boolean>;
+    readonly isRevealed: _angular_core.Signal<boolean>;
+    readonly maxLines: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    readonly copy: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly copyRemoved: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Words laid over the catalog of the language in force, key by key: the
+     * scroll region's name when the block has no title (`region`), the controls,
+     * and the announcements.
+     */
+    readonly messages: _angular_core.InputSignal<PartialMessages<CodeBlockMessages> | undefined>;
+    readonly tabSize: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** The request behind a wrap change, with the reason it carries. */
+    readonly wrapChangeRequest: _angular_core.OutputEmitterRef<ChangeRequest<boolean>>;
+    readonly revealedChangeRequest: _angular_core.OutputEmitterRef<ChangeRequest<boolean>>;
+    /** What the copy control wrote, and whether the platform took it. */
+    readonly copyRequest: _angular_core.OutputEmitterRef<CodeBlockCopyRequest>;
+    readonly highlightError: _angular_core.OutputEmitterRef<unknown>;
+    private readonly defaults;
+    private readonly host;
+    private readonly destroyRef;
+    private readonly ariaLabel;
+    private readonly body;
+    protected readonly lineTemplate: _angular_core.Signal<SlCodeBlockLine | undefined>;
+    private readonly action;
+    readonly id: string;
+    protected readonly skeletonWidths: number[];
+    /** The family's words in the language in force, with this block's `messages` laid over them. */
+    readonly t: _slotted_core_i18n.FamilyTranslator<CodeBlockMessages>;
+    protected readonly lineNumbersValue: _angular_core.Signal<boolean>;
+    protected readonly copyControl: _angular_core.Signal<boolean>;
+    private readonly engine;
+    private readonly resolved;
+    protected readonly copied: _angular_core.WritableSignal<boolean>;
+    protected readonly overflow: _angular_core.WritableSignal<boolean>;
+    private timer;
+    private keyed;
+    private readonly lines;
+    private readonly marksByLine;
+    protected readonly hasMarks: _angular_core.Signal<boolean>;
+    protected readonly rows: _angular_core.Signal<{
+        dim: boolean;
+        indent: number;
+        mark: _slotted_core_code.CodeMark | undefined;
+        number: number;
+        tokens: CodeLine;
+    }[]>;
+    protected readonly digits: _angular_core.Signal<number>;
+    protected readonly collapses: _angular_core.Signal<boolean>;
+    protected readonly hiddenCount: _angular_core.Signal<number>;
+    protected readonly hasHeader: _angular_core.Signal<boolean>;
+    protected readonly icon: _angular_core.Signal<"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" | undefined>;
+    protected readonly regionName: _angular_core.Signal<string>;
+    constructor();
+    protected onOverflow(state: ScrollEdgesState): void;
+    /** `Enter` and `Space` both end in a click; whether a key came first decides the reason. */
+    protected remember(event: KeyboardEvent): void;
+    private takeReason;
+    protected toggleWrap(event?: Event): void;
+    requestWrap(next: boolean, reason: CodeBlockWrapReason, source?: Event): void;
+    protected toggleRevealed(event?: Event): void;
+    requestRevealed(next: boolean, reason: CodeBlockRevealedReason, source?: Event): void;
+    protected onKeyDown(event: KeyboardEvent): void;
+    protected copyFromControl(event: Event): void;
+    /** Writes the code to the clipboard, as the control does. */
+    copyCode(): Promise<boolean>;
+    private write;
+    /** Brings a one-based line into view. */
+    scrollToLine(line: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlCodeBlock, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlCodeBlock, "[slCodeBlock]", ["slCodeBlock"], { "code": { "alias": "code"; "required": true; "isSignal": true; }; "language": { "alias": "language"; "required": false; "isSignal": true; }; "highlight": { "alias": "highlight"; "required": false; "isSignal": true; }; "tokens": { "alias": "tokens"; "required": false; "isSignal": true; }; "title": { "alias": "title"; "required": false; "isSignal": true; }; "fileName": { "alias": "fileName"; "required": false; "isSignal": true; }; "lineNumbers": { "alias": "lineNumbers"; "required": false; "isSignal": true; }; "start": { "alias": "start"; "required": false; "isSignal": true; }; "marks": { "alias": "marks"; "required": false; "isSignal": true; }; "wrap": { "alias": "wrap"; "required": false; "isSignal": true; }; "defaultWrap": { "alias": "defaultWrap"; "required": false; "isSignal": true; }; "collapseAfter": { "alias": "collapseAfter"; "required": false; "isSignal": true; }; "revealed": { "alias": "revealed"; "required": false; "isSignal": true; }; "defaultRevealed": { "alias": "defaultRevealed"; "required": false; "isSignal": true; }; "maxLines": { "alias": "maxLines"; "required": false; "isSignal": true; }; "copy": { "alias": "copy"; "required": false; "isSignal": true; }; "copyRemoved": { "alias": "copyRemoved"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; "tabSize": { "alias": "tabSize"; "required": false; "isSignal": true; }; }, { "wrap": "wrapChange"; "revealed": "revealedChange"; "wrapChangeRequest": "wrapChangeRequest"; "revealedChangeRequest": "revealedChangeRequest"; "copyRequest": "copyRequest"; "highlightError": "highlightError"; }, ["lineTemplate", "action"], ["[slCodeBlockAction]"], true, never>;
+}
+
+export { CODE_BLOCK_DEFAULTS_TOKEN, SlCodeBlock, SlCodeBlockAction, SlCodeBlockLine, injectCodeBlockDefaults, provideCodeBlockDefaults };
+export type { CodeBlockCopyRequest, CodeBlockDefaults, CodeBlockLineContext, CodeBlockRevealedReason, CodeBlockWrapReason };
+//# sourceMappingURL=slotted-angular-code-block.d.ts.map

package/types/slotted-angular-code-block.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-code-block.d.ts","sources":["../../code-block/src/code-block.constants.ts","../../code-block/src/code-block.ts"],"mappings":";;;;;;;;;AAGM,KAAM,mBAAmB;AACzB,KAAM,uBAAuB;;UAGlB,oBAAoB;AACnC;AACA;AACA;AACA,sBAAkB,KAAK;AACxB;UAEgB,iBAAiB;gBACpB,eAAe;;;AAG5B;AAED,cAAa,yBAAyB,EAAA,cAAA,CAAA,iBAAA;AAKtC;;;;;AAKG;AACH,iBAAgB,wBAAwB,WAAW,iBAAiB;;;AAEnE;AAED,iBAAgB,uBAAuB,IAAI,iBAAiB;;ACqC5D;AACA,cACa,iBAAiB;oDAAjB,iBAAiB;sDAAjB,iBAAiB;AAAG;AAEjC;UACiB,oBAAoB;eACxB,QAAQ;;AAEnB,UAAM,QAAQ;;AAEf;AAED;AACA,cACa,eAAe;uBACT,WAAA,CAAA,oBAAA;oDADN,eAAe;sDAAf,eAAe;AAE3B;AAED;;;;;AAKG;AACH,cAyGa,WAAW;;mBAET,aAAA,CAAA,WAAA;uBACI,aAAA,CAAA,WAAA;;wBAEC,aAAA,CAAA,WAAA,CAAA,eAAA;;qBAEH,aAAA,CAAA,WAAA,UAAA,QAAA;oBACD,aAAA,CAAA,WAAA;;uBAEG,aAAA,CAAA,WAAA;0BACG,aAAA,CAAA,wBAAA;oBAGN,aAAA,CAAA,wBAAA;oBACA,aAAA,CAAA,WAAA,CAAA,SAAA;;mBAED,aAAA,CAAA,WAAA;;0BAEO,aAAA,CAAA,wBAAA;4BACE,aAAA,CAAA,wBAAA;uBAGL,aAAA,CAAA,WAAA;8BACO,aAAA,CAAA,wBAAA;wBACN,aAAA,CAAA,MAAA;yBACC,aAAA,CAAA,MAAA;uBACF,aAAA,CAAA,wBAAA;mBAGJ,aAAA,CAAA,wBAAA;0BAGO,aAAA,CAAA,wBAAA;sBACJ,aAAA,CAAA,wBAAA;AAChB;;;;AAIG;uBACc,aAAA,CAAA,WAAA,CAAA,eAAA,CAAA,iBAAA;sBACD,aAAA,CAAA,wBAAA;;gCAGU,aAAA,CAAA,gBAAA,CAAA,aAAA;oCACI,aAAA,CAAA,gBAAA,CAAA,aAAA;;0BAEV,aAAA,CAAA,gBAAA,CAAA,oBAAA;6BACG,aAAA,CAAA,gBAAA;AAEvB;AACA;AACA;AACA;AACA;AACA,qCAA+B,aAAA,CAAA,MAAA,CAAA,eAAA;AAC/B;;AAGA;;gBAGU,kBAAA,CAAA,gBAAA,CAAA,iBAAA;AACV,yCAAmC,aAAA,CAAA,MAAA;AAGnC,oCAA8B,aAAA,CAAA,MAAA;AAC9B;AAKA;AACA,+BAAyB,aAAA,CAAA,cAAA;AACzB,iCAA2B,aAAA,CAAA,cAAA;;;AAI3B;AAOA;AACA,iCAA2B,aAAA,CAAA,MAAA;6BAIJ,aAAA,CAAA,MAAA;;;;;;AAYpB;AAEH,+BAAyB,aAAA,CAAA,MAAA;AACzB,kCAA4B,aAAA,CAAA,MAAA;AAI5B,oCAA8B,aAAA,CAAA,MAAA;AAG9B,kCAA4B,aAAA,CAAA,MAAA;AAO5B,6BAAuB,aAAA,CAAA,MAAA;AAKvB,mCAA6B,aAAA,CAAA,MAAA;;AA2B7B,gCAA4B,gBAAgB;;AAK5C,8BAA0B,aAAa;AAIvC;AAMA,iCAA6B,KAAK;AAIlC,uCAAmC,mBAAmB,WAAW,KAAK;AAQtE,qCAAiC,KAAK;AAItC,2CAAuC,uBAAuB,WAAW,KAAK;AAQ9E,+BAA2B,aAAa;AAQxC,qCAAiC,KAAK;;AAKtC,gBAAY,OAAO;;;;oDA3MR,WAAW;sDAAX,WAAW;AAmOvB;;","names":[]}

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

@@ -0,0 +1,272 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, OnInit, TemplateRef } from '@angular/core';
+import { ChangeRequest } from '@slotted/core/state';
+import * as _slotted_angular_collapsible from '@slotted/angular/collapsible';
+
+/** The type step the header and its panel sit at. */
+type CollapsibleSize = 'sm' | 'md' | 'lg';
+/**
+ * How the disclosure is drawn. `plain` paints no chrome at all, `ruled` draws a
+ * hairline above the header so a stack of them reads as one list, and `framed`
+ * is its own card.
+ */
+type CollapsibleVariant = 'plain' | 'ruled' | 'framed';
+/**
+ * The mark that says whether the panel is open. `chevron` turns between down
+ * and up, `plus-minus` swaps the one bar for the pair, and `none` draws nothing
+ * — which is Angular Material's `hideToggle` and Carbon's chevron-less header.
+ */
+type CollapsibleIndicator = 'chevron' | 'plus-minus' | 'none';
+/** Which side of the words the mark stands on. */
+type CollapsibleTogglePlacement = 'end' | 'start';
+/**
+ * The heading level the header answers to. `none` writes no heading semantics
+ * at all, which is the standalone disclosure that belongs to no outline.
+ *
+ * The element is the consumer's own: `<h3 slCollapsibleHeader>` is a native
+ * heading and the directive adds nothing, while `<div slCollapsibleHeader>`
+ * gets `role="heading"` and `aria-level` — the alternative the pattern itself
+ * names. React reads the element off this value instead, and the two reach the
+ * same accessibility tree.
+ */
+type CollapsibleLevel = 'none' | '1' | '2' | '3' | '4' | '5' | '6';
+/**
+ * When the panel's content exists. The box always does, so the trigger's
+ * `aria-controls` never names an element that is gone.
+ */
+type CollapsibleMount = 'active' | 'lazy' | 'eager' | 'until-found';
+/** Why the panel opened or closed. */
+type CollapsibleOpenReason = 'pointer' | 'keyboard' | 'select' | 'programmatic';
+interface CollapsibleDefaults {
+    indicator: CollapsibleIndicator;
+    level: CollapsibleLevel;
+    mount: CollapsibleMount;
+    size: CollapsibleSize;
+    togglePlacement: CollapsibleTogglePlacement;
+    truncate: boolean;
+    variant: CollapsibleVariant;
+}
+declare const COLLAPSIBLE_DEFAULTS: InjectionToken<CollapsibleDefaults>;
+/**
+ * An application decides once how its disclosures look, rather than repeating
+ * the same seven inputs on every one in a product. A disclosure that states any
+ * of them itself still wins, and so does the accordion between the two.
+ */
+declare function provideCollapsibleDefaults(defaults: Partial<CollapsibleDefaults>): {
+    provide: InjectionToken<CollapsibleDefaults>;
+    useFactory: () => CollapsibleDefaults;
+};
+/** What a disclosure renders as here, before it states anything of its own. */
+declare function injectCollapsibleDefaults(): CollapsibleDefaults;
+/**
+ * Application-scoped rather than module-scoped, for the reason `field` records:
+ * a module-level counter produces colliding sequences when two applications
+ * render in one server process, and the server and the client sequences must
+ * match for hydration.
+ */
+declare class SlCollapsibleIdFactory {
+    private count;
+    next(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlCollapsibleIdFactory, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
+}
+
+/** The trigger of one disclosure, in the order the DOM holds them. */
+declare const COLLAPSIBLE_TRIGGER_SELECTOR = "[data-part=\"trigger\"]";
+/**
+ * One disclosure: a header the reader operates and a panel it controls.
+ *
+ * **The keyboard is the platform's.** The trigger is a `button`, so `Enter` and
+ * `Space` toggle without the family binding a key, and every trigger stays in
+ * the page tab sequence — which is what the APG's accordion pattern requires
+ * and what `w3c/aria-practices#3434` removed the roving alternative for.
+ *
+ * **The panel opens without being measured.** The stylesheet transitions a grid
+ * track between `0fr` and `1fr`, so the height is the content's own at every
+ * frame. Radix, Base UI, Ark and Angular Material each read the layout and
+ * write a custom property, which is wrong for one frame on the server and stale
+ * until a resize observer fires.
+ *
+ * **Inside an `slAccordion` the value belongs to the set.** The disclosure then
+ * reports its own request as well, so a consumer may watch one panel without
+ * unpacking the set's array.
+ */
+declare class SlCollapsible implements OnInit {
+    /** Whether the panel is open. Two-way, so a template may bind it directly. */
+    readonly open: _angular_core.ModelSignal<boolean>;
+    /**
+     * What this disclosure is called inside an accordion. It is identity rather
+     * than state — the state model is `open` — and the set's array holds it. One
+     * that states none is given one from the id factory.
+     */
+    readonly value: _angular_core.InputSignal<string | undefined>;
+    /** Unstated rather than false, so the disclosure defers to the set around it. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /**
+     * Whether the panel's content is still on its way. The panel keeps a line's
+     * height and carries `aria-busy`; what stands in for the content is
+     * `slSkeleton`, composed by the consumer.
+     */
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Whether the panel is a `region` landmark. Off by default: the APG's own
+     * example warns that a landmark per panel fills the landmark list.
+     */
+    readonly region: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly size: _angular_core.InputSignal<CollapsibleSize | undefined>;
+    readonly variant: _angular_core.InputSignal<CollapsibleVariant | undefined>;
+    readonly indicator: _angular_core.InputSignal<CollapsibleIndicator | undefined>;
+    readonly togglePlacement: _angular_core.InputSignal<CollapsibleTogglePlacement | undefined>;
+    readonly level: _angular_core.InputSignal<CollapsibleLevel | undefined>;
+    readonly mount: _angular_core.InputSignal<CollapsibleMount | undefined>;
+    readonly truncate: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /** One output for one transition, carrying the reason and the event. */
+    readonly openChangeRequest: _angular_core.OutputEmitterRef<ChangeRequest<boolean>>;
+    private readonly defaults;
+    /** The set this disclosure is in, or nothing: a standalone one is complete. */
+    private readonly group;
+    private readonly generated;
+    readonly identity: _angular_core.Signal<string>;
+    /**
+     * Three owners, in one order. The set's value wins over the disclosure's own
+     * `open` because the set is what a consumer wrote when they wrote an
+     * accordion; a disclosure standing alone owns the value outright.
+     */
+    readonly isOpen: _angular_core.Signal<boolean>;
+    /** Whether the set refuses to let this one close, which the APG marks. */
+    readonly held: _angular_core.Signal<boolean>;
+    readonly resolvedDisabled: _angular_core.Signal<boolean>;
+    readonly resolvedSize: _angular_core.Signal<CollapsibleSize>;
+    readonly resolvedVariant: _angular_core.Signal<CollapsibleVariant>;
+    readonly resolvedIndicator: _angular_core.Signal<CollapsibleIndicator>;
+    readonly resolvedTogglePlacement: _angular_core.Signal<CollapsibleTogglePlacement>;
+    readonly resolvedLevel: _angular_core.Signal<CollapsibleLevel>;
+    readonly resolvedMount: _angular_core.Signal<CollapsibleMount>;
+    readonly resolvedTruncate: _angular_core.Signal<boolean>;
+    /** Whether this panel has ever been open, which is what `lazy` reads. */
+    private readonly everOpened;
+    readonly seen: _angular_core.Signal<boolean>;
+    ngOnInit(): void;
+    /** The identifiers that wire the trigger to its panel. */
+    ids(): {
+        panelId: string;
+        triggerId: string;
+    };
+    /**
+     * Asks to open or close. The set is asked after this disclosure's own
+     * consumer has had the chance to refuse; it owns the array, so it decides
+     * what `multiple` and `requireOpen` make of the request.
+     */
+    toggle(next: boolean, reason: CollapsibleOpenReason, source?: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlCollapsible, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlCollapsible, "[slCollapsible]", ["slCollapsible"], { "open": { "alias": "open"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "region": { "alias": "region"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "indicator": { "alias": "indicator"; "required": false; "isSignal": true; }; "togglePlacement": { "alias": "togglePlacement"; "required": false; "isSignal": true; }; "level": { "alias": "level"; "required": false; "isSignal": true; }; "mount": { "alias": "mount"; "required": false; "isSignal": true; }; "truncate": { "alias": "truncate"; "required": false; "isSignal": true; }; }, { "open": "openChange"; "openChangeRequest": "openChangeRequest"; }, never, ["*"], true, never>;
+}
+
+/**
+ * The heading the trigger lives in.
+ *
+ * The element is the consumer's own, which is what this ecosystem composes
+ * with: `<h3 slCollapsibleHeader>` is a native heading and this adds nothing to
+ * it, while `<div slCollapsibleHeader>` gets `role="heading"` and the level the
+ * disclosure resolved. The pattern names both — "if the native host language
+ * has an element with an implicit heading and aria-level … a native host
+ * language element may be used" — and React reads the element off `level`
+ * instead, because there the component owns the tag.
+ *
+ * The trigger is meant to be its only child: the pattern requires the button to
+ * be the only element inside the heading, which is why the always-visible
+ * controls go in `slCollapsibleActions` beside it.
+ */
+declare class SlCollapsibleHeader {
+    private readonly collapsible;
+    private readonly native;
+    /** Whether the consumer already wrote a heading, in which case ARIA adds nothing. */
+    private readonly isNativeHeading;
+    protected readonly ariaRole: _angular_core.Signal<"heading" | null>;
+    protected readonly ariaLevel: _angular_core.Signal<_slotted_angular_collapsible.CollapsibleLevel | null>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlCollapsibleHeader, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlCollapsibleHeader, "[slCollapsibleHeader]", ["slCollapsibleHeader"], {}, {}, never, never, true, never>;
+}
+/**
+ * The control.
+ *
+ * It is the consumer's own `button`, so `Enter` and `Space` are the platform's
+ * and the family binds no key of its own. The mark, the words and the second
+ * line are the component's, because all three are parts the stylesheet places.
+ */
+declare class SlCollapsibleTrigger {
+    protected readonly collapsible: SlCollapsible;
+    /**
+     * A second line under the title. It is inside the trigger, so it is part of
+     * the accessible name — "Entrega, 3 de 12 itens" is what a reader hears.
+     */
+    readonly description: _angular_core.InputSignal<string | undefined>;
+    /**
+     * The chevron is one glyph the stylesheet turns; plus and minus are two, so
+     * the state picks between them here.
+     */
+    protected readonly indicatorGlyph: _angular_core.Signal<"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">;
+    protected ids(): {
+        panelId: string;
+        triggerId: string;
+    };
+    protected onClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlCollapsibleTrigger, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlCollapsibleTrigger, "button[slCollapsibleTrigger]", ["slCollapsibleTrigger"], { "description": { "alias": "description"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+/**
+ * The always-visible controls beside the header.
+ *
+ * They are a sibling of the heading rather than a child of it, for two reasons
+ * that agree: the pattern requires the button to be the only element inside the
+ * heading, and a control inside a `button` is invalid HTML. What belongs here is
+ * an `slToolbar` — one tab stop for however many actions the page puts there.
+ */
+declare class SlCollapsibleActions {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlCollapsibleActions, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlCollapsibleActions, "[slCollapsibleActions]", ["slCollapsibleActions"], {}, {}, never, never, true, never>;
+}
+/**
+ * Content built the first time the panel opens.
+ *
+ * `<ng-content>` is instantiated by the parent whether or not it is inserted,
+ * so `mount="lazy"` needs a template rather than projection. It is Angular
+ * Material's own `matExpansionPanelContent`, and it is the answer this
+ * ecosystem already knows.
+ */
+declare class SlCollapsibleContent {
+    readonly template: TemplateRef<any>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlCollapsibleContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlCollapsibleContent, "ng-template[slCollapsibleContent]", ["slCollapsibleContent"], {}, {}, never, never, true, never>;
+}
+/**
+ * The panel.
+ *
+ * The box always exists, so the trigger's `aria-controls` never names an
+ * element that is gone; `mount` decides whether the content inside it does.
+ *
+ * While the panel is closed it is taken out of the tab sequence and out of the
+ * accessibility tree twice over: the stylesheet with `content-visibility`, and
+ * this component with `inert`, so a browser without the property still cannot
+ * put focus inside it. `mount="until-found"` writes `hidden="until-found"`
+ * instead, and the browser removes that attribute itself when its page search
+ * reaches the text inside — `beforematch` is what asks the family to open, with
+ * the one reason the closed vocabulary holds for a move the browser made.
+ */
+declare class SlCollapsiblePanel {
+    protected readonly collapsible: SlCollapsible;
+    protected readonly deferred: _angular_core.Signal<SlCollapsibleContent | undefined>;
+    private readonly native;
+    protected readonly mounted: _angular_core.Signal<boolean>;
+    constructor();
+    protected ids(): {
+        panelId: string;
+        triggerId: string;
+    };
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlCollapsiblePanel, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlCollapsiblePanel, "[slCollapsiblePanel]", ["slCollapsiblePanel"], {}, {}, ["deferred"], ["*"], true, never>;
+}
+
+export { COLLAPSIBLE_DEFAULTS, COLLAPSIBLE_TRIGGER_SELECTOR, SlCollapsible, SlCollapsibleActions, SlCollapsibleContent, SlCollapsibleHeader, SlCollapsibleIdFactory, SlCollapsiblePanel, SlCollapsibleTrigger, injectCollapsibleDefaults, provideCollapsibleDefaults };
+export type { CollapsibleDefaults, CollapsibleIndicator, CollapsibleLevel, CollapsibleMount, CollapsibleOpenReason, CollapsibleSize, CollapsibleTogglePlacement, CollapsibleVariant };
+//# sourceMappingURL=slotted-angular-collapsible.d.ts.map