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

package/types/slotted-angular-saved-views.d.ts

@@ -0,0 +1,198 @@
+import * as _slotted_core_i18n from '@slotted/core/i18n';
+import { PartialMessages, SavedViewsMessages } from '@slotted/core/i18n';
+import * as _angular_core from '@angular/core';
+import { WritableSignal, Injector } from '@angular/core';
+import { MenuSelectEvent } from '@slotted/angular/menu';
+import { GridView, SavedViewsState, GridColumn, SavedView, GridViewStorage } from '@slotted/core/grid';
+import { ChangeRequest } from '@slotted/core/state';
+
+/** What the reader did. One state object answers seven different presses. */
+type SavedViewsAction = 'apply' | 'save' | 'create' | 'rename' | 'delete' | 'default' | 'revert';
+/** Why the views moved. `submit` is a form; `remove` a confirmed delete. */
+type SavedViewsReason = 'pointer' | 'keyboard' | 'submit' | 'remove' | 'programmatic';
+/** Why the layer opened or closed: the popover's own reasons. */
+type SavedViewsOpenReason = Extract<ChangeRequest<boolean>['reason'], 'pointer' | 'keyboard' | 'escape' | 'outsidePress' | 'dismiss' | 'programmatic'>;
+/**
+ * The request every change carries: the state asked for, the one it
+ * replaces, the reason, what the reader did, the originating event, and a
+ * refusal that stops the change before anything commits.
+ */
+interface SavedViewsRequest {
+    readonly value: SavedViewsState;
+    readonly previous: SavedViewsState;
+    readonly reason: SavedViewsReason;
+    readonly action: SavedViewsAction;
+    readonly source?: Event | undefined;
+    readonly cancelled: boolean;
+    /** Refuses the request. Nothing commits and no view is applied. */
+    cancel(): void;
+}
+/** What `viewApply` emits: the view to write into the grid, and the request that caused it. */
+interface SavedViewApply {
+    readonly view: GridView;
+    readonly request: SavedViewsRequest;
+}
+declare class SlSavedViewsIdFactory {
+    private count;
+    next(): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlSavedViewsIdFactory, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<any>;
+}
+/** `crypto.randomUUID()` where the platform has it, and a counter otherwise. */
+declare function newSavedViewId(): string;
+
+/** What replaces a row, or opens above the footer. */
+type Editing = {
+    kind: 'create';
+} | {
+    kind: 'rename';
+    id: string;
+} | {
+    kind: 'delete';
+    id: string;
+} | null;
+/** One row of the list: the built-in view has no id and no saved view. */
+interface Row {
+    readonly id: string | null;
+    readonly key: string;
+    readonly name: string;
+    readonly view: SavedView | null;
+    readonly current: boolean;
+    readonly isDefault: boolean;
+}
+/**
+ * `slMenuTriggerFor` binds `[attr.data-part]` and resolves it to `null` on a
+ * trigger that is neither a bar's item nor a submenu's; a host binding of
+ * `null` removes the part the template wrote. The part is written back after
+ * the first change detection, where the constant binding is not applied again.
+ */
+declare class SlSavedViewsPart {
+    readonly slSavedViewsPart: _angular_core.InputSignal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlSavedViewsPart, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlSavedViewsPart, "[slSavedViewsPart]", never, { "slSavedViewsPart": { "alias": "slSavedViewsPart"; "required": true; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+/**
+ * The named views of a grid, and the one in use: a trigger naming it, a mark
+ * and a revert while the grid differs from it, and a popover listing every
+ * view with its actions. The family applies nothing to a grid — it asks with
+ * `stateChangeRequest` and hands the consumer the view to write through
+ * `viewApply`.
+ */
+declare class SlSavedViews {
+    /** The view the grid shows now. */
+    readonly current: _angular_core.InputSignal<GridView>;
+    /** The built-in view: the application's defaults. */
+    readonly builtIn: _angular_core.InputSignal<GridView>;
+    /** The model, so a view is serialized and compared against the columns it names. */
+    readonly columns: _angular_core.InputSignal<readonly GridColumn<never>[] | undefined>;
+    /** The views. Two-way, so a template may bind it directly; cancel the request to hold it. */
+    readonly state: _angular_core.ModelSignal<SavedViewsState | undefined>;
+    /** The views an unbound instance starts from. */
+    readonly defaultState: _angular_core.InputSignal<SavedViewsState | undefined>;
+    /** Whether the layer is open. Two-way. */
+    readonly open: _angular_core.ModelSignal<boolean | undefined>;
+    readonly defaultOpen: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Words laid over the catalog of the language in force, key by key: the
+     * group's and the panel's name (`label`), the controls, the forms and the
+     * announcements. A host `aria-label` names both instead.
+     */
+    readonly messages: _angular_core.InputSignal<PartialMessages<SavedViewsMessages> | undefined>;
+    /** Every change to the views, carrying the action and the reason; cancellable. */
+    readonly stateChangeRequest: _angular_core.OutputEmitterRef<SavedViewsRequest>;
+    /** One output for one transition of the layer. */
+    readonly openChangeRequest: _angular_core.OutputEmitterRef<ChangeRequest<boolean>>;
+    /** After apply and revert: the view to write into the grid. */
+    readonly viewApply: _angular_core.OutputEmitterRef<SavedViewApply>;
+    private readonly injector;
+    private readonly host;
+    protected readonly role: string;
+    protected readonly writtenLabel: string | null;
+    readonly panelId: string;
+    private readonly triggerRef;
+    protected readonly editing: _angular_core.WritableSignal<Editing>;
+    protected readonly draft: _angular_core.WritableSignal<string>;
+    protected readonly error: _angular_core.WritableSignal<"empty" | "duplicate" | null>;
+    /** The family's words in the language in force, with this control's `messages` laid over them. */
+    readonly t: _slotted_core_i18n.FamilyTranslator<SavedViewsMessages>;
+    readonly resolvedLabel: _angular_core.Signal<string>;
+    readonly resolvedState: _angular_core.Signal<SavedViewsState>;
+    readonly isOpen: _angular_core.Signal<boolean>;
+    readonly active: _angular_core.Signal<SavedView | null>;
+    readonly activeView: _angular_core.Signal<GridView>;
+    readonly modified: _angular_core.Signal<boolean>;
+    readonly activeName: _angular_core.Signal<string>;
+    readonly canSave: _angular_core.Signal<boolean>;
+    readonly rows: _angular_core.Signal<readonly Row[]>;
+    /** A click the keyboard produced has no pointer detail. */
+    protected pressReason(event: MouseEvent): 'pointer' | 'keyboard';
+    protected editingKind(row: Row): 'rename' | 'delete' | null;
+    /** Opens the layer, carrying `programmatic`. */
+    show(): void;
+    /** Closes the layer, carrying `programmatic`. */
+    hide(): void;
+    /** Moves focus to the trigger. */
+    focus(): void;
+    /** Applies a view by id — `null` is the built-in view — carrying the reason. */
+    apply(id: string | null, reason?: SavedViewsReason, source?: Event): void;
+    protected revert(event: MouseEvent): void;
+    protected save(event: MouseEvent): void;
+    protected setDefault(id: string | null, event: MenuSelectEvent): void;
+    protected startCreate(): void;
+    protected startRename(view: SavedView): void;
+    protected startDelete(view: SavedView): void;
+    /** Cancelling returns focus to the control that opened the form. */
+    protected cancelEditing(): void;
+    protected onDraft(value: string | undefined): void;
+    protected submit(event: Event): void;
+    protected confirmDelete(id: string, event: MouseEvent): void;
+    /**
+     * The dismissable layer asks in the capture phase. The popover's own move is
+     * always refused here and replayed as this family's request, so the layer
+     * follows one open state; a form open inside is cancelled first and the
+     * close is refused.
+     */
+    protected onLayerRequest(request: ChangeRequest<boolean>): void;
+    private setOpen;
+    /** Asks for a new state. Not emitted when nothing would change; refused when cancelled. */
+    private request;
+    private closeForms;
+    private announce;
+    private focusAfterRender;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlSavedViews, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlSavedViews, "sl-saved-views", ["slSavedViews"], { "current": { "alias": "current"; "required": true; "isSignal": true; }; "builtIn": { "alias": "builtIn"; "required": true; "isSignal": true; }; "columns": { "alias": "columns"; "required": false; "isSignal": true; }; "state": { "alias": "state"; "required": false; "isSignal": true; }; "defaultState": { "alias": "defaultState"; "required": false; "isSignal": true; }; "open": { "alias": "open"; "required": false; "isSignal": true; }; "defaultOpen": { "alias": "defaultOpen"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; }, { "state": "stateChange"; "open": "openChange"; "stateChangeRequest": "stateChangeRequest"; "openChangeRequest": "openChangeRequest"; "viewApply": "viewApply"; }, never, never, true, never>;
+}
+
+interface PersistedSavedViewsOptions {
+    /** The entry the views are kept under. */
+    readonly key: string;
+    /** Default `window.localStorage`; `null` keeps the views in memory only. */
+    readonly storage?: GridViewStorage | null | undefined;
+    /** The model, so the default view a visit opens on is parsed against it. */
+    readonly columns?: readonly GridColumn<never>[] | undefined;
+    /** Required outside an injection context. */
+    readonly injector?: Injector | undefined;
+}
+interface PersistedSavedViews {
+    /** Bind with `[(state)]`. */
+    readonly state: WritableSignal<SavedViewsState>;
+    /**
+     * The default view this visit opened on, when the store held no view in use
+     * and a default: the state already names it as active, and the grid still
+     * has to be given it once. `null` otherwise.
+     */
+    readonly openedDefault: GridView | null;
+}
+/**
+ * A reader's saved views, kept across visits: read once from the store with
+ * `parseSavedViews` — which is total, so a malformed entry is no views — and
+ * written with `serializeSavedViews` after every change. A store that holds
+ * no view in use and a default opens the visit on the default. The store is
+ * reached inside `try` both ways, as `persistedGridView` reaches it.
+ */
+declare function persistedSavedViews({ key, storage, columns, injector, }: PersistedSavedViewsOptions): PersistedSavedViews;
+
+export { SlSavedViews, SlSavedViewsIdFactory, SlSavedViewsPart, newSavedViewId, persistedSavedViews };
+export type { PersistedSavedViews, PersistedSavedViewsOptions, SavedViewApply, SavedViewsAction, SavedViewsOpenReason, SavedViewsReason, SavedViewsRequest };
+//# sourceMappingURL=slotted-angular-saved-views.d.ts.map

package/types/slotted-angular-saved-views.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-saved-views.d.ts","sources":["../../saved-views/src/saved-views-defaults.ts","../../saved-views/src/saved-views.ts","../../saved-views/src/persisted-saved-views.ts"],"mappings":";;;;;;;;AAIA;KACY,gBAAgB;AAG5B;AACM,KAAM,gBAAgB;AAE5B;AACM,KAAM,oBAAoB,GAAG,OAAO,CACxC,aAAa;AAIf;;;;AAIG;UACc,iBAAiB;AAChC,oBAAgB,eAAe;AAC/B,uBAAmB,eAAe;AAClC,qBAAiB,gBAAgB;AACjC,qBAAiB,gBAAgB;AACjC,sBAAkB,KAAK;AACvB;;;AAGD;AAED;UACiB,cAAc;AAC7B,mBAAe,QAAQ;AACvB,sBAAkB,iBAAiB;AACpC;AAED,cACa,qBAAqB;;;oDAArB,qBAAqB;;AAOjC;AAID;AACA,iBAAgB,cAAc;;ACiB9B;AACA,KAAK,OAAO;;;;;;;;AAC0E;AAOtF;AACA,UAAU,GAAG;AACX;AACA;AACA;AACA,mBAAe,SAAS;AACxB;AACA;AACD;AAED;;;;;AAKG;AACH,cACa,gBAAgB;+BACF,aAAA,CAAA,WAAA;;oDADd,gBAAgB;sDAAhB,gBAAgB;AAO5B;AAED;;;;;;AAMG;AACH,cAyOa,YAAY;;sBAEP,aAAA,CAAA,WAAA,CAAA,QAAA;;sBAEA,aAAA,CAAA,WAAA,CAAA,QAAA;;sBAEA,aAAA,CAAA,WAAA,UAAA,UAAA;;oBAEF,aAAA,CAAA,WAAA,CAAA,eAAA;;2BAEO,aAAA,CAAA,WAAA,CAAA,eAAA;;mBAER,aAAA,CAAA,WAAA;0BACO,aAAA,CAAA,wBAAA;AACpB;;;;AAIG;uBACc,aAAA,CAAA,WAAA,CAAA,eAAA,CAAA,kBAAA;;iCAGU,aAAA,CAAA,gBAAA,CAAA,iBAAA;;gCAED,aAAA,CAAA,gBAAA,CAAA,aAAA;;wBAER,aAAA,CAAA,gBAAA,CAAA,cAAA;AAElB;AACA;AACA;AACA;;AAKA;AAEA,gCAA0B,aAAA,CAAA,cAAA,CAAA,OAAA;AAC1B,8BAAwB,aAAA,CAAA,cAAA;AACxB,8BAAwB,aAAA,CAAA,cAAA;;gBAGd,kBAAA,CAAA,gBAAA,CAAA,kBAAA;4BACY,aAAA,CAAA,MAAA;4BACA,aAAA,CAAA,MAAA,CAAA,eAAA;qBAGP,aAAA,CAAA,MAAA;qBACA,aAAA,CAAA,MAAA,CAAA,SAAA;yBAII,aAAA,CAAA,MAAA,CAAA,QAAA;uBAIF,aAAA,CAAA,MAAA;yBAGE,aAAA,CAAA,MAAA;sBACH,aAAA,CAAA,MAAA;mBACH,aAAA,CAAA,MAAA,UAAA,GAAA;;iCAuBgB,UAAU;+BAIZ,GAAG;;;;;;;;AAsB9B,sCAAiC,gBAAiC,WAAW,KAAK;AAgBlF,4BAAwB,UAAU;AAQlC,0BAAsB,UAAU;mDAce,eAAe;AAQ9D;AAOA,gCAA4B,SAAS;AAOrC,gCAA4B,SAAS;;AAOrC;AASA;AAKA,4BAAwB,KAAK;+CAmCc,UAAU;AAWrD;;;;;AAKG;sCAC+B,aAAa;AAa/C;;AAsBA;AA4BA;AAMA;AAIA;oDA7TW,YAAY;sDAAZ,YAAY;AAwVxB;;UCpqBgB,0BAA0B;;AAEzC;;uBAEmB,eAAe;;AAElC,gCAA4B,UAAU;;AAEtC,wBAAoB,QAAQ;AAC7B;UAEgB,mBAAmB;;AAElC,oBAAgB,cAAc,CAAC,eAAe;AAC9C;;;;AAIG;AACH,4BAAwB,QAAQ;AACjC;AAUD;;;;;;AAMG;AACH,iBAAgB,mBAAmB,uCAKhC,0BAA0B,GAAG,mBAAmB;;","names":[]}

package/types/slotted-angular-scroll-area.d.ts

@@ -0,0 +1,186 @@
+import * as _slotted_core_i18n from '@slotted/core/i18n';
+import { PartialMessages, ScrollAreaMessages } from '@slotted/core/i18n';
+import * as _angular_core from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { ScrollPosition, ScrollEdgesState, LogicalEdge } from '@slotted/core/overflow';
+export { LogicalEdge, ScrollEdgesState, ScrollPosition } from '@slotted/core/overflow';
+
+/** Which axes scroll. Logical, so a vertical writing mode needs no second vocabulary. */
+type ScrollAreaAxis = 'block' | 'inline' | 'both';
+/**
+ * What the scrollbar does. `auto` is `overflow: auto`; `always` is
+ * `overflow: scroll`; `hover` paints the bar transparent until a pointer or the
+ * keyboard is inside; `none` removes the bar and leaves the scrolling.
+ *
+ * `scroll` — visible only while scrolling, which Radix and Mantine both ship —
+ * is folded into `hover`, because it is what a platform overlay scrollbar
+ * already does on its own.
+ */
+type ScrollAreaScrollbars = 'auto' | 'always' | 'hover' | 'none';
+/** `scrollbar-gutter`, and `stable` is the default because content that shifts is the defect. */
+type ScrollAreaGutter = 'auto' | 'stable' | 'both-edges';
+/**
+ * Where the veil is drawn. `both` dims what the reader has passed as well as
+ * what is ahead; `end` only what is ahead; `none` leaves the scrollbar to say
+ * there is more.
+ */
+type ScrollAreaFade = 'both' | 'end' | 'none';
+/** `overscroll-behavior`, and `contain` is the default. */
+type ScrollAreaOverscroll = 'contain' | 'auto' | 'none';
+interface ScrollAreaDefaults {
+    axis: ScrollAreaAxis;
+    scrollbars: ScrollAreaScrollbars;
+    gutter: ScrollAreaGutter;
+    fade: ScrollAreaFade;
+    overscroll: ScrollAreaOverscroll;
+}
+declare const SCROLL_AREA_DEFAULTS: InjectionToken<ScrollAreaDefaults>;
+/**
+ * An application decides once what its scroll areas look like — whether the
+ * bar waits for a hand, whether the veil dims both ends — rather than repeating
+ * it on fifty of them. A region's name comes from the language in force
+ * (`provideSlotted`).
+ *
+ * None of the five surveyed implementations has an equivalent: each takes its
+ * policy per instance, and Mantine's `type` in particular is written on every
+ * call site of every product that uses it.
+ */
+declare function provideScrollAreaDefaults(defaults: Partial<ScrollAreaDefaults>): {
+    provide: InjectionToken<ScrollAreaDefaults>;
+    useFactory: () => ScrollAreaDefaults;
+};
+/** What a scroll area is here, before it states anything of its own. */
+declare function injectScrollAreaDefaults(): ScrollAreaDefaults;
+
+/** What `scrollChange` carries: where the scroller is, and the event that moved it. */
+interface ScrollAreaScrollEvent {
+    readonly position: ScrollPosition;
+    readonly source: Event;
+}
+/**
+ * A scrollport, and the box that frames it.
+ *
+ * The scrollbar is the platform's, themed by the stylesheet through
+ * `scrollbar-color`; the keyboard is the platform's too. What this component
+ * adds is the measurement of whether the content overflows and which of its
+ * ends show, published on the frame for CSS and emitted to the consumer, and
+ * the tab stop a scrolling region owes a keyboard together with the name that
+ * tab stop owes a screen reader — both written only while the content actually
+ * overflows, which is the pattern `prose` shipped first for one block inside a
+ * document.
+ *
+ * The frame is the consumer's own element — `<div slScrollArea>` — and the
+ * scrollport is the component's, projected into: the frame is where a border,
+ * a radius and a ground go, and the scrollport is the element the veil is on.
+ * A consumer's own attributes on the host are never written over, because the
+ * family writes its role, its tab stop and its name on an element it owns.
+ *
+ * The scroll position is never held. The browser moves it on a wheel, a
+ * fling, a `Tab` into a child, an anchor navigation and a printed page, and a
+ * consumer holding the value would have to accept every one of those or fight
+ * the platform. It is emitted, and the instance moves it.
+ */
+declare class SlScrollArea {
+    readonly axis: _angular_core.InputSignal<ScrollAreaAxis | undefined>;
+    readonly scrollbars: _angular_core.InputSignal<ScrollAreaScrollbars | undefined>;
+    readonly gutter: _angular_core.InputSignal<ScrollAreaGutter | undefined>;
+    readonly fade: _angular_core.InputSignal<ScrollAreaFade | undefined>;
+    readonly overscroll: _angular_core.InputSignal<ScrollAreaOverscroll | undefined>;
+    /**
+     * Scroll only past this size, as any CSS length. It is Mantine's
+     * `ScrollArea.Autosize` as one binding rather than a second component.
+     */
+    readonly maxBlockSize: _angular_core.InputSignal<string | undefined>;
+    readonly maxInlineSize: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Whether the scrollport joins the tab sequence while it overflows.
+     *
+     * On by default, because content that scrolls has to be scrollable by
+     * keyboard and a scrollport with no tab stop is not — unless a child of it
+     * already takes focus. A consumer who knows the content is reachable another
+     * way turns it off and carries the reason.
+     */
+    readonly tabbable: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * The name the region is announced by. Resolved in one order: `labelledBy`,
+     * then `messages.label`, then the catalog of the language in force.
+     */
+    readonly labelledBy: _angular_core.InputSignal<string | undefined>;
+    /** Words laid over the catalog of the language in force: the region's name (`label`). */
+    readonly messages: _angular_core.InputSignal<PartialMessages<ScrollAreaMessages> | undefined>;
+    /**
+     * The position, as a distance from each logical start, on every scroll. It
+     * is a report and not a request: the browser moves the position on a wheel,
+     * a fling, a `Tab` into a child and a printed page, and a consumer holding it
+     * would have to accept every one of those.
+     */
+    readonly scrollChange: _angular_core.OutputEmitterRef<ScrollAreaScrollEvent>;
+    /** The measurement, and only a new one: which axes overflow, and which ends show. */
+    readonly overflowChange: _angular_core.OutputEmitterRef<ScrollEdgesState>;
+    private readonly defaults;
+    /** The family's words in the language in force, with this area's `messages` laid over them. */
+    readonly t: _slotted_core_i18n.FamilyTranslator<ScrollAreaMessages>;
+    private readonly element;
+    private readonly destroyRef;
+    private readonly viewportRef;
+    /**
+     * The measurement, as a signal, so the attributes it becomes are rendered.
+     * Before the first render it is the state of content that fits — four ends
+     * showing and nothing overflowing — which paints no veil and writes no tab
+     * stop, so a server render and its hydration agree and the veil does not
+     * flash on before the browser has said whether there is anything behind it.
+     */
+    private readonly measured;
+    protected readonly sideways: _angular_core.WritableSignal<boolean>;
+    private edges;
+    protected readonly resolvedAxis: _angular_core.Signal<ScrollAreaAxis>;
+    protected readonly resolvedScrollbars: _angular_core.Signal<ScrollAreaScrollbars>;
+    protected readonly resolvedGutter: _angular_core.Signal<ScrollAreaGutter>;
+    protected readonly resolvedFade: _angular_core.Signal<ScrollAreaFade>;
+    protected readonly resolvedOverscroll: _angular_core.Signal<ScrollAreaOverscroll>;
+    protected readonly edgeAttributes: _angular_core.Signal<Record<string, string>>;
+    protected readonly overflowing: _angular_core.Signal<boolean>;
+    protected readonly wired: _angular_core.Signal<boolean>;
+    protected readonly ariaLabelledBy: _angular_core.Signal<string | null>;
+    protected readonly ariaLabel: _angular_core.Signal<string | null>;
+    constructor();
+    /** The frame: the consumer's own element. */
+    get root(): HTMLElement;
+    /** The scrollport: the element that scrolls and takes focus. */
+    get viewport(): HTMLElement;
+    /** The last measurement: whether each axis overflows, and which of its ends show. */
+    state(): ScrollEdgesState;
+    /** The distance from each logical start, read now. */
+    position(): ScrollPosition;
+    /** Moves to a logical position. An axis left out is an axis left alone. */
+    scrollTo(target: Partial<ScrollPosition>): void;
+    /** Moves to one end of one axis. */
+    scrollToEdge(edge: LogicalEdge): void;
+    /** Brings one element into view by the shortest movement that does it, without moving anything else. */
+    reveal(element: Element): void;
+    /** Measures again, after content the observer could not see changed. */
+    refresh(): void;
+    /** Moves focus to the scrollport. */
+    focus(): void;
+    protected onScroll(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlScrollArea, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlScrollArea, "[slScrollArea]", ["slScrollArea"], { "axis": { "alias": "axis"; "required": false; "isSignal": true; }; "scrollbars": { "alias": "scrollbars"; "required": false; "isSignal": true; }; "gutter": { "alias": "gutter"; "required": false; "isSignal": true; }; "fade": { "alias": "fade"; "required": false; "isSignal": true; }; "overscroll": { "alias": "overscroll"; "required": false; "isSignal": true; }; "maxBlockSize": { "alias": "maxBlockSize"; "required": false; "isSignal": true; }; "maxInlineSize": { "alias": "maxInlineSize"; "required": false; "isSignal": true; }; "tabbable": { "alias": "tabbable"; "required": false; "isSignal": true; }; "labelledBy": { "alias": "labelledBy"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; }, { "scrollChange": "scrollChange"; "overflowChange": "overflowChange"; }, never, ["*"], true, never>;
+}
+/**
+ * The inset that scrolls with the content.
+ *
+ * Padding on a scrollport is not applied at the end edge of its scrollable
+ * overflow in every engine, so an inset that has to survive a scroll to the
+ * end goes on an element inside it. The family states no inset of its own: the
+ * directive exists to give the consumer's one a place to live, on the
+ * consumer's own element, and an area whose content already carries its own
+ * inset uses no `slScrollAreaContent` at all.
+ */
+declare class SlScrollAreaContent {
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlScrollAreaContent, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlScrollAreaContent, "[slScrollAreaContent]", ["slScrollAreaContent"], {}, {}, never, never, true, never>;
+}
+
+export { SCROLL_AREA_DEFAULTS, SlScrollArea, SlScrollAreaContent, injectScrollAreaDefaults, provideScrollAreaDefaults };
+export type { ScrollAreaAxis, ScrollAreaDefaults, ScrollAreaFade, ScrollAreaGutter, ScrollAreaOverscroll, ScrollAreaScrollEvent, ScrollAreaScrollbars };
+//# sourceMappingURL=slotted-angular-scroll-area.d.ts.map

package/types/slotted-angular-scroll-area.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-scroll-area.d.ts","sources":["../../scroll-area/src/scroll-area-defaults.ts","../../scroll-area/src/scroll-area.ts"],"mappings":";;;;;;;AAEA;AACM,KAAM,cAAc;AAE1B;;;;;;;;AAQG;AACG,KAAM,oBAAoB;AAEhC;AACM,KAAM,gBAAgB;AAE5B;;;;AAIG;AACG,KAAM,cAAc;AAE1B;AACM,KAAM,oBAAoB;UAEf,kBAAkB;UAC3B,cAAc;gBACR,oBAAoB;YACxB,gBAAgB;UAClB,cAAc;gBACR,oBAAoB;AACjC;AAUD,cAAa,oBAAoB,EAAA,cAAA,CAAA,kBAAA;AAKjC;;;;;;;;;AASG;AACH,iBAAgB,yBAAyB,WAAW,OAAO,CAAC,kBAAkB;;sBAG1D,kBAAkB;AAErC;AAED;AACA,iBAAgB,wBAAwB,IAAI,kBAAkB;;AC3B9D;UACiB,qBAAqB;AACpC,uBAAmB,cAAc;AACjC,qBAAiB,KAAK;AACvB;AAED;;;;;;;;;;;;;;;;;;;;;;AAsBG;AACH,cAsCa,YAAY;mBACV,aAAA,CAAA,WAAA,CAAA,cAAA;yBACM,aAAA,CAAA,WAAA,CAAA,oBAAA;qBACJ,aAAA,CAAA,WAAA,CAAA,gBAAA;mBACF,aAAA,CAAA,WAAA,CAAA,cAAA;yBACM,aAAA,CAAA,WAAA,CAAA,oBAAA;AAEnB;;;AAGG;2BACkB,aAAA,CAAA,WAAA;4BACC,aAAA,CAAA,WAAA;AAEtB;;;;;;;AAOG;uBACc,aAAA,CAAA,wBAAA;AAEjB;;;AAGG;yBACgB,aAAA,CAAA,WAAA;;uBAEF,aAAA,CAAA,WAAA,CAAA,eAAA,CAAA,kBAAA;AAEjB;;;;;AAKG;2BACkB,aAAA,CAAA,gBAAA,CAAA,qBAAA;;6BAGE,aAAA,CAAA,gBAAA,CAAA,gBAAA;AAEvB;;gBAEU,kBAAA,CAAA,gBAAA,CAAA,kBAAA;AACV;AACA;AACA;AAEA;;;;;;AAMG;AACH;AACA,iCAA2B,aAAA,CAAA,cAAA;;AAG3B,qCAA+B,aAAA,CAAA,MAAA,CAAA,cAAA;AAC/B,2CAAqC,aAAA,CAAA,MAAA,CAAA,oBAAA;AAGrC,uCAAiC,aAAA,CAAA,MAAA,CAAA,gBAAA;AACjC,qCAA+B,aAAA,CAAA,MAAA,CAAA,cAAA;AAC/B,2CAAqC,aAAA,CAAA,MAAA,CAAA,oBAAA;AAIrC,uCAAiC,aAAA,CAAA,MAAA,CAAA,MAAA;AAEjC,oCAA8B,aAAA,CAAA,MAAA;AAI9B,8BAAwB,aAAA,CAAA,MAAA;AACxB,uCAAiC,aAAA,CAAA,MAAA;AAGjC,kCAA4B,aAAA,CAAA,MAAA;;;gBAiChB,WAAW;;oBAKP,WAAW;;AAK3B,aAAS,gBAAgB;;AAKzB,gBAAY,cAAc;;qBAKT,OAAO,CAAC,cAAc;;AAKvC,uBAAmB,WAAW;;AAK9B,oBAAgB,OAAO;;AAKvB;;AAKA;AAIA,8BAA0B,KAAK;oDA9JpB,YAAY;sDAAZ,YAAY;AAkKxB;AAED;;;;;;;;;AASG;AACH,cAMa,mBAAmB;oDAAnB,mBAAmB;sDAAnB,mBAAmB;AAAG;;","names":[]}

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

@@ -0,0 +1,143 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, OnInit, OnDestroy } from '@angular/core';
+import * as _slotted_angular_typography from '@slotted/angular/typography';
+import { HeadingLevelValue } from '@slotted/angular/typography';
+
+/** The type step the heading sits at, independent of its rank. */
+type SectionSize = 'sm' | 'md' | 'lg';
+/** The rank of the heading. `auto` takes the one the outline gives. */
+type SectionLevel = 'auto' | '1' | '2' | '3' | '4' | '5' | '6';
+/** The ground: nothing, or a surface with an edge and a radius and no shadow. */
+type SectionGround = 'none' | 'surface';
+interface SectionDefaults {
+    divider: boolean;
+    ground: SectionGround;
+    size: SectionSize;
+    sticky: boolean;
+}
+declare const SECTION_DEFAULTS: InjectionToken<SectionDefaults>;
+/**
+ * An application decides once how its sections separate — a rule, a surface,
+ * the step of their headings — rather than repeating the same inputs on every
+ * one. A section that states any of them itself still wins.
+ */
+declare function provideSectionDefaults(defaults: Partial<SectionDefaults>): {
+    provide: InjectionToken<SectionDefaults>;
+    useFactory: () => SectionDefaults;
+};
+/** What a section renders as here, before it states anything of its own. */
+declare function injectSectionDefaults(): SectionDefaults;
+/** Application-scoped, for the reason `field` records: the server and the client sequences must match. */
+declare class SlSectionIdFactory {
+    private count;
+    next(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlSectionIdFactory, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+
+/**
+ * One unit of content inside a page: a header — eyebrow, heading,
+ * description, actions — and a body one outline step deeper.
+ *
+ * **The rank is the outline's.** `typography` owns it: the heading takes the
+ * rank `slHeadingLevel` gives — `h2` directly in a page body, one deeper
+ * inside another section's body — unless `level` says otherwise. The element
+ * is the consumer's: `<h2 slSectionHeading>` is a native heading and the
+ * directive adds nothing to it; `<div slSectionHeading>` gets `role="heading"`
+ * and the level the section resolved.
+ *
+ * **A region only when it has a name.** The root is `aria-labelledby` its
+ * heading once one is rendered, which makes the `section` a region landmark.
+ *
+ * **The hooks anchor navigation needs.** The root carries an `id`, the
+ * consumer's own or a generated one, and a scroll margin the height of the
+ * page's fixed chrome, so a hash link lands under the header.
+ */
+/** The measured height of a sticky section's header, written on the root. */
+declare const HEADER_SIZE_PROPERTY = "--slotted-section-header-size";
+declare class SlSection {
+    readonly size: i0.InputSignal<SectionSize | undefined>;
+    /** Defaults to `auto`: the rank the outline gives. */
+    readonly level: i0.InputSignal<SectionLevel | undefined>;
+    readonly ground: i0.InputSignal<SectionGround | undefined>;
+    readonly divider: i0.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    readonly sticky: i0.InputSignalWithTransform<boolean | undefined, string | boolean | undefined>;
+    private readonly defaults;
+    private readonly outline;
+    private readonly writtenId;
+    private readonly generated;
+    /** Whether a heading is rendered, which is what makes the section a region. */
+    readonly hasHeading: i0.WritableSignal<boolean>;
+    /** The header element, handed over by `slSectionHeader`, so a sticky header can be measured. */
+    readonly header: i0.WritableSignal<HTMLElement | null>;
+    private readonly native;
+    readonly id: i0.Signal<string>;
+    readonly headingId: i0.Signal<string>;
+    readonly resolvedSize: i0.Signal<SectionSize>;
+    readonly resolvedGround: i0.Signal<SectionGround>;
+    readonly resolvedDivider: i0.Signal<boolean>;
+    readonly resolvedSticky: i0.Signal<boolean>;
+    readonly resolvedLevel: i0.Signal<HeadingLevelValue>;
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlSection, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SlSection, "[slSection]", ["slSection"], { "size": { "alias": "size"; "required": false; "isSignal": true; }; "level": { "alias": "level"; "required": false; "isSignal": true; }; "ground": { "alias": "ground"; "required": false; "isSignal": true; }; "divider": { "alias": "divider"; "required": false; "isSignal": true; }; "sticky": { "alias": "sticky"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+/**
+ * The row above the body: the title column and the actions. It hands the
+ * root its element, so a sticky header's height reaches the stylesheet.
+ */
+declare class SlSectionHeader implements OnInit, OnDestroy {
+    private readonly section;
+    private readonly native;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlSectionHeader, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlSectionHeader, "[slSectionHeader]", never, {}, {}, never, never, true, never>;
+}
+/** Eyebrow, heading, description, in that order. */
+declare class SlSectionTitle {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlSectionTitle, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlSectionTitle, "[slSectionTitle]", never, {}, {}, never, never, true, never>;
+}
+/** A short overline above the heading — a count, a category. Structural, not status. */
+declare class SlSectionEyebrow {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlSectionEyebrow, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlSectionEyebrow, "[slSectionEyebrow]", never, {}, {}, never, never, true, never>;
+}
+/** A paragraph under the heading, in the muted text, with a measure. */
+declare class SlSectionDescription {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlSectionDescription, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlSectionDescription, "[slSectionDescription]", never, {}, {}, never, never, true, never>;
+}
+/** The end of the header row: a button, a toolbar, a link. */
+declare class SlSectionActions {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlSectionActions, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlSectionActions, "[slSectionActions]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * The heading, at the rank the section resolved. Rendering it is what makes
+ * the section a region: the root names it through `aria-labelledby`. The
+ * element is the consumer's own — a native heading gets nothing added, and
+ * anything else gets `role="heading"` and `aria-level`.
+ */
+declare class SlSectionHeading implements OnInit, OnDestroy {
+    protected readonly section: SlSection;
+    private readonly native;
+    private readonly isNativeHeading;
+    protected readonly ariaRole: i0.Signal<"heading" | null>;
+    protected readonly ariaLevel: i0.Signal<_slotted_angular_typography.HeadingLevelValue | null>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlSectionHeading, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlSectionHeading, "[slSectionHeading]", ["slSectionHeading"], {}, {}, never, never, true, never>;
+}
+/** The content, one outline step deeper: `slHeadingLevel` is a host directive. */
+declare class SlSectionBody {
+    static ɵfac: i0.ɵɵFactoryDeclaration<SlSectionBody, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SlSectionBody, "[slSectionBody]", never, {}, {}, never, never, true, [{ directive: typeof _slotted_angular_typography.SlHeadingLevel; inputs: {}; outputs: {}; }]>;
+}
+
+export { HEADER_SIZE_PROPERTY, SECTION_DEFAULTS, SlSection, SlSectionActions, SlSectionBody, SlSectionDescription, SlSectionEyebrow, SlSectionHeader, SlSectionHeading, SlSectionIdFactory, SlSectionTitle, injectSectionDefaults, provideSectionDefaults };
+export type { SectionDefaults, SectionGround, SectionLevel, SectionSize };
+//# sourceMappingURL=slotted-angular-section.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-section.d.ts","sources":["../../section/src/section-defaults.ts","../../section/src/section.ts","../../section/src/section-parts.ts"],"mappings":";;;;;AAEA;AACM,KAAM,WAAW;AAEvB;KACY,YAAY;AAExB;KACY,aAAa;UAER,eAAe;;YAEtB,aAAa;UACf,WAAW;;AAElB;AASD,cAAa,gBAAgB,EAAA,cAAA,CAAA,eAAA;AAK7B;;;;AAIG;AACH,iBAAgB,sBAAsB,WAAW,OAAO,CAAC,eAAe;;sBAGpD,eAAe;AAElC;AAED;AACA,iBAAgB,qBAAqB,IAAI,eAAe;AAIxD;AACA,cACa,kBAAkB;;;yCAAlB,kBAAkB;;AAO9B;;ACnCD;;;;;;;;;;;;;;;;;AAiBG;AACH;AACA,cAAa,oBAAoB;AAEjC,cAoBa,SAAS;mBACPA,EAAA,CAAA,WAAA,CAAA,WAAA;;oBAECA,EAAA,CAAA,WAAA,CAAA,YAAA;qBACCA,EAAA,CAAA,WAAA,CAAA,aAAA;sBACCA,EAAA,CAAA,wBAAA;qBAGDA,EAAA,CAAA,wBAAA;AAIf;AACA;AACA;AACA;;yBAGmBA,EAAA,CAAA,cAAA;;qBAEJA,EAAA,CAAA,cAAA,CAAA,WAAA;AAEf;iBAEWA,EAAA,CAAA,MAAA;wBACOA,EAAA,CAAA,MAAA;2BACGA,EAAA,CAAA,MAAA,CAAA,WAAA;6BACEA,EAAA,CAAA,MAAA,CAAA,aAAA;8BACCA,EAAA,CAAA,MAAA;6BACDA,EAAA,CAAA,MAAA;4BACDA,EAAA,CAAA,MAAA,CAAA,iBAAA;;yCA9BX,SAAS;2CAAT,SAAS;AA8DrB;;ACpHD;;;AAGG;AACH,cACa,eAAgB,YAAW,MAAM,EAAE,SAAS;AACvD;AACA;;;yCAFW,eAAe;2CAAf,eAAe;AAW3B;AAED;AACA,cACa,cAAc;yCAAd,cAAc;2CAAd,cAAc;AAAG;AAE9B;AACA,cACa,gBAAgB;yCAAhB,gBAAgB;2CAAhB,gBAAgB;AAAG;AAEhC;AACA,cAKa,oBAAoB;yCAApB,oBAAoB;2CAApB,oBAAoB;AAAG;AAEpC;AACA,cACa,gBAAgB;yCAAhB,gBAAgB;2CAAhB,gBAAgB;AAAG;AAEhC;;;;;AAKG;AACH,cAWa,gBAAiB,YAAW,MAAM,EAAE,SAAS;AACxD,gCAA0B,SAAA;AAC1B;AACA;AAEA,iCAA2BA,EAAA,CAAA,MAAA;AAC3B,kCAA4BA,EAAA,CAAA,MAAA,CAAA,2BAAA,CAAA,iBAAA;;;yCANjB,gBAAgB;2CAAhB,gBAAgB;AAiB5B;AAED;AACA,cAMa,aAAa;yCAAb,aAAa;2CAAb,aAAa,6EAAAC,2BAAA,CAAA,cAAA;AAAG;;","names":["_angular_core","i1"]}