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

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

@@ -0,0 +1,141 @@
+import * as _slotted_core_i18n from '@slotted/core/i18n';
+import { PartialMessages, PageMessages } from '@slotted/core/i18n';
+import * as _angular_core from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { PresenceStatus } from '@slotted/core/presence';
+import * as i1 from '@slotted/angular/typography';
+
+/** The width of the content column: the container's own sizes. */
+type PageWidth = 'measure' | 'content' | 'wide' | 'full' | 'bleed';
+/** The inset of the content column from the edge of the page: the container's own steps. */
+type PageInset = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
+/**
+ * Who scrolls. `ancestor` puts the page inside whatever scrolls and makes it
+ * at least as tall as that, so the footer has a bottom to stick to. `self`
+ * makes the page's own scroll part the scroller, with the footer below it.
+ */
+type PageScroll = 'ancestor' | 'self';
+/** The ground: the sunken canvas of an application, or the plain surface of a document. */
+type PageGround = 'sunken' | 'surface';
+/** Whether the root is the document's `main` landmark. */
+type PageLandmark = 'main' | 'none';
+interface PageDefaults {
+    ground: PageGround;
+    inset: PageInset;
+    landmark: PageLandmark;
+    scroll: PageScroll;
+    width: PageWidth;
+}
+declare const PAGE_DEFAULTS: InjectionToken<PageDefaults>;
+/**
+ * An application decides once how its pages are laid out — the measure, the
+ * inset, who scrolls, the ground — rather than repeating the same inputs on
+ * every route. A page that states any of them itself still wins. Its words
+ * come from the language in force (`provideSlotted`).
+ */
+declare function providePageDefaults(defaults: Partial<PageDefaults>): {
+    provide: InjectionToken<PageDefaults>;
+    useFactory: () => PageDefaults;
+};
+/** What a page renders as here, before it states anything of its own. */
+declare function injectPageDefaults(): PageDefaults;
+
+/** The custom property the scroller carries for what sticks above the footer. */
+declare const STICKY_BOTTOM_PROPERTY = "--slotted-page-sticky-bottom";
+/**
+ * The column of a screen: who scrolls, how wide the content is, where the
+ * footer stays, how much air the body has.
+ *
+ * **The header is a direct child of what scrolls.** There is no header part: a
+ * `sticky` element never leaves the box that contains it, so a wrapper exactly
+ * the header's height would pin nothing. The element carrying `slPageHeader`
+ * is projected first into the scroll part, beside the body.
+ *
+ * **The footer is projected outside the scroll part** — below the scroller
+ * under `self`, stuck to the bottom of the root under `ancestor` — which is
+ * what content projection is for. It keeps its box through its exit on
+ * `open`, so the bar slides out rather than vanishing.
+ *
+ * **The element is the consumer's.** `<main slPage>` is the main landmark and
+ * the directive adds nothing; `<div slPage>` gets `role="main"` unless
+ * `landmark="none"` says the document already has one.
+ */
+declare class SlPage {
+    /** Defaults to the provider, then `wide`. */
+    readonly width: _angular_core.InputSignal<PageWidth | undefined>;
+    /** Defaults to the provider, then `6`. */
+    readonly inset: _angular_core.InputSignal<PageInset | undefined>;
+    /** Defaults to the provider, then `ancestor`. */
+    readonly scroll: _angular_core.InputSignal<PageScroll | undefined>;
+    /** Defaults to the provider, then `sunken`. */
+    readonly ground: _angular_core.InputSignal<PageGround | undefined>;
+    /** Defaults to the provider, then `main`. */
+    readonly landmark: _angular_core.InputSignal<PageLandmark | undefined>;
+    /**
+     * Fills the height it was given: the body stops growing with its content and
+     * the container inside it stretches to what is left. With `scroll="self"`
+     * nothing then scrolls outside the body, so the body's principal scroller —
+     * not a form control, and at least half the body's height — is what
+     * collapses the header: past 16 pixels down it snaps the area shut, and back
+     * at its top it opens it again. From 600 pixels of the page's width up;
+     * below it the page scrolls as it does without `fill`.
+     */
+    readonly fill: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** The body carries `aria-busy`; what stands in for the content is each family's own placeholder. */
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /**
+     * Words laid over the catalog of the language in force: the footer's
+     * accessible name (`footer`). A static `aria-label` on the footer still wins.
+     */
+    readonly messages: _angular_core.InputSignal<PartialMessages<PageMessages> | undefined>;
+    private readonly defaults;
+    private readonly native;
+    private readonly writtenRole;
+    readonly resolvedWidth: _angular_core.Signal<PageWidth>;
+    readonly resolvedInset: _angular_core.Signal<PageInset>;
+    readonly resolvedScroll: _angular_core.Signal<PageScroll>;
+    readonly resolvedGround: _angular_core.Signal<PageGround>;
+    readonly resolvedLandmark: _angular_core.Signal<PageLandmark>;
+    /** The family's words in the language in force, with this page's `messages` laid over them. */
+    readonly t: _slotted_core_i18n.FamilyTranslator<PageMessages>;
+    /** `role="main"` only where the element is not already `main`, and only when asked. */
+    protected readonly role: _angular_core.Signal<string | null>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlPage, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlPage, "[slPage]", ["slPage"], { "width": { "alias": "width"; "required": false; "isSignal": true; }; "inset": { "alias": "inset"; "required": false; "isSignal": true; }; "scroll": { "alias": "scroll"; "required": false; "isSignal": true; }; "ground": { "alias": "ground"; "required": false; "isSignal": true; }; "landmark": { "alias": "landmark"; "required": false; "isSignal": true; }; "fill": { "alias": "fill"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; }, {}, never, ["[slPageHeader]", "*", "[slPageFooter]"], true, never>;
+}
+/**
+ * The padded column: one container at the page's width and inset, and one
+ * outline step deeper than the header — `slHeadingLevel` is a host directive,
+ * so a section written directly in the body takes `h2`.
+ */
+declare class SlPageBody {
+    protected readonly page: SlPage | null;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlPageBody, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlPageBody, "[slPageBody]", ["slPageBody"], {}, {}, never, ["*"], true, [{ directive: typeof i1.SlHeadingLevel; inputs: {}; outputs: {}; }]>;
+}
+/**
+ * The bar for the actions that finish the task. In the flow and never fixed:
+ * it takes its own height, so the last line of content scrolls up to it
+ * rather than under it. `open` keeps the element through its exit, so the bar
+ * slides out rather than vanishing; the status reaches the DOM for the
+ * stylesheet to transition on.
+ */
+declare class SlPageFooter {
+    /** Whether the bar is shown. `false` slides it out and hides it once it has left. */
+    readonly open: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    protected readonly page: SlPage | null;
+    private readonly written;
+    private readonly native;
+    protected readonly status: _angular_core.WritableSignal<PresenceStatus>;
+    /** A footer outside a page still speaks the language in force. */
+    private readonly own;
+    protected readonly label: _angular_core.Signal<string>;
+    constructor();
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlPageFooter, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlPageFooter, "[slPageFooter]", ["slPageFooter"], { "open": { "alias": "open"; "required": false; "isSignal": true; }; }, {}, never, ["*"], true, never>;
+}
+
+export { PAGE_DEFAULTS, STICKY_BOTTOM_PROPERTY, SlPage, SlPageBody, SlPageFooter, injectPageDefaults, providePageDefaults };
+export type { PageDefaults, PageGround, PageInset, PageLandmark, PageScroll, PageWidth };
+//# sourceMappingURL=slotted-angular-page.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slotted-angular-page.d.ts","sources":["../../page/src/page-defaults.ts","../../page/src/page.ts"],"mappings":";;;;;;;AAEA;AACM,KAAM,SAAS;AAErB;AACM,KAAM,SAAS;AAErB;;;;AAIG;KACS,UAAU;AAEtB;KACY,UAAU;AAEtB;KACY,YAAY;UAEP,YAAY;YACnB,UAAU;WACX,SAAS;cACN,YAAY;YACd,UAAU;WACX,SAAS;AACjB;AAUD,cAAa,aAAa,EAAA,cAAA,CAAA,YAAA;AAK1B;;;;;AAKG;AACH,iBAAgB,mBAAmB,WAAW,OAAO,CAAC,YAAY;;sBAG9C,YAAY;AAE/B;AAED;AACA,iBAAgB,kBAAkB,IAAI,YAAY;;ACrBlD;AACA,cAAa,sBAAsB;AAEnC;;;;;;;;;;;;;;;;;AAiBG;AACH,cAuBa,MAAM;;oBAEH,aAAA,CAAA,WAAA,CAAA,SAAA;;oBAEA,aAAA,CAAA,WAAA,CAAA,SAAA;;qBAEC,aAAA,CAAA,WAAA,CAAA,UAAA;;qBAEA,aAAA,CAAA,WAAA,CAAA,UAAA;;uBAEE,aAAA,CAAA,WAAA,CAAA,YAAA;AACjB;;;;;;;;AAQG;mBACU,aAAA,CAAA,wBAAA;;sBAEG,aAAA,CAAA,wBAAA;AAChB;;;AAGG;uBACc,aAAA,CAAA,WAAA,CAAA,eAAA,CAAA,YAAA;AAEjB;AACA;AACA;4BAEsB,aAAA,CAAA,MAAA,CAAA,SAAA;4BACA,aAAA,CAAA,MAAA,CAAA,SAAA;6BACC,aAAA,CAAA,MAAA,CAAA,UAAA;6BACA,aAAA,CAAA,MAAA,CAAA,UAAA;+BACE,aAAA,CAAA,MAAA,CAAA,YAAA;;gBAEf,kBAAA,CAAA,gBAAA,CAAA,YAAA;;AAGV,6BAAuB,aAAA,CAAA,MAAA;;oDA1CZ,MAAM;sDAAN,MAAM;AAqElB;AAED;;;;AAIG;AACH,cAgBa,UAAU;AACrB,6BAAuB,MAAA;oDADZ,UAAU;sDAAV,UAAU,mFAAA,EAAA,CAAA,cAAA;AAEtB;AAED;;;;;;AAMG;AACH,cAiBa,YAAY;;mBAEV,aAAA,CAAA,wBAAA;AAEb,6BAAuB,MAAA;AACvB;AACA;AACA,+BAAyB,aAAA,CAAA,cAAA,CAAA,cAAA;;AAEzB;AAEA,8BAAwB,aAAA,CAAA,MAAA;;oDAXb,YAAY;sDAAZ,YAAY;AAyBxB;;","names":[]}

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

@@ -0,0 +1,213 @@
+import * as _slotted_core_pagination from '@slotted/core/pagination';
+import * as _slotted_core_i18n from '@slotted/core/i18n';
+import { PartialMessages, PaginationMessages } from '@slotted/core/i18n';
+import * as _angular_core from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { ChangeRequest } from '@slotted/core/state';
+
+type PaginationPageReason = 'pointer' | 'keyboard' | 'programmatic';
+type PaginationPageSizeReason = 'select' | 'programmatic';
+type PaginationLive = 'polite' | 'off';
+declare const PAGINATION_DEFAULT_PAGE_SIZE = 20;
+declare const PAGINATION_DEFAULT_PAGE_SIZE_OPTIONS: number[];
+interface PaginationDefaults {
+    boundaryCount?: number;
+    defaultPageSize?: number;
+    live?: PaginationLive;
+    pageSizeOptions?: readonly number[];
+    siblingCount?: number;
+}
+declare const PAGINATION_DEFAULTS_TOKEN: InjectionToken<PaginationDefaults>;
+/**
+ * An application decides once how wide its rows of pages are, how many items a
+ * page holds, and whether a page change is announced. A paginator that states
+ * any of those itself still wins: an explicit input is never overridden by the
+ * token. Its words come from the language in force (`provideSlotted`).
+ */
+declare function providePaginationDefaults(defaults: PaginationDefaults): {
+    provide: InjectionToken<PaginationDefaults>;
+    useValue: PaginationDefaults;
+};
+declare function injectPaginationDefaults(): PaginationDefaults;
+
+/**
+ * Moving between pages of a collection the consumer owns.
+ *
+ * **It never fetches and never slices.** The collection is the consumer's, and
+ * a family that held a copy of it would hold a stale one. `count` and
+ * `pageSize` are all the arithmetic needs, and `@slotted/core/pagination` does
+ * that arithmetic once for both bindings.
+ *
+ * **It never invents a total.** A collection whose total the server does not
+ * know states no `count`; the row of numbers is then not drawn at all, and the
+ * two triggers plus a sentence are the whole paginator.
+ *
+ * **The page can move by itself, twice.** A collection that shrinks under a
+ * reader leaves them past the end, and a change of page size moves the window
+ * they are looking through. Both emit `programmatic`, so a consumer holding
+ * the value follows rather than guessing.
+ */
+declare class SlPagination {
+    /**
+     * Present means controlled, for the life of the component. Both values take
+     * `undefined` as their unset state rather than a number, because a paginator
+     * that read a default as the consumer's answer would never own its own page.
+     */
+    readonly pageValue: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    readonly defaultPage: _angular_core.InputSignalWithTransform<number, unknown>;
+    readonly pageSizeValue: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    readonly defaultPageSize: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    readonly count: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    readonly siblingCount: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    readonly boundaryCount: _angular_core.InputSignalWithTransform<number | undefined, string | number | undefined>;
+    readonly pageSizeOptions: _angular_core.InputSignal<readonly number[] | undefined>;
+    /**
+     * Words laid over the catalog of the language in force, key by key: the
+     * landmark's name (`label`), the controls, and the sentences.
+     */
+    readonly messages: _angular_core.InputSignal<PartialMessages<PaginationMessages> | undefined>;
+    readonly live: _angular_core.InputSignal<PaginationLive | undefined>;
+    readonly disabled: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    readonly loading: _angular_core.InputSignalWithTransform<boolean, unknown>;
+    /** Turns every page and every trigger into an anchor with a destination. */
+    readonly itemHref: _angular_core.InputSignal<((page: number) => string) | undefined>;
+    /**
+     * Emitted before either value moves, carrying what it replaces, the reason
+     * and the event. Neither is the second half of a two-way binding: one slot
+     * can carry none of those.
+     */
+    readonly pageChange: _angular_core.OutputEmitterRef<ChangeRequest<number>>;
+    readonly pageSizeChange: _angular_core.OutputEmitterRef<ChangeRequest<number>>;
+    private readonly ownPage;
+    private readonly ownSize;
+    readonly page: _angular_core.Signal<number>;
+    readonly pageSize: _angular_core.Signal<number>;
+    private readonly defaults;
+    private readonly ownLabel;
+    /** The family's words in the language in force, with this paginator's `messages` laid over them. */
+    readonly t: _slotted_core_i18n.FamilyTranslator<PaginationMessages>;
+    readonly accessibleLabel: _angular_core.Signal<string>;
+    readonly liveValue: _angular_core.Signal<PaginationLive>;
+    readonly sizeOptions: _angular_core.Signal<readonly number[]>;
+    readonly pages: _angular_core.Signal<number>;
+    readonly currentPage: _angular_core.Signal<number>;
+    readonly items: _angular_core.Signal<_slotted_core_pagination.PageItem[]>;
+    readonly range: _angular_core.Signal<{
+        start: number;
+        end: number;
+    }>;
+    readonly inert: _angular_core.Signal<boolean>;
+    readonly canGoPrevious: _angular_core.Signal<boolean>;
+    readonly canGoNext: _angular_core.Signal<boolean>;
+    constructor();
+    goToPage(next: number, reason?: PaginationPageReason, source?: Event): void;
+    reset(source?: Event): void;
+    next(reason?: PaginationPageReason, source?: Event): void;
+    previous(reason?: PaginationPageReason, source?: Event): void;
+    /**
+     * Changing how many rows a page holds moves the reader, and where they land
+     * is a decision. Clamping leaves someone on page seven at the end of the
+     * collection; resetting to page one throws away where they were. Angular
+     * Material takes the third answer and so does this: the first item of the
+     * current page stays visible.
+     */
+    setPageSize(next: number, reason?: PaginationPageSizeReason, source?: Event): void;
+    private move;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlPagination, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlPagination, "nav[slPagination]", ["slPagination"], { "pageValue": { "alias": "page"; "required": false; "isSignal": true; }; "defaultPage": { "alias": "defaultPage"; "required": false; "isSignal": true; }; "pageSizeValue": { "alias": "pageSize"; "required": false; "isSignal": true; }; "defaultPageSize": { "alias": "defaultPageSize"; "required": false; "isSignal": true; }; "count": { "alias": "count"; "required": false; "isSignal": true; }; "siblingCount": { "alias": "siblingCount"; "required": false; "isSignal": true; }; "boundaryCount": { "alias": "boundaryCount"; "required": false; "isSignal": true; }; "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; "isSignal": true; }; "messages": { "alias": "messages"; "required": false; "isSignal": true; }; "live": { "alias": "live"; "required": false; "isSignal": true; }; "disabled": { "alias": "disabled"; "required": false; "isSignal": true; }; "loading": { "alias": "loading"; "required": false; "isSignal": true; }; "itemHref": { "alias": "itemHref"; "required": false; "isSignal": true; }; }, { "pageChange": "pageChange"; "pageSizeChange": "pageSizeChange"; }, never, ["*"], true, never>;
+}
+/**
+ * A control that moves the page, on the consumer's own `button` or `a`.
+ *
+ * A button that cannot move takes the native `disabled`. An anchor cannot: it
+ * has no such attribute, and one that kept its `href` would still navigate on
+ * a middle click — so an unavailable link loses its destination and says
+ * `aria-disabled`, the shape the `link` family already ships.
+ */
+declare abstract class SlPaginationTrigger {
+    protected readonly pagination: SlPagination;
+    private readonly ownLabel;
+    abstract readonly part: 'first' | 'previous' | 'next' | 'last';
+    protected abstract target(): number;
+    protected abstract usable(): boolean;
+    protected abstract defaultLabel(): string;
+    /** A button says it cannot move with the native `disabled`; only an anchor needs `aria-disabled`. */
+    readonly anchor: boolean;
+    readonly accessibleLabel: _angular_core.Signal<string>;
+    readonly unavailable: _angular_core.Signal<boolean>;
+    readonly href: _angular_core.Signal<string | null>;
+    activate(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlPaginationTrigger, never>;
+    static ɵdir: _angular_core.ɵɵDirectiveDeclaration<SlPaginationTrigger, never, never, {}, {}, never, never, true, never>;
+}
+declare class SlPaginationFirst extends SlPaginationTrigger {
+    readonly part: "first";
+    protected target: () => number;
+    protected usable: () => boolean;
+    protected defaultLabel: () => string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlPaginationFirst, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlPaginationFirst, "[slPaginationFirst]", ["slPaginationFirst"], {}, {}, never, ["*"], true, never>;
+}
+declare class SlPaginationPrevious extends SlPaginationTrigger {
+    readonly part: "previous";
+    protected target: () => number;
+    protected usable: () => boolean;
+    protected defaultLabel: () => string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlPaginationPrevious, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlPaginationPrevious, "[slPaginationPrevious]", ["slPaginationPrevious"], {}, {}, never, ["*"], true, never>;
+}
+declare class SlPaginationNext extends SlPaginationTrigger {
+    readonly part: "next";
+    protected target: () => number;
+    protected usable: () => boolean;
+    protected defaultLabel: () => string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlPaginationNext, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlPaginationNext, "[slPaginationNext]", ["slPaginationNext"], {}, {}, never, ["*"], true, never>;
+}
+declare class SlPaginationLast extends SlPaginationTrigger {
+    readonly part: "last";
+    protected target: () => number;
+    protected usable: () => boolean;
+    protected defaultLabel: () => string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlPaginationLast, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlPaginationLast, "[slPaginationLast]", ["slPaginationLast"], {}, {}, never, ["*"], true, never>;
+}
+/**
+ * The row of page numbers, and the sentence that replaces it below the
+ * family's own breakpoint. Both are rendered and exactly one is displayed, so
+ * neither is announced twice. A paginator over a collection whose total the
+ * server does not know renders nothing here.
+ */
+declare class SlPaginationItems {
+    readonly pagination: SlPagination;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlPaginationItems, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlPaginationItems, "sl-pagination-items", ["slPaginationItems"], {}, {}, never, never, true, never>;
+}
+/**
+ * "21–40 of 482", and the polite live region that announces a page change. One
+ * region announcing one sentence is the whole of the announcement.
+ */
+declare class SlPaginationStatus {
+    readonly pagination: SlPagination;
+    readonly text: _angular_core.Signal<string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlPaginationStatus, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlPaginationStatus, "p[slPaginationStatus]", ["slPaginationStatus"], {}, {}, never, ["*"], true, never>;
+}
+/**
+ * How many items a page holds.
+ *
+ * A native `select`, wrapped by its own label. `select` in a later wave owns
+ * the styled listbox; a paginator that could not change its page size until
+ * then is not one a table can use. Wrapping rather than pointing gives the
+ * control its accessible name from the platform, with no generated id.
+ */
+declare class SlPaginationPageSize {
+    readonly pagination: SlPagination;
+    onChange(event: Event): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SlPaginationPageSize, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SlPaginationPageSize, "sl-pagination-page-size", ["slPaginationPageSize"], {}, {}, never, ["*"], true, never>;
+}
+
+export { PAGINATION_DEFAULTS_TOKEN, PAGINATION_DEFAULT_PAGE_SIZE, PAGINATION_DEFAULT_PAGE_SIZE_OPTIONS, SlPagination, SlPaginationFirst, SlPaginationItems, SlPaginationLast, SlPaginationNext, SlPaginationPageSize, SlPaginationPrevious, SlPaginationStatus, injectPaginationDefaults, providePaginationDefaults };
+export type { PaginationDefaults, PaginationLive, PaginationPageReason, PaginationPageSizeReason };
+//# sourceMappingURL=slotted-angular-pagination.d.ts.map

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

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