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

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

@@ -0,0 +1,171 @@
+import * as i0 from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import * as _slotted_core_i18n from '@slotted/core/i18n';
+import { PartialMessages, ProseMessages } from '@slotted/core/i18n';
+
+/**
+ * The type-scale step the body text takes. Named for the scale's own steps, as
+ * `slText` names its own, so the offset from control type is visible rather
+ * than hidden: `lg` is one rem, and `--slotted-font-size-md` is the size a
+ * button label is set in.
+ */
+type ProseSize = 'md' | 'lg' | 'xl';
+/**
+ * The space between blocks, from which every other distance in the region
+ * derives. `tight` is a message in a thread, `normal` a documentation page,
+ * `loose` an article.
+ */
+type ProseFlow = 'tight' | 'normal' | 'loose';
+interface ProseDefaults {
+    flow: ProseFlow;
+    size: ProseSize;
+}
+declare const PROSE_DEFAULTS: InjectionToken<ProseDefaults>;
+/**
+ * An application decides once how its rendered content reads — Typeset's
+ * presets, as a provider rather than as a class. A region that states any of
+ * them itself still wins: an explicit input is never overridden by the token.
+ */
+declare function provideProseDefaults(defaults: Partial<ProseDefaults>): {
+    provide: InjectionToken<ProseDefaults>;
+    useFactory: () => ProseDefaults;
+};
+/** What a region is set in here, before it states anything of its own. */
+declare function injectProseDefaults(): ProseDefaults;
+
+/**
+ * The typography of a region the application did not author element by
+ * element. The tree arrives from a Markdown renderer, a CMS or a language
+ * model, and the page never gets to put an attribute on the `h2`.
+ *
+ * Text the application does author is `slText` and `slHeading`: those carry a
+ * size, a weight and a tone per element, and wrapping two authored paragraphs
+ * in this family is choosing a recipe over a decision. The boundary is who
+ * wrote the tags.
+ *
+ * It does not sanitise. The renderer that produced the tree is where a
+ * sanitiser belongs, and a component that both styled and sanitised would hide
+ * which of the two failed.
+ *
+ * The selector is an attribute, so the page keeps its own element: a `div`
+ * claims nothing, and `article`, `section` or `main` is a claim the page
+ * makes. Measure is not painted here either — `slContainer` owns it, and one
+ * element composes the two:
+ *
+ * ```html
+ * <div slContainer size="measure"><article slProse [innerHTML]="rendered"></article></div>
+ * ```
+ */
+declare class SlProse {
+    /** The type-scale step the body text takes. Falls back to the token. */
+    readonly size: i0.InputSignal<ProseSize | undefined>;
+    /** The space between blocks, from which every other distance derives. */
+    readonly flow: i0.InputSignal<ProseFlow | undefined>;
+    private readonly defaults;
+    protected readonly resolvedSize: i0.Signal<ProseSize>;
+    protected readonly resolvedFlow: i0.Signal<ProseFlow>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlProse, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlProse, "[slProse]", ["slProse"], { "size": { "alias": "size"; "required": false; "isSignal": true; }; "flow": { "alias": "flow"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * The opening paragraph, one step up and in the muted tone. Tailwind's
+ * equivalent is a class the author writes into the Markdown; this is a part,
+ * so it is contract and it is selectable.
+ */
+declare class SlProseLead {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlProseLead, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlProseLead, "[slProseLead]", ["slProseLead"], {}, {}, never, never, true, never>;
+}
+/**
+ * A heading's permalink. The destination is the consumer's —
+ * `rehype-autolink-headings` writes it — and the family owns where it sits,
+ * how large its target is, and the rule that it appears on hover **and** on
+ * focus. It is hidden with opacity, never with `display: none`, so a keyboard
+ * reader can reach it and a screen reader can announce it.
+ */
+declare class SlProseAnchor {
+    private readonly host;
+    private readonly renderer;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlProseAnchor, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlProseAnchor, "[slProseAnchor]", ["slProseAnchor"], {}, {}, never, never, true, never>;
+}
+/**
+ * A subtree the family does not style. Every content rule carries a guard
+ * against this part and everything under it, and the four properties
+ * inheritance still carried in — family, size, leading and wrapping — are
+ * returned to control type here.
+ *
+ * Tailwind's `not-prose` and Typeset's `not-typeset` both leave the inherited
+ * type in place, so a card inside a large region is set in the region's text.
+ */
+declare class SlProseExclude {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlProseExclude, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlProseExclude, "[slProseExclude]", ["slProseExclude"], {}, {}, never, never, true, never>;
+}
+/** What GitHub Flavored Markdown emits at the end of a document. */
+declare class SlProseFootnotes {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlProseFootnotes, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlProseFootnotes, "[slProseFootnotes]", ["slProseFootnotes"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * A wide block — a table, a fence — that scrolls sideways instead of pushing
+ * the page over. The axe rule `scrollable-region-focusable` makes that a WCAG
+ * 2.2 level A failure unless a keyboard can reach it, and anything that takes
+ * focus then needs a name and a role or it fails SC 4.1.2. Adrian Roselli's
+ * pattern is `<div role="region" aria-labelledby tabindex="0">`.
+ *
+ * None of the four surveyed implementations of this family ships it: Typeset's
+ * `typeset-scroll` is a `div` with `overflow: auto`, and GitHub's table
+ * wrapper is the same.
+ *
+ * The wiring is written **only while the block actually overflows**, measured
+ * by `@slotted/core/overflow` — the module `slTabs` already uses. A tab stop
+ * on a block that fits is a tab stop that does nothing, and a reader tabbing a
+ * documentation page would hit one per table.
+ *
+ * `refresh()` is reachable through `exportAs`, for content that arrives after
+ * the observer's last measurement:
+ *
+ * ```html
+ * <div slProseScroll #wide="slProseScroll"><table>…</table></div>
+ * <button type="button" (click)="wide.refresh()">Reloaded</button>
+ * ```
+ */
+declare class SlProseScroll {
+    /**
+     * Words laid over the catalog of the language in force: the last resort name
+     * of the region (`scroll`). A static `aria-label` still wins.
+     */
+    readonly messages: i0.InputSignal<PartialMessages<ProseMessages> | undefined>;
+    /** Names it from an element already on the page — a table's own caption. */
+    readonly labelledBy: i0.InputSignal<string | undefined>;
+    private readonly host;
+    /** The family's words in the language in force, with this block's `messages` laid over them. */
+    readonly t: _slotted_core_i18n.FamilyTranslator<ProseMessages>;
+    private readonly overflowing;
+    private affordance;
+    /**
+     * A consumer who wrote its own `role` or `aria-label` on the element keeps
+     * them: the attribute is read once, before anything is bound over it.
+     */
+    private readonly writtenRole;
+    private readonly writtenLabel;
+    protected readonly resolvedRole: i0.Signal<string | null>;
+    protected readonly resolvedTabIndex: i0.Signal<"0" | null>;
+    protected readonly resolvedLabelledBy: i0.Signal<string | null>;
+    protected readonly resolvedLabel: i0.Signal<string | null>;
+    constructor();
+    /** Measures the block again and rewrites the wiring if the answer changed. */
+    refresh(): void;
+    /** Whether the block is scrollable as of the last measurement. */
+    isOverflowing(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlProseScroll, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlProseScroll, "[slProseScroll]", ["slProseScroll"], { "messages": { "alias": "messages"; "required": false; "isSignal": true; }; "labelledBy": { "alias": "labelledBy"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+export { PROSE_DEFAULTS, SlProse, SlProseAnchor, SlProseExclude, SlProseFootnotes, SlProseLead, SlProseScroll, injectProseDefaults, provideProseDefaults };
+export type { ProseDefaults, ProseFlow, ProseSize };
+//# sourceMappingURL=slotted-angular-prose.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-prose.d.ts","sources":["../../prose/src/prose-defaults.ts","../../prose/src/prose.ts","../../prose/src/prose-parts.ts","../../prose/src/prose-scroll.ts"],"mappings":";;;;;AAEA;;;;;AAKG;AACG,KAAM,SAAS;AAErB;;;;AAIG;AACG,KAAM,SAAS;UAEJ,aAAa;UACtB,SAAS;UACT,SAAS;AAChB;AAiBD,cAAa,cAAc,EAAA,cAAA,CAAA,aAAA;AAK3B;;;;AAIG;AACH,iBAAgB,oBAAoB,WAAW,OAAO,CAAC,aAAa;;sBAGhD,aAAa;AAKhC;AAED;AACA,iBAAgB,mBAAmB,IAAI,aAAa;;AC7CpD;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACH,cAea,OAAO;;mBAELA,EAAA,CAAA,WAAA,CAAA,SAAA;;mBAEAA,EAAA,CAAA,WAAA,CAAA,SAAA;AAEb;AAEA,qCAA+BA,EAAA,CAAA,MAAA,CAAA,SAAA;AAC/B,qCAA+BA,EAAA,CAAA,MAAA,CAAA,SAAA;yCATpB,OAAO;2CAAP,OAAO;AAUnB;;AC3DD;;;;AAIG;AACH,cAMa,WAAW;yCAAX,WAAW;2CAAX,WAAW;AAAG;AAE3B;;;;;;AAMG;AACH,cAMa,aAAa;AACxB;AACA;;yCAFW,aAAa;2CAAb,aAAa;AA8BzB;AAED;;;;;;;;AAQG;AACH,cAMa,cAAc;yCAAd,cAAc;2CAAd,cAAc;AAAG;AAE9B;AACA,cAMa,gBAAgB;yCAAhB,gBAAgB;2CAAhB,gBAAgB;AAAG;;ACpEhC;;;;;;;;;;;;;;;;;;;;;;;AAuBG;AACH,cAYa,aAAa;AACxB;;;AAGG;uBACcA,EAAA,CAAA,WAAA,CAAA,eAAA,CAAA,aAAA;;yBAEEA,EAAA,CAAA,WAAA;AAEnB;;gBAEU,kBAAA,CAAA,gBAAA,CAAA,aAAA;AACV;;AAGA;;;AAGG;AACH;AACA;AAEA,qCAA+BA,EAAA,CAAA,MAAA;AAK/B,yCAAmCA,EAAA,CAAA,MAAA;AAEnC,2CAAqCA,EAAA,CAAA,MAAA;AAKrC,sCAAgCA,EAAA,CAAA,MAAA;;;AA6BhC;;AAKA;yCApEW,aAAa;2CAAb,aAAa;AAuEzB;;","names":["_angular_core"]}

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

@@ -0,0 +1,268 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken, OnInit } from '@angular/core';
+import { ChangeRequest } from '@slotted/core/state';
+import { ControlValueAccessor, Validator, AbstractControl, ValidationErrors } from '@angular/forms';
+
+/** The type step the group and every item inside it sit at. */
+type RadioGroupSize = 'sm' | 'md' | 'lg';
+/** How the choices flow. `horizontal` wraps; a set of options is not a scroll region. */
+type RadioGroupOrientation = 'vertical' | 'horizontal';
+/**
+ * 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 RadioGroupVariant = 'plain' | 'tile';
+/**
+ * Which side of its own label the circle 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 radio's label is its own.
+ */
+type RadioGroupLabelPlacement = 'end' | 'start';
+interface RadioGroupDefaults {
+    labelPlacement: RadioGroupLabelPlacement;
+    variant: RadioGroupVariant;
+    orientation: RadioGroupOrientation;
+    size: RadioGroupSize;
+}
+declare const RADIO_GROUP_DEFAULTS: InjectionToken<RadioGroupDefaults>;
+/**
+ * An application decides once how its sets of choices flow, rather than
+ * repeating the same inputs on every group in a form. A group that states any
+ * of them itself still wins, and a field around it outranks this token for
+ * `size`.
+ */
+declare function provideRadioGroupDefaults(defaults: Partial<RadioGroupDefaults>): {
+    provide: InjectionToken<RadioGroupDefaults>;
+    useFactory: () => RadioGroupDefaults;
+};
+/** What a radio group renders as here, before it states anything of its own. */
+declare function injectRadioGroupDefaults(): RadioGroupDefaults;
+/**
+ * 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.
+ *
+ * It answers for the group's generated `name` as well as for each item's
+ * identifier, because both have to be stable across the two renders.
+ */
+declare class SlRadioGroupIdFactory {
+    private count;
+    next(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlRadioGroupIdFactory, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
+}
+
+/** Why the value moved. A radio group can produce exactly these two. */
+type RadioGroupSelectionReason = 'pointer' | 'keyboard';
+/**
+ * What the group needs from each item, and nothing more.
+ *
+ * A structural type rather than the item's class, so the group does not import
+ * the component that injects it — the cycle `text-field` breaks with an
+ * abstract class, broken here with the smaller thing that works.
+ */
+interface SlRadioGroupItem {
+    /** Writes this item's element from the group's value. */
+    syncElement(): void;
+}
+/**
+ * One choice out of a set.
+ *
+ * **The keyboard is the platform's, and that is why the items share a `name`.**
+ * Native radios in one form owner with one name already implement the APG's
+ * whole table: Tab lands on the checked item or on the first, `Space` checks,
+ * both arrow axes move focus and selection together, the set wraps, and
+ * disabled items are skipped — in a right-to-left document too. A roving
+ * `tabindex` written once per binding would reimplement all of it twice.
+ *
+ * **The role is conditional, and the condition is the field group.** A
+ * `field-group` is a `fieldset` with a `legend`, which is already a named group;
+ * a `radiogroup` inside it, named by the same legend, is the same set announced
+ * twice. A `role` the consumer wrote wins over both.
+ *
+ * **`readOnly` is enforced, because the platform has none.** A radio ignores
+ * `readonly`, so the group refuses the change on the item's own `click` — the
+ * one event a pointer and `Space` share — and announces `aria-readonly`.
+ */
+declare class SlRadioGroup implements ControlValueAccessor, OnInit, Validator {
+    /** Present means the consumer owns the choice. */
+    readonly value: _angular_core.InputSignal<string | undefined>;
+    /** The value an uncontrolled group starts from, read once. */
+    readonly defaultValue: _angular_core.InputSignal<string | undefined>;
+    /**
+     * The submission name the set shares, and the reason the platform treats it
+     * as one group. Generated when it is not written, because grouping is by name
+     * within the form owner and an unnamed set is not a set.
+     */
+    readonly name: _angular_core.InputSignal<string | undefined>;
+    readonly size: _angular_core.InputSignal<RadioGroupSize | undefined>;
+    readonly orientation: _angular_core.InputSignal<RadioGroupOrientation | undefined>;
+    readonly labelPlacement: _angular_core.InputSignal<RadioGroupLabelPlacement | undefined>;
+    readonly variant: _angular_core.InputSignal<RadioGroupVariant | undefined>;
+    /** Unstated rather than `false`, so the group defers to the field around it. */
+    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>;
+    readonly required: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /**
+     * One output for one transition. Its `previous` is `undefined` while nothing
+     * has been chosen, which is the state the APG asks a group to start in and
+     * which a request typed over `string` alone could not say.
+     */
+    readonly valueChange: _angular_core.OutputEmitterRef<ChangeRequest<string | undefined>>;
+    private readonly field;
+    private readonly fieldGroup;
+    private readonly defaults;
+    /**
+     * The field defaults in force: a field group's, or the application's own.
+     * A group outside a field reads disabled and read-only from them, as React's
+     * reads them from FieldDefaultsProvider.
+     */
+    private readonly fieldDefaultsSource;
+    private readonly fieldDefaultsToken;
+    private readonly fieldDefaults;
+    private readonly generatedName;
+    private readonly writtenRole;
+    private readonly writtenDescribedBy;
+    private readonly writtenLabel;
+    private readonly writtenLabelledBy;
+    private readonly items;
+    private readonly own;
+    private readonly formDisabled;
+    private onChangeFn;
+    private onTouchedFn;
+    readonly selection: _angular_core.Signal<string | undefined>;
+    readonly resolvedName: _angular_core.Signal<string>;
+    readonly resolvedSize: _angular_core.Signal<"sm" | "md" | "lg">;
+    readonly resolvedOrientation: _angular_core.Signal<RadioGroupOrientation>;
+    readonly resolvedLabelPlacement: _angular_core.Signal<RadioGroupLabelPlacement>;
+    /** Handed to every choice in the set: one plain box among four tiles is a
+        set nobody meant to write. */
+    readonly resolvedVariant: _angular_core.Signal<RadioGroupVariant>;
+    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>;
+    protected readonly resolvedRole: _angular_core.Signal<string | null>;
+    protected readonly labelledBy: _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>;
+    /**
+     * Only where the root owns the role, and only when the group flows the other
+     * way: on an element with no role the attribute describes nothing, and
+     * `radiogroup` already implies `vertical`.
+     */
+    protected readonly ariaOrientation: _angular_core.Signal<"horizontal" | null>;
+    ngOnInit(): void;
+    /** An item joins the set, so the group can put every element back at once. */
+    register(item: SlRadioGroupItem): void;
+    /** An item leaves the set. */
+    unregister(item: SlRadioGroupItem): void;
+    /**
+     * Writes every item's element from the value.
+     *
+     * The HTML standard's canceled activation behaviour for a radio restores the
+     * *clicked* element and nothing else, so the option that was chosen before
+     * the refused click stays unchecked: checking one radio unchecks its
+     * neighbours, and undoing the first half of that is all the platform offers.
+     * Angular writes a property binding only when its value changes, and the
+     * neighbour's did not, so the correction is made here — measured, in the
+     * first run of this family's Angular spec, as a controlled group that lost
+     * its choice after its consumer had said no.
+     */
+    restoreElements(): void;
+    /** Whether one value is the chosen one. Read by every item in the set. */
+    holds(value: string): boolean;
+    /**
+     * Asks the group to move to one value. Returns whether the value actually
+     * moved — false while a consumer owns it, which is what tells the item to
+     * refuse the activation and let the platform put the element back.
+     */
+    select(value: string, reason: RadioGroupSelectionReason, source: Event): boolean;
+    writeValue(value: string | null | undefined): void;
+    registerOnChange(fn: (value: string) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    /** Marks the set touched, which an item calls when it loses focus. */
+    markTouched(): void;
+    /**
+     * The group owns validity over the set, which no single item can see:
+     * "choose one" is a fact about the group and not about any one option.
+     */
+    validate(control: AbstractControl): ValidationErrors | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlRadioGroup, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlRadioGroup, "[slRadioGroup]", ["slRadioGroup"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "name": { "alias": "name"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "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; }; "required": { "alias": "required"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, ["*"], true, never>;
+}
+
+/**
+ * Help text under one item'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
+ * describes that item and not the set — what the set says belongs to the field
+ * group above it.
+ */
+declare class SlRadioDescription {
+    readonly id: string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlRadioDescription, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlRadioDescription, "[slRadioDescription]", ["slRadioDescription"], {}, {}, never, never, true, never>;
+}
+/**
+ * One item of the set.
+ *
+ * It is a part of `radio-group` and not an entry point of its own: outside a
+ * group it has no exclusive set to belong to, and the platform's whole keyboard
+ * model is defined over the set. `SlRadioGroup` is injected without `optional`,
+ * so an item written outside one fails at construction rather than silently.
+ *
+ * The mark is a sibling of the control for the reason `checkbox` records —
+ * Firefox renders no pseudo-element on an `input` — and the label names the
+ * control through `for` so the description below it can be read without
+ * choosing anything.
+ */
+declare class SlRadio implements SlRadioGroupItem {
+    /** What this item selects. It is what the group's value holds. */
+    readonly value: _angular_core.InputSignal<string>;
+    /** Unstated rather than `false`, so the item defers to the group. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    /**
+     * The group the item belongs to. Injected without `optional`, and public
+     * because the template reads the shared name from it and a consumer reaching
+     * the item through `exportAs` may want the group's resolved step.
+     */
+    readonly group: SlRadioGroup;
+    private readonly writtenId;
+    private readonly writtenDescribedBy;
+    private readonly element;
+    private readonly description;
+    /** The identifier the label points at. A consumer's own wins. */
+    readonly controlId: string;
+    readonly checked: _angular_core.Signal<boolean>;
+    constructor();
+    readonly resolvedDisabled: _angular_core.Signal<boolean | undefined>;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    protected readonly disabledAttribute: _angular_core.Signal<"" | null>;
+    /** The native element, for `focus()` and `click()`. */
+    get inputElement(): HTMLInputElement;
+    /** Writes this item's element from the group's value. */
+    syncElement(): void;
+    /**
+     * Refusing the default undoes the platform's pre-click check of *this*
+     * element. It does not put the previously chosen neighbour back — checking a
+     * radio unchecks its neighbours, and the canceled activation behaviour undoes
+     * only the first half of that — so the group writes every element from the
+     * value afterwards.
+     */
+    protected onClick(event: MouseEvent): void;
+    protected onBlur(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlRadio, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlRadio, "[slRadio]", ["slRadio"], { "value": { "alias": "value"; "required": true; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; }, {}, ["description"], ["*", "[slRadioDescription]"], true, never>;
+}
+
+export { RADIO_GROUP_DEFAULTS, SlRadio, SlRadioDescription, SlRadioGroup, SlRadioGroupIdFactory, injectRadioGroupDefaults, provideRadioGroupDefaults };
+export type { RadioGroupDefaults, RadioGroupLabelPlacement, RadioGroupOrientation, RadioGroupSelectionReason, RadioGroupSize, RadioGroupVariant };
+//# sourceMappingURL=slotted-angular-radio-group.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-radio-group.d.ts","sources":["../../radio-group/src/radio-group-defaults.ts","../../radio-group/src/radio-group.ts","../../radio-group/src/radio-group-parts.ts"],"mappings":";;;;;AAEA;AACM,KAAM,cAAc;AAE1B;KACY,qBAAqB;AAEjC;;;;AAIG;KACS,iBAAiB;AAE7B;;;;AAIG;KACS,wBAAwB;UAEnB,kBAAkB;oBACjB,wBAAwB;aAC/B,iBAAiB;iBACb,qBAAqB;UAC5B,cAAc;AACrB;AASD,cAAa,oBAAoB,EAAA,cAAA,CAAA,kBAAA;AAKjC;;;;;AAKG;AACH,iBAAgB,yBAAyB,WAAW,OAAO,CAAC,kBAAkB;;sBAG1D,kBAAkB;AAErC;AAED;AACA,iBAAgB,wBAAwB,IAAI,kBAAkB;AAI9D;;;;;;;;AAQG;AACH,cACa,qBAAqB;;;oDAArB,qBAAqB;;AAOjC;;AClCD;KACY,yBAAyB;AAErC;;;;;;AAMG;UACc,gBAAgB;;;AAGhC;AAED;;;;;;;;;;;;;;;;;;AAkBG;AACH,cA+Ba,YAAa,YAAW,oBAAoB,EAAE,MAAM,EAAE,SAAS;;oBAE5D,aAAA,CAAA,WAAA;;2BAEO,aAAA,CAAA,WAAA;AACrB;;;;AAIG;mBACU,aAAA,CAAA,WAAA;mBACA,aAAA,CAAA,WAAA,CAAA,cAAA;0BACO,aAAA,CAAA,WAAA,CAAA,qBAAA;6BACG,aAAA,CAAA,WAAA,CAAA,wBAAA;sBACP,aAAA,CAAA,WAAA,CAAA,iBAAA;;uBAEC,aAAA,CAAA,wBAAA;uBAGA,aAAA,CAAA,wBAAA;sBAGD,aAAA,CAAA,wBAAA;uBAGC,aAAA,CAAA,wBAAA;AAIjB;;;;AAIG;0BACiB,aAAA,CAAA,gBAAA,CAAA,aAAA;AAEpB;AACA;AACA;AACA;;;;AAIG;AACH;AACA;AACA;AAGA;AACA;AACA;AAGA;AACA;AAIA;AACA;AACA;;;wBAIkB,aAAA,CAAA,MAAA;2BACG,aAAA,CAAA,MAAA;2BAEA,aAAA,CAAA,MAAA;kCAOO,aAAA,CAAA,MAAA,CAAA,qBAAA;qCACG,aAAA,CAAA,MAAA,CAAA,wBAAA;AAG/B;AACiC;8BACT,aAAA,CAAA,MAAA,CAAA,iBAAA;+BACC,aAAA,CAAA,MAAA;+BAOA,aAAA,CAAA,MAAA;8BAGD,aAAA,CAAA,MAAA;+BAGC,aAAA,CAAA,MAAA;AAIzB,qCAA+B,aAAA,CAAA,MAAA;AAK/B,mCAA6B,aAAA,CAAA,MAAA;AAK7B,oCAA8B,aAAA,CAAA,MAAA;AAI9B,oCAA8B,aAAA,CAAA,MAAA;AAG9B,qCAA+B,aAAA,CAAA,MAAA;AAG/B,qCAA+B,aAAA,CAAA,MAAA;AAG/B;;;;AAIG;AACH,wCAAkC,aAAA,CAAA,MAAA;;;mBAWnB,gBAAgB;;qBAKd,gBAAgB;AAIjC;;;;;;;;;;;AAWG;;;AAMH;AAIA;;;;AAIG;AACH,kCAA8B,yBAAyB,UAAU,KAAK;AAmBtE;;AAQA;;;;AAaA;;;AAGG;AACH,sBAAkB,eAAe,GAAG,gBAAgB;oDAzNzC,YAAY;sDAAZ,YAAY;AA8NxB;;ACpTD;;;;;;;AAOG;AACH,cASa,kBAAkB;;oDAAlB,kBAAkB;sDAAlB,kBAAkB;AAE9B;AAWD;;;;;;;;;;;;AAYG;AACH,cA+Ba,OAAQ,YAAW,gBAAgB;;oBAEhC,aAAA,CAAA,WAAA;;uBAEG,aAAA,CAAA,wBAAA;AAIjB;;;;AAIG;oBACW,YAAA;AAEd;AACA;AAGA;AACA;;;sBAKgB,aAAA,CAAA,MAAA;;+BAMS,aAAA,CAAA,MAAA;AAEzB,oCAA8B,aAAA,CAAA,MAAA;AAI9B,0CAAoC,aAAA,CAAA,MAAA;;wBAKhB,gBAAgB;;;AASpC;;;;;;AAMG;AACH,6BAAyB,UAAU;AAMnC;oDAhEW,OAAO;sDAAP,OAAO;AAmEnB;;","names":[]}