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

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

@@ -0,0 +1,216 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { ControlValueAccessor } from '@angular/forms';
+import { ChangeRequest } from '@slotted/core/state';
+
+/** The type step the control sits at, matching the field around it. */
+type SliderSize = 'sm' | 'md' | 'lg';
+/**
+ * Which axis the scale runs along. A vertical slider's minimum is at the
+ * bottom, which is where the browser's own vertical range input and every
+ * surveyed implementation put it.
+ */
+type SliderOrientation = 'horizontal' | 'vertical';
+/**
+ * When the value stands on the thumb. `auto` shows it while the thumb is being
+ * dragged or has the caret, `always` shows it at rest as well, and `none`
+ * withdraws it — which is what a scale whose values are words needs.
+ */
+type SliderValueLabel = 'auto' | 'always' | 'none';
+/** Where the filled portion starts: an end of the scale, or a point on it. */
+type SliderOrigin = 'min' | 'max' | number;
+/** A tick on the scale, with the label that may become the announced value. */
+interface SliderMark {
+    value: number;
+    label?: string | undefined;
+}
+interface SliderDefaults {
+    orientation: SliderOrientation;
+    size: SliderSize;
+    valueLabel: SliderValueLabel;
+}
+declare const SLIDER_DEFAULTS: InjectionToken<SliderDefaults>;
+/**
+ * An application decides once what its sliders look like, rather than
+ * repeating the same inputs on every scale. A slider that states any of them
+ * itself still wins, and a slider inside a field takes the field's step before
+ * this token's. The locale its values are written in comes from the language
+ * in force (`provideSlotted`).
+ */
+declare function provideSliderDefaults(defaults: Partial<SliderDefaults>): {
+    provide: InjectionToken<SliderDefaults>;
+    useFactory: () => SliderDefaults;
+};
+/** What a slider renders as here, before it states anything of its own. */
+declare function injectSliderDefaults(): SliderDefaults;
+
+/**
+ * A scale, a rail and one thumb per value.
+ *
+ * **Every thumb is a real `input[type="range"]`.** Angular Material's own
+ * thumbs are `input[matSliderThumb]` elements, and the element is taken for the
+ * same reasons: it carries the `slider` role, `aria-valuenow`, `aria-valuemin`,
+ * `aria-valuemax`, form submission, form reset and `disabled` without the
+ * family writing any of them. It is invisible and unhittable, filling the thumb
+ * it lives in, so the thumb a reader sees is this family's own element.
+ *
+ * **The family owns the keyboard and the pointer.** Browsers disagree about a
+ * range input's larger step — Chrome moves Page Up by a tenth of the range and
+ * Firefox by one step — and `largeStep` has to mean one thing in both bindings.
+ *
+ * **Two thumbs cannot cross, and the accessibility tree says so.** Each input's
+ * own `min` and `max` follow its neighbour, which is what the APG's multi-thumb
+ * pattern requires of the dependent sliders' announced range.
+ *
+ * **Unset means ask the field.** `disabled`, `readOnly` and `invalid` default to
+ * `undefined` rather than `false`.
+ */
+declare class SlSlider implements ControlValueAccessor {
+    /**
+     * Present means the consumer owns the value, for the life of the component.
+     * An array makes a range; a number makes one thumb, and the shape handed in
+     * is the shape every request carries back.
+     */
+    readonly value: _angular_core.InputSignal<number | readonly number[] | undefined>;
+    /** The value an uncontrolled slider starts from, read once. */
+    readonly defaultValue: _angular_core.InputSignal<number | readonly number[]>;
+    readonly min: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly max: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly step: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** The amount `Shift` and the page keys move by. Defaults to `step * 10`. */
+    readonly largeStep: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    /** How many steps must stay between two neighbouring thumbs. */
+    readonly minStepsBetween: _angular_core.InputSignalWithTransform<number, unknown>;
+    /** Where the filled portion starts. Defaults to `min`. */
+    readonly origin: _angular_core.InputSignal<SliderOrigin>;
+    /** The ticks drawn beside the rail. A mark's label becomes its announced value. */
+    readonly marks: _angular_core.InputSignal<readonly (number | SliderMark)[] | undefined>;
+    /** How the value is written, through `Intl.NumberFormat`. */
+    readonly format: _angular_core.InputSignal<Intl.NumberFormatOptions | undefined>;
+    /** BCP 47. Unset, the language in force decides. */
+    readonly locale: _angular_core.InputSignal<string | undefined>;
+    /** The accessible name of each thumb, in order. */
+    readonly thumbLabels: _angular_core.InputSignal<readonly string[] | undefined>;
+    readonly size: _angular_core.InputSignal<SliderSize | undefined>;
+    readonly orientation: _angular_core.InputSignal<SliderOrientation | undefined>;
+    readonly valueLabel: _angular_core.InputSignal<SliderValueLabel | undefined>;
+    /** Unstated rather than `false`, so the control defers to the 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 value, the value it replaces,
+     * the reason, the originating event and `cancel()`. There is no `[(value)]`,
+     * because a two-way binding has one slot and can carry none of those; a form
+     * gets the same movement through `ControlValueAccessor`.
+     */
+    readonly valueChange: _angular_core.OutputEmitterRef<ChangeRequest<number | number[]>>;
+    /**
+     * The end of a drag, or a key that settled the value. A drag emits a hundred
+     * changes and one commit; this is the commit.
+     */
+    readonly valueCommit: _angular_core.OutputEmitterRef<number | number[]>;
+    private readonly element;
+    private readonly track;
+    private readonly field;
+    private readonly defaults;
+    private readonly appLocale;
+    private readonly writtenId;
+    private readonly writtenName;
+    private readonly writtenForm;
+    private readonly writtenLabel;
+    private readonly writtenDescribedBy;
+    private readonly writtenInvalid;
+    private readonly writtenRequired;
+    /** What the family holds when nobody else owns it. */
+    private readonly own;
+    private readonly formValue;
+    private readonly formDisabled;
+    protected readonly dragging: _angular_core.WritableSignal<number | null>;
+    private onChangeFn;
+    private onTouchedFn;
+    protected readonly scale: _angular_core.Signal<{
+        min: number;
+        max: number;
+        step: number;
+    }>;
+    /** The shape the consumer handed in is the shape every request carries back. */
+    private readonly isRange;
+    readonly values: _angular_core.Signal<number[]>;
+    private readonly formatter;
+    readonly resolvedSize: _angular_core.Signal<SliderSize>;
+    readonly resolvedOrientation: _angular_core.Signal<SliderOrientation>;
+    readonly resolvedValueLabel: _angular_core.Signal<SliderValueLabel>;
+    readonly resolvedDisabled: _angular_core.Signal<boolean | undefined>;
+    readonly resolvedReadOnly: _angular_core.Signal<boolean | undefined>;
+    readonly resolvedInvalid: _angular_core.Signal<boolean | undefined>;
+    private readonly inert;
+    readonly controlId: _angular_core.Signal<string | null>;
+    protected readonly submissionName: _angular_core.Signal<string | null>;
+    protected readonly submissionForm: _angular_core.Signal<string | null>;
+    protected readonly markList: _angular_core.Signal<SliderMark[]>;
+    protected readonly marksMode: _angular_core.Signal<"labelled" | "ticks" | null>;
+    protected readonly describedBy: _angular_core.Signal<string | null>;
+    protected readonly ariaInvalid: _angular_core.Signal<string | null>;
+    protected readonly ariaRequired: _angular_core.Signal<string | null>;
+    /** Where the fill starts, which is an end of the scale or a point on it. */
+    protected readonly span: _angular_core.Signal<{
+        start: number;
+        end: number;
+    }>;
+    protected readonly outputText: _angular_core.Signal<string>;
+    /** The native element, for `focus()` on the root and for a consumer's own query. */
+    get sliderElement(): HTMLElement;
+    /** The one action a value cannot express: putting focus on a named thumb. */
+    focusThumb(index?: number): void;
+    protected percentOf(value: number): number;
+    protected edgeOf(value: number): "start" | "end" | null;
+    protected boundsAt(index: number): {
+        min: number;
+        max: number;
+    };
+    protected thumbLabelAt(index: number): string | null;
+    /**
+     * The APG names `aria-valuetext` for a value that is not user-friendly, and
+     * gives "Monday" as its example. A mark that already carries a label is that
+     * string, so a five-step quality scale announces "Medium" rather than "50".
+     */
+    protected valueTextOf(value: number): string;
+    protected onTouched(): void;
+    writeValue(value: number | readonly number[] | null): void;
+    registerOnChange(fn: (value: number | number[]) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    protected onPointerDown(event: PointerEvent): void;
+    protected onPointerMove(event: PointerEvent): void;
+    protected onPointerUp(event: PointerEvent): void;
+    /**
+     * The whole keyboard table, and `preventDefault()` on every key in it. The
+     * inline arrows follow the reading direction — in a mirrored document
+     * `ArrowRight` moves the thumb toward the end of the track the reader sees —
+     * and the block arrows do not, because a scale has a direction and bidi is
+     * not it.
+     */
+    protected onKeyDown(index: number, event: KeyboardEvent): void;
+    private thumbInputs;
+    /**
+     * Which way the inline arrows move, read from the element rather than from an
+     * input: a right-to-left document is a property of the page.
+     */
+    private isRtl;
+    private valueAtPointer;
+    private shape;
+    private move;
+    /**
+     * Asks to move, and moves nothing the consumer owns. A refused request stops
+     * here: a control that wrote the value regardless would show one the consumer
+     * never accepted.
+     */
+    private request;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlSlider, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlSlider, "[slSlider]", ["slSlider"], { "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "step": { "alias": "step"; "required": false; "isSignal": true; }; "largeStep": { "alias": "largeStep"; "required": false; "isSignal": true; }; "minStepsBetween": { "alias": "minStepsBetween"; "required": false; "isSignal": true; }; "origin": { "alias": "origin"; "required": false; "isSignal": true; }; "marks": { "alias": "marks"; "required": false; "isSignal": true; }; "format": { "alias": "format"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "thumbLabels": { "alias": "thumbLabels"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "orientation": { "alias": "orientation"; "required": false; "isSignal": true; }; "valueLabel": { "alias": "valueLabel"; "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; }; }, { "valueChange": "valueChange"; "valueCommit": "valueCommit"; }, never, never, true, never>;
+}
+
+export { SLIDER_DEFAULTS, SlSlider, injectSliderDefaults, provideSliderDefaults };
+export type { SliderDefaults, SliderMark, SliderOrientation, SliderOrigin, SliderSize, SliderValueLabel };
+//# sourceMappingURL=slotted-angular-slider.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-slider.d.ts","sources":["../../slider/src/slider-defaults.ts","../../slider/src/slider.ts"],"mappings":";;;;;AAEA;AACM,KAAM,UAAU;AAEtB;;;;AAIG;KACS,iBAAiB;AAE7B;;;;AAIG;AACG,KAAM,gBAAgB;AAE5B;AACM,KAAM,YAAY;AAExB;UACiB,UAAU;;AAEzB;AACD;UAEgB,cAAc;iBAChB,iBAAiB;UACxB,UAAU;gBACJ,gBAAgB;AAC7B;AAQD,cAAa,eAAe,EAAA,cAAA,CAAA,cAAA;AAK5B;;;;;;AAMG;AACH,iBAAgB,qBAAqB,WAAW,OAAO,CAAC,cAAc;;sBAGlD,cAAc;AAEjC;AAED;AACA,iBAAgB,oBAAoB,IAAI,cAAc;;ACFtD;;;;;;;;;;;;;;;;;;;;AAoBG;AACH,cAiFa,QAAS,YAAW,oBAAoB;AACnD;;;;AAIG;oBACW,aAAA,CAAA,WAAA;;2BAEO,aAAA,CAAA,WAAA;kBAET,aAAA,CAAA,wBAAA;kBACA,aAAA,CAAA,wBAAA;mBACC,aAAA,CAAA,wBAAA;;wBAEK,aAAA,CAAA,wBAAA;;8BAEM,aAAA,CAAA,wBAAA;;qBAIT,aAAA,CAAA,WAAA,CAAA,YAAA;;oBAED,aAAA,CAAA,WAAA,oBAAA,UAAA;;qBAEC,aAAA,CAAA,WAAA,CAAA,IAAA,CAAA,mBAAA;;qBAEA,aAAA,CAAA,WAAA;;0BAEK,aAAA,CAAA,WAAA;mBAEP,aAAA,CAAA,WAAA,CAAA,UAAA;0BACO,aAAA,CAAA,WAAA,CAAA,iBAAA;yBACD,aAAA,CAAA,WAAA,CAAA,gBAAA;;uBAGF,aAAA,CAAA,wBAAA;uBAGA,aAAA,CAAA,wBAAA;sBAGD,aAAA,CAAA,wBAAA;AAIhB;;;;;AAKG;0BACiB,aAAA,CAAA,gBAAA,CAAA,aAAA;AACpB;;;AAGG;0BACiB,aAAA,CAAA,gBAAA;AAEpB;AACA;AACA;AACA;AACA;AAEA;AACA;AACA;AACA;AACA;AAGA;AAGA;;AAKA;AACA;AACA;AACA,iCAA2B,aAAA,CAAA,cAAA;;;8BAIH,aAAA,CAAA,MAAA;;;;AAIpB;;AAGJ;qBAKe,aAAA,CAAA,MAAA;AAMf;2BAQqB,aAAA,CAAA,MAAA,CAAA,UAAA;kCAGO,aAAA,CAAA,MAAA,CAAA,iBAAA;iCACD,aAAA,CAAA,MAAA,CAAA,gBAAA;+BACF,aAAA,CAAA,MAAA;+BAGA,aAAA,CAAA,MAAA;8BACD,aAAA,CAAA,MAAA;AACxB;wBAIkB,aAAA,CAAA,MAAA;AAClB,uCAAiC,aAAA,CAAA,MAAA;AACjC,uCAAiC,aAAA,CAAA,MAAA;AAEjC,iCAA2B,aAAA,CAAA,MAAA,CAAA,UAAA;AAM3B,kCAA4B,aAAA,CAAA,MAAA;AAM5B,oCAA8B,aAAA,CAAA,MAAA;AAI9B,oCAA8B,aAAA,CAAA,MAAA;AAG9B,qCAA+B,aAAA,CAAA,MAAA;;6BAKR,aAAA,CAAA,MAAA;;;AAapB;AAEH,mCAA6B,aAAA,CAAA,MAAA;;yBAOR,WAAW;;;AAShC;AAIA;AAMA;;;;AASA;AAMA;;;;AAIG;AACH;AAOA;;;AAcA;;AAQA,mCAA+B,YAAY;AAe3C,mCAA+B,YAAY;AAQ3C,iCAA6B,YAAY;AAQzC;;;;;;AAMG;8CACuC,aAAa;AAiDvD;AAIA;;;AAGG;AACH;AAKA;AAWA;AAIA;AAaA;;;;AAIG;AACH;oDAzXW,QAAQ;sDAAR,QAAQ;AAmZpB;;","names":[]}

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

@@ -0,0 +1,106 @@
+import * as _slotted_core_sparkline from '@slotted/core/sparkline';
+import { SparklineDatum } from '@slotted/core/sparkline';
+import * as _slotted_core_i18n from '@slotted/core/i18n';
+import { PartialMessages, SparklineMessages } from '@slotted/core/i18n';
+import * as _angular_core from '@angular/core';
+import { InjectionToken } from '@angular/core';
+
+type SparklineType = 'line' | 'bar';
+type SparklineSize = 'sm' | 'md' | 'lg';
+type SparklineCurve = 'linear' | 'monotone';
+type SparklineTone = 'neutral' | 'accent' | 'secondary' | 'success' | 'warning' | 'danger';
+type SparklineSeries = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
+
+/**
+ * A series of numbers drawn in a box: a line through them or a bar per
+ * period, a disc on the last point, a dashed line at a reference. The
+ * geometry is `@slotted/core/sparkline`'s and the paint is the stylesheet's;
+ * what this binding decides is when to measure and what to say.
+ *
+ * The box is measured after the first render, so the first browser paint is
+ * on the real grid; on the server the drawing is laid out on the nominal
+ * grid of its size step and stretched to the box, where
+ * `vector-effect: non-scaling-stroke` keeps every stroke and both discs at
+ * their screen size. The host is `role="img"` with the generated description
+ * as its name — an `aria-label` the consumer wrote on the element wins — and
+ * the `svg` is hidden: a drawing with no interaction is an image.
+ */
+declare class SlSparkline {
+    /** The series, oldest first. `null` is a gap: the line breaks, the bar is not drawn. */
+    readonly data: _angular_core.InputSignal<readonly SparklineDatum[]>;
+    readonly type: _angular_core.InputSignal<SparklineType>;
+    readonly size: _angular_core.InputSignal<SparklineSize>;
+    /** Straight segments, or a monotone curve that never overshoots a point. */
+    readonly curve: _angular_core.InputSignal<SparklineCurve | undefined>;
+    /** The wash under a line. */
+    readonly area: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
+    /** A disc on the last real point. */
+    readonly marker: _angular_core.InputSignalWithTransform<boolean | undefined, unknown>;
+    /** A dashed line at this value, which widens the extent to hold it. */
+    readonly reference: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    /** The extent, when the data's own is not the one to draw. The data widens it, never narrows it. */
+    readonly min: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    readonly max: _angular_core.InputSignalWithTransform<number | undefined, unknown>;
+    /** How the series is doing. Wins over `series`. */
+    readonly tone: _angular_core.InputSignal<SparklineTone | undefined>;
+    /** Which series this is, as a slot of the data scale. */
+    readonly series: _angular_core.InputSignal<SparklineSeries | undefined>;
+    /** What the series is, said first in the description. */
+    readonly label: _angular_core.InputSignal<string | undefined>;
+    /** The whole accessible name, replacing the generated description. */
+    readonly description: _angular_core.InputSignal<string | undefined>;
+    readonly formatOptions: _angular_core.InputSignal<Intl.NumberFormatOptions | undefined>;
+    readonly valueFormatter: _angular_core.InputSignal<((value: number) => string) | undefined>;
+    /** The locale numbers are written in; the language in force when absent. */
+    readonly locale: _angular_core.InputSignal<string | undefined>;
+    /** Words laid over the catalog of the language in force, key by key: the description's sentences. */
+    readonly messages: _angular_core.InputSignal<PartialMessages<SparklineMessages> | undefined>;
+    private readonly defaults;
+    private readonly host;
+    /** An `aria-label` the consumer wrote on their own element, which wins. */
+    private readonly ownLabel;
+    private readonly box;
+    readonly resolvedCurve: _angular_core.Signal<SparklineCurve>;
+    readonly resolvedArea: _angular_core.Signal<boolean>;
+    readonly resolvedMarker: _angular_core.Signal<boolean>;
+    /** The family's words in the language in force, with this sparkline's `messages` laid over them. */
+    readonly t: _slotted_core_i18n.FamilyTranslator<SparklineMessages>;
+    private readonly appLocale;
+    readonly width: _angular_core.Signal<number>;
+    readonly height: _angular_core.Signal<number>;
+    readonly viewBox: _angular_core.Signal<string>;
+    readonly layout: _angular_core.Signal<_slotted_core_sparkline.SparklineLayout>;
+    readonly markerPath: _angular_core.Signal<string | null>;
+    readonly name: _angular_core.Signal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlSparkline, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlSparkline, "[slSparkline]", ["slSparkline"], { "data": { "alias": "data"; "required": false; "isSignal": true; }; "type": { "alias": "type"; "required": false; "isSignal": true; }; "size": { "alias": "size"; "required": false; "isSignal": true; }; "curve": { "alias": "curve"; "required": false; "isSignal": true; }; "area": { "alias": "area"; "required": false; "isSignal": true; }; "marker": { "alias": "marker"; "required": false; "isSignal": true; }; "reference": { "alias": "reference"; "required": false; "isSignal": true; }; "min": { "alias": "min"; "required": false; "isSignal": true; }; "max": { "alias": "max"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "series": { "alias": "series"; "required": false; "isSignal": true; }; "label": { "alias": "label"; "required": false; "isSignal": true; }; "description": { "alias": "description"; "required": false; "isSignal": true; }; "formatOptions": { "alias": "formatOptions"; "required": false; "isSignal": true; }; "valueFormatter": { "alias": "valueFormatter"; "required": false; "isSignal": true; }; "locale": { "alias": "locale"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * What every sparkline in an application does before any of them states
+ * anything of its own: how a number is read out, whether a line is smoothed,
+ * washed and marked. Its words and locale come from the language in force
+ * (`provideSlotted`).
+ */
+interface SparklineDefaults {
+    area?: boolean;
+    curve?: SparklineCurve;
+    formatOptions?: Intl.NumberFormatOptions;
+    marker?: boolean;
+}
+declare const SPARKLINE_DEFAULTS_TOKEN: InjectionToken<SparklineDefaults>;
+/**
+ * An application decides once how its sparklines are drawn and read out, and
+ * every sparkline inherits it. A sparkline that states any of those still
+ * wins: an explicit input is never overridden by the token.
+ */
+declare function provideSparklineDefaults(defaults: SparklineDefaults): {
+    provide: InjectionToken<SparklineDefaults>;
+    useValue: SparklineDefaults;
+};
+declare function injectSparklineDefaults(): SparklineDefaults;
+
+export { SPARKLINE_DEFAULTS_TOKEN, SlSparkline, injectSparklineDefaults, provideSparklineDefaults };
+export type { SparklineCurve, SparklineDefaults, SparklineSeries, SparklineSize, SparklineTone, SparklineType };
+//# sourceMappingURL=slotted-angular-sparkline.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-sparkline.d.ts","sources":["../../sparkline/src/sparkline.constants.ts","../../sparkline/src/sparkline.ts","../../sparkline/src/sparkline-defaults.ts"],"mappings":";;;;;;;KAAY,aAAa;AACnB,KAAM,aAAa;KACb,cAAc;AACpB,KAAM,aAAa;KACb,eAAe;;ACqC3B;;;;;;;;;;;;;AAaG;AACH,cAiDa,WAAW;;mBAET,aAAA,CAAA,WAAA,UAAA,cAAA;mBACA,aAAA,CAAA,WAAA,CAAA,aAAA;mBACA,aAAA,CAAA,WAAA,CAAA,aAAA;;oBAEC,aAAA,CAAA,WAAA,CAAA,cAAA;;mBAED,aAAA,CAAA,wBAAA;;qBAEE,aAAA,CAAA,wBAAA;;wBAEG,aAAA,CAAA,wBAAA;;kBAEN,aAAA,CAAA,wBAAA;kBACA,aAAA,CAAA,wBAAA;;mBAEC,aAAA,CAAA,WAAA,CAAA,aAAA;;qBAEE,aAAA,CAAA,WAAA,CAAA,eAAA;;oBAED,aAAA,CAAA,WAAA;;0BAEM,aAAA,CAAA,WAAA;4BACE,aAAA,CAAA,WAAA,CAAA,IAAA,CAAA,mBAAA;AACtB,6BAAuB,aAAA,CAAA,WAAA;;qBAER,aAAA,CAAA,WAAA;;uBAEE,aAAA,CAAA,WAAA,CAAA,eAAA,CAAA,iBAAA;AAEjB;AACA;;AAEA;AACA;4BAEsB,aAAA,CAAA,MAAA,CAAA,cAAA;2BACD,aAAA,CAAA,MAAA;6BACE,aAAA,CAAA,MAAA;;gBAEb,kBAAA,CAAA,gBAAA,CAAA,iBAAA;AACV;oBAEc,aAAA,CAAA,MAAA;qBACC,aAAA,CAAA,MAAA;sBACC,aAAA,CAAA,MAAA;qBAED,aAAA,CAAA,MAAA,CAAA,uBAAA,CAAA,eAAA;yBAiBI,aAAA,CAAA,MAAA;mBAMN,aAAA,CAAA,MAAA;;oDAvEF,WAAW;sDAAX,WAAW;AA8FvB;;AClMD;;;;;AAKG;UACc,iBAAiB;;YAExB,cAAc;AACtB,oBAAgB,IAAI,CAAC,mBAAmB;;AAEzC;AAED,cAAa,wBAAwB,EAAA,cAAA,CAAA,iBAAA;AAKrC;;;;AAIG;AACH,iBAAgB,wBAAwB,WAAW,iBAAiB;;;AAEnE;AAED,iBAAgB,uBAAuB,IAAI,iBAAiB;;","names":[]}

package/types/slotted-angular-split-button.d.ts

@@ -0,0 +1,180 @@
+import * as _angular_core from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { ChangeRequest } from '@slotted/core/state';
+import { SlIconButton, SlButton, ButtonSize, ButtonTone, ButtonVariant } from '@slotted/angular/button';
+import * as i1 from '@slotted/angular/menu';
+
+/**
+ * Why the remembered value moved. The menu's radio group produces exactly
+ * these two, and the family surfaces them unchanged.
+ */
+type SplitButtonValueReason = 'pointer' | 'keyboard';
+/**
+ * An action and the menu of its alternatives, joined into one shape.
+ *
+ * The root is a `group` of two `button`s: the primary, `SlButton` carrying
+ * this family's part, and the menu trigger, `SlIconButton` carrying the
+ * other and hosting `slMenuTriggerFor`. Each keeps its role, its state and
+ * its own tab stop — every surveyed split button gives the pair two — and
+ * the root hands them one appearance through `button`'s own token. The menu
+ * is the consumer's own `sl-menu`, written inside the root, and nothing of
+ * it is restated here.
+ *
+ * `remember` is the one decision the family adds. Off, the alternatives are
+ * actions. On, the radio group carrying `slSplitButtonChoices` is bound to
+ * the root's value, and the consumer renders the primary's label from that
+ * value — the merge button whose strategy a repository remembers. A silent
+ * update was refused because it changes what the next click does.
+ */
+declare class SlSplitButton {
+    readonly size: _angular_core.InputSignal<"sm" | "md" | "lg" | undefined>;
+    readonly tone: _angular_core.InputSignal<"accent" | "secondary" | "success" | "warning" | "danger" | undefined>;
+    readonly variant: _angular_core.InputSignal<"solid" | "outline" | "ghost" | undefined>;
+    /** The action takes the line; the menu trigger stays square. */
+    readonly fullWidth: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Takes both halves out. Each half keeps the native attribute for itself. */
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * The action is in flight: the primary shows `button`'s indicator with its
+     * width and name held, and the menu trigger is `aria-disabled` for the
+     * duration — still in the tab sequence, still named, still painted — so a
+     * second alternative cannot be chosen while the first runs.
+     */
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * The choice in the menu becomes the action. Off, the menu's items are
+     * actions; on, the items inside the radio group carrying
+     * `slSplitButtonChoices` are bound to `value`.
+     */
+    readonly remember: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The remembered value. Present at all puts it in controlled mode. */
+    readonly value: _angular_core.InputSignal<string | undefined>;
+    /** The value an uncontrolled split button remembers first, read once. */
+    readonly defaultValue: _angular_core.InputSignal<string | undefined>;
+    /**
+     * One output for one transition, carrying the value, the value it
+     * replaces, the reason, the originating event and `cancel()`.
+     */
+    readonly valueChange: _angular_core.OutputEmitterRef<ChangeRequest<string>>;
+    private readonly defaults;
+    private readonly inherited;
+    /**
+     * A static attribute the consumer wrote survives the host binding, so a
+     * root that is already inside a named group can give the role up with
+     * `role=""`, the way `button-group` lets it.
+     */
+    private readonly writtenRole;
+    protected readonly role: string | null;
+    private readonly own;
+    readonly resolvedSize: _angular_core.Signal<"sm" | "md" | "lg">;
+    readonly resolvedTone: _angular_core.Signal<"accent" | "secondary" | "success" | "warning" | "danger">;
+    readonly resolvedVariant: _angular_core.Signal<"solid" | "outline" | "ghost">;
+    /** The remembered value, under `remember`; nothing otherwise. */
+    readonly resolvedValue: _angular_core.Signal<string | undefined>;
+    /** Asks the family to remember one alternative as the action. */
+    select(next: string, reason: SplitButtonValueReason, source?: unknown): boolean;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlSplitButton, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlSplitButton, "[slSplitButton]", ["slSplitButton"], { "size": { "alias": "size"; "required": false; "isSignal": true; }; "tone": { "alias": "tone"; "required": false; "isSignal": true; }; "variant": { "alias": "variant"; "required": false; "isSignal": true; }; "fullWidth": { "alias": "fullWidth"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "remember": { "alias": "remember"; "required": false; "isSignal": true; }; "value": { "alias": "value"; "required": false; "isSignal": true; }; "defaultValue": { "alias": "defaultValue"; "required": false; "isSignal": true; }; }, { "valueChange": "valueChange"; }, never, ["*"], true, never>;
+}
+
+/**
+ * The action: `SlButton`, carrying this family's part and folding the root's
+ * `disabled` and `loading` into its own. The subclass restates the template
+ * and the host binding for the part, and overrides the two resolvers the
+ * parent reads its state through — everything else, from `slButtonStart` to
+ * the indicator, is `SlButton`'s. `button` selects itself by `data-ui` alone
+ * and reads no part on its root, so the part slot is free.
+ */
+declare class SlSplitButtonPrimary extends SlButton {
+    private readonly split;
+    readonly resolvedDisabled: _angular_core.Signal<boolean>;
+    readonly resolvedLoading: _angular_core.Signal<boolean>;
+    protected readonly inert: {
+        refuses: _angular_core.Signal<boolean>;
+        nativelyDisabled: _angular_core.Signal<boolean>;
+        ariaDisabled: _angular_core.Signal<"true" | null>;
+    };
+    readonly waiting: _angular_core.Signal<boolean>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlSplitButtonPrimary, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlSplitButtonPrimary, "button[slSplitButtonPrimary]", ["slSplitButtonPrimary"], {}, {}, never, ["[slButtonStart]", "*", "[slButtonEnd]"], true, never>;
+}
+/**
+ * The menu trigger: `SlIconButton` hosting `slMenuTriggerFor` and carrying
+ * this family's part. It takes `aria-haspopup`, `aria-expanded`,
+ * `aria-controls` and the four keys of the Menu Button pattern from `menu`,
+ * and every tone, variant and size from `button`. The chevron is the
+ * family's, the `chevron-down` Glyph element in the icon part, which `button`
+ * sizes; content the consumer writes replaces it; the accessible name is the consumer's, and `SlIconButton`
+ * refuses to render without one in development.
+ *
+ * `slMenuTriggerFor` is a host directive rather than a second attribute the
+ * consumer writes beside this one, and the order is the point: a host
+ * directive's bindings run before the host's, so the `data-part` and the
+ * `data-disabled` this component binds win over the `null` the trigger
+ * binds for a control that is neither a bar's item nor a submenu's. The
+ * write-back `toolbar`'s overflow needs is not needed here.
+ *
+ * While the root is loading the trigger is busy: `aria-disabled`, still in
+ * the tab sequence, still named, still painted — no `data-disabled`, so
+ * `button` does not paint it unavailable beside an action still in its
+ * tone. The click is refused in the capture phase by `button`'s own guard,
+ * and the opening keys are refused the same way here, before the trigger's
+ * own listener sees them.
+ */
+declare class SlSplitButtonMenuTrigger extends SlIconButton {
+    private readonly split;
+    readonly resolvedDisabled: _angular_core.Signal<boolean>;
+    /** The action is in flight and the menu waits with it. */
+    readonly busy: _angular_core.Signal<boolean>;
+    protected readonly inert: {
+        refuses: _angular_core.Signal<boolean>;
+        nativelyDisabled: _angular_core.Signal<boolean>;
+        ariaDisabled: _angular_core.Signal<"true" | null>;
+    };
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlSplitButtonMenuTrigger, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlSplitButtonMenuTrigger, "button[slSplitButtonMenuTrigger]", ["slSplitButtonMenuTrigger"], {}, {}, never, ["*"], true, [{ directive: typeof i1.SlMenuTrigger; inputs: { "slMenuTriggerFor": "slMenuTriggerFor"; }; outputs: {}; }]>;
+}
+/**
+ * The alternatives under `remember`: the consumer's `sl-menu-radio-group`,
+ * bound both ways to the root's value. The group never owns the value — its
+ * own request is cancelled once forwarded, and what it shows checked is
+ * written back from the root, so a controlled root the consumer has not yet
+ * moved shows nothing the consumer did not agree to. The DI tree is the
+ * template tree, so the group finds the root above it however the layer is
+ * portaled.
+ */
+declare class SlSplitButtonChoices {
+    private readonly group;
+    private readonly split;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlSplitButtonChoices, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlSplitButtonChoices, "sl-menu-radio-group[slSplitButtonChoices]", ["slSplitButtonChoices"], {}, {}, never, never, true, never>;
+}
+
+/**
+ * What a split button paints itself as here, before it states anything of
+ * its own. Every axis is optional: an unset one falls through to `button`'s
+ * own token, which is where an application that paints every action at once
+ * already set it, and then to the contract's defaults.
+ */
+interface SplitButtonDefaults {
+    size?: ButtonSize | undefined;
+    tone?: ButtonTone | undefined;
+    variant?: ButtonVariant | undefined;
+}
+declare const SPLIT_BUTTON_DEFAULTS: InjectionToken<SplitButtonDefaults>;
+/**
+ * An application decides once how its split buttons are painted rather than
+ * repeating three inputs on every one. A split button that states an axis
+ * itself still wins.
+ */
+declare function provideSplitButtonDefaults(defaults: SplitButtonDefaults): {
+    provide: InjectionToken<SplitButtonDefaults>;
+    useValue: SplitButtonDefaults;
+};
+declare function injectSplitButtonDefaults(): SplitButtonDefaults;
+
+export { SPLIT_BUTTON_DEFAULTS, SlSplitButton, SlSplitButtonChoices, SlSplitButtonMenuTrigger, SlSplitButtonPrimary, injectSplitButtonDefaults, provideSplitButtonDefaults };
+export type { SplitButtonDefaults, SplitButtonValueReason };
+//# sourceMappingURL=slotted-angular-split-button.d.ts.map

package/types/slotted-angular-split-button.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-split-button.d.ts","sources":["../../split-button/src/split-button.ts","../../split-button/src/split-button-parts.ts","../../split-button/src/split-button-defaults.ts"],"mappings":";;;;;;AAyBA;;;AAGG;KACS,sBAAsB;AA6BlC;;;;;;;;;;;;;;;;AAgBG;AACH,cAqBa,aAAa;mBACX,aAAA,CAAA,WAAA;mBACA,aAAA,CAAA,WAAA;sBACG,aAAA,CAAA,WAAA;;wBAEE,aAAA,CAAA,wBAAA;;uBAED,aAAA,CAAA,wBAAA;AACjB;;;;;AAKG;sBACa,aAAA,CAAA,wBAAA;AAChB;;;;AAIG;uBACc,aAAA,CAAA,wBAAA;;oBAGH,aAAA,CAAA,WAAA;;2BAEO,aAAA,CAAA,WAAA;AACrB;;;AAGG;0BACiB,aAAA,CAAA,gBAAA,CAAA,aAAA;AAEpB;AACA;AACA;;;;AAIG;AACH;AACA;AAEA;2BAIqB,aAAA,CAAA,MAAA;2BAGA,aAAA,CAAA,MAAA;8BAGG,aAAA,CAAA,MAAA;;4BAIF,aAAA,CAAA,MAAA;;AAKtB,iCAA6B,sBAAsB;oDA7DxC,aAAa;sDAAb,aAAa;AAuEzB;;AC7ID;;;;;;;AAOG;AACH,cA6Ba,oBAAqB,SAAQ,QAAQ;AAChD;+BAEyB,aAAA,CAAA,MAAA;8BACD,aAAA,CAAA,MAAA;AAExB;;;;AAIG;AACH,sBAAyB,aAAA,CAAA,MAAA;oDAXd,oBAAoB;sDAApB,oBAAoB;AAYhC;AAQD;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACH,cAkCa,wBAAyB,SAAQ,YAAY;AACxD;+BAEyB,aAAA,CAAA,MAAA;;mBAEZ,aAAA,CAAA,MAAA;AAEb;;;;AAIG;;oDAXQ,wBAAwB;sDAAxB,wBAAwB,qHAAA,EAAA,CAAA,aAAA;AAwBpC;AAED;;;;;;;;AAQG;AACH,cAKa,oBAAoB;AAC/B;AACA;;oDAFW,oBAAoB;sDAApB,oBAAoB;AAmBhC;;ACpMD;;;;;AAKG;UACc,mBAAmB;AAClC,WAAO,UAAU;AACjB,WAAO,UAAU;AACjB,cAAU,aAAa;AACxB;AAED,cAAa,qBAAqB,EAAA,cAAA,CAAA,mBAAA;AAKlC;;;;AAIG;AACH,iBAAgB,0BAA0B,WAAW,mBAAmB;;;AAEvE;AAED,iBAAgB,yBAAyB,IAAI,mBAAmB;;","names":[]}