antd-crud-table 0.5.0 → 0.7.0

package/dist/CrudTable.d.ts

@@ -1,34 +1,101 @@
 import { ProColumns } from '@ant-design/pro-components';
-import { UseCrudTableConfig, CrudTableActions } from './hooks/useCrudTable';
+import { FormRule } from 'antd';
+import { CrudTableActions, UseCrudTableOptions } from './hooks/useCrudTable';
 import { FieldType } from './fields/registry';
-type DataType = Record<string, any>;
-interface CrudColumn<T extends DataType> extends ProColumns<T> {
+import { EnumOption } from './fields/types';
+import { PartialCrudTableLocale } from './locale/types';
+/**
+ * A column bound to one property of `T`.
+ *
+ * `K` ties `dataIndex` to a real key, so `customRender` and `transform`
+ * receive that property's type rather than a widened one.
+ */
+export interface CrudColumnFor<T, K extends keyof T> extends Omit<ProColumns<T>, 'dataIndex' | 'title' | 'render'> {
+    /** The record property this column reads. */
+    dataIndex: K;
+    /** Also used as the form label, so a plain string rather than a ReactNode. */
+    title: string;
+    /** Which registry entry renders and edits this column. Defaults to `string`. */
     fieldType?: FieldType;
-    enumOptions?: Record<string, {
-        text: string;
-        [key: string]: any;
-    }>;
-    customRender?: (value: any, record: T) => React.ReactNode;
+    /** Selectable values, for `enum` columns. */
+    enumOptions?: Record<string, EnumOption>;
+    /** Cell renderer for `custom` columns, receiving this property's type. */
+    customRender?: (value: T[K], record: T) => React.ReactNode;
+    /** How this column behaves in the create/edit form. */
     formConfig?: {
+        /** Adds a required rule, unless `rules` is given instead. */
         required?: boolean;
+        /** Replaces the registry's control entirely. */
         component?: React.ReactNode;
-        transform?: (value: any) => any;
-        rules?: any[];
+        /** Applied to the submitted value before it reaches the data source. */
+        transform?: (value: T[K]) => T[K];
+        /** antd validation rules. Replaces `required` when both are present. */
+        rules?: FormRule[];
     };
+    /** Editable in the create/edit form. Defaults to true. */
     fieldEditable?: boolean;
+    /** Exposed in the search form. Defaults to true. */
     searchable?: boolean;
 }
-interface CrudTableConfig<T extends DataType> {
-    columns: CrudColumn<T>[];
-    rowKey: keyof T;
+/**
+ * A column for any one key of `T` - the type an array of columns holds.
+ *
+ * Distributing over `keyof T` is what keeps each column's callbacks bound to
+ * its own property type. A single `CrudColumnFor<T, keyof T>` would widen
+ * `customRender` and `transform` to accept a union of every property type,
+ * losing exactly the precision this exists for.
+ */
+export type CrudColumn<T> = {
+    [K in keyof T]-?: CrudColumnFor<T, K>;
+}[keyof T];
+/** Everything needed to render a {@link CrudTable}. */
+export interface CrudTableConfig<T extends object, K extends keyof T> {
+    /** Column definitions, each bound to a property of `T`. */
+    columns: readonly CrudColumn<T>[];
+    /** The property holding each record's identity. */
+    rowKey: K;
+    /** Table header, also used to name exported files. */
     title: string;
+    /** Rows per page. Defaults to 10. */
     defaultPageSize?: number;
-    hookConfig: UseCrudTableConfig<T>;
+    /** Selects and configures the data strategy. */
+    hookConfig: UseCrudTableOptions<T, K>;
+    /** Show row selection and the bulk delete control. Defaults to false. */
     enableBulkOperations?: boolean;
+    /** Show ProTable's column visibility and density controls. Defaults to true. */
     enableColumnSettings?: boolean;
+    /** Show the export entries in the toolbar menu. Defaults to true. */
     enableExport?: boolean;
-    customActions?: (record: T, actions: CrudTableActions<T>) => React.ReactNode[];
+    /**
+     * Whether export covers the whole filtered result set or just the rows on
+     * screen. Defaults to `'all'`, falling back to `'page'` when the data source
+     * cannot list without pagination.
+     */
+    exportScope?: 'all' | 'page';
+    /** Extra per-row controls, appended after Edit and Delete. */
+    customActions?: (record: T, actions: CrudTableActions<T, K>) => React.ReactNode[];
+    /**
+     * Overrides for the library's own wording.
+     *
+     * antd and ProTable chrome follow the surrounding `ConfigProvider`; this is
+     * for the strings the library itself produces. Anything omitted falls back
+     * to English.
+     */
+    locale?: PartialCrudTableLocale;
 }
-declare const CrudTable: <T extends DataType>(config: CrudTableConfig<T>) => import("react").JSX.Element;
+/**
+ * A paginated, searchable table with a create/edit form and CRUD wired through
+ * a {@link CrudDataSource}.
+ *
+ * @example
+ * ```tsx
+ * <CrudTable<User, 'id'>
+ *   title="Users"
+ *   rowKey="id"
+ *   columns={[{ dataIndex: 'name', title: 'Name', fieldType: 'string' }]}
+ *   hookConfig={{ staticData: users }}
+ * />
+ * ```
+ */
+declare const CrudTable: <T extends object, K extends keyof T>(config: CrudTableConfig<T, K>) => import("react").JSX.Element;
 export default CrudTable;
-export type { CrudTableConfig, CrudColumn, DataType };

package/dist/CrudTable.js

@@ -1,3 +1,3 @@
-import { t as e } from "./CrudTable-DUfRGJW2.js";
+import { t as e } from "./CrudTable-Btf58zof.js";
 import "./exportData.js";
 export { e as default };

package/dist/CrudTableLazy.cjs

@@ -1 +1 @@
-require(`./CrudTable-TTRqkEoZ.cjs`);let e=require(`react`),t=require(`react/jsx-runtime`);var n=(0,e.lazy)(()=>Promise.resolve().then(()=>require(`./CrudTable.cjs`))),r=r=>(0,t.jsx)(e.Suspense,{fallback:(0,t.jsx)(`div`,{style:{textAlign:`center`,padding:`2rem`},children:`Loading CRUD table…`}),children:(0,t.jsx)(n,{...r})});module.exports=r;
+Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:`Module`}});const e=require("./en_US-D3Kl6g3n.cjs");let t=require("react"),n=require("react/jsx-runtime");var r=(0,t.lazy)(()=>Promise.resolve().then(()=>require("./CrudTable.cjs"))),i=i=>(0,n.jsx)(t.Suspense,{fallback:(0,n.jsx)(`div`,{style:{textAlign:`center`,padding:`2rem`},children:i.locale?.loading??e.t.loading}),children:(0,n.jsx)(r,{...i})});exports.default=i;

package/dist/CrudTableLazy.d.ts

@@ -1,4 +1,5 @@
-import { CrudTableConfig, DataType } from './CrudTable';
-declare const CrudTableLazy: <T extends DataType>(props: CrudTableConfig<T>) => import("react").JSX.Element;
+import { CrudTableConfig } from './CrudTable';
+/** Code-split `CrudTable`, keeping the same typed configuration. */
+declare const CrudTableLazy: <T extends object, K extends keyof T>(props: CrudTableConfig<T, K>) => import("react").JSX.Element;
 export default CrudTableLazy;
-export type { CrudTableConfig, DataType };
+export type { CrudTableConfig };

package/dist/CrudTableLazy.js

@@ -1,15 +1,16 @@
-import { Suspense as e, lazy as t } from "react";
-import { jsx as n } from "react/jsx-runtime";
+import { t as e } from "./en_US-DGCMDOdX.js";
+import { Suspense as t, lazy as n } from "react";
+import { jsx as r } from "react/jsx-runtime";
 //#region lib/CrudTableLazy.tsx
-var r = t(() => import("./CrudTable.js")), i = (t) => /* @__PURE__ */ n(e, {
-	fallback: /* @__PURE__ */ n("div", {
+var i = n(() => import("./CrudTable.js")), a = (n) => /* @__PURE__ */ r(t, {
+	fallback: /* @__PURE__ */ r("div", {
 		style: {
 			textAlign: "center",
 			padding: "2rem"
 		},
-		children: "Loading CRUD table…"
+		children: n.locale?.loading ?? e.loading
 	}),
-	children: /* @__PURE__ */ n(r, { ...t })
+	children: /* @__PURE__ */ r(i, { ...n })
 });
 //#endregion
-export { i as default };
+export { a as default };

package/dist/core/CustomDataSource.d.ts

@@ -0,0 +1,35 @@
+import { CrudDataSource, CrudDraft, CrudPage, CrudQuery } from './types';
+/**
+ * The operations a consumer may supply. Every entry is optional so a
+ * read-only table need not invent write handlers it will never call.
+ */
+export type CrudOperations<T, K extends keyof T> = Partial<CrudDataSource<T, K>>;
+/**
+ * Raised when the table attempts an operation the consumer did not supply.
+ *
+ * Names the missing operation so the message points at the fix rather than
+ * surfacing as `undefined is not a function`.
+ */
+export declare class UnsupportedOperationError extends Error {
+    /** The operation that was attempted but not supplied. */
+    readonly operation: string;
+    constructor(operation: string);
+}
+/**
+ * Adapts a bag of consumer-supplied functions to the full interface.
+ *
+ * Exists so the rest of the library can depend on `CrudDataSource` without
+ * null-checking each method at every call site; absent operations fail here
+ * with a message naming what is missing.
+ */
+export declare class CustomDataSource<T extends object, K extends keyof T> implements CrudDataSource<T, K> {
+    private readonly operations;
+    constructor(operations: CrudOperations<T, K>);
+    /** Whether an operation was supplied, so callers can hide unavailable UI. */
+    supports(operation: keyof CrudDataSource<T, K>): boolean;
+    list(query: CrudQuery<T>): Promise<CrudPage<T>>;
+    listAll(query: Omit<CrudQuery<T>, 'page' | 'pageSize'>): Promise<readonly T[]>;
+    create(draft: CrudDraft<T>): Promise<T>;
+    update(id: T[K], draft: CrudDraft<T>): Promise<T>;
+    remove(id: T[K]): Promise<void>;
+}

package/dist/core/InMemoryDataSource.d.ts

@@ -0,0 +1,30 @@
+import { CrudDataSource, CrudDraft, CrudPage, CrudQuery, IdGenerator } from './types';
+/**
+ * Shared behaviour for every source backed by a local collection.
+ *
+ * Subclasses supply only where the records live, via `read`/`write`. All
+ * querying, identity assignment and mutation semantics are defined once here
+ * so the static and localStorage strategies cannot drift apart.
+ */
+export declare abstract class InMemoryDataSource<T extends object, K extends keyof T> implements CrudDataSource<T, K> {
+    /** The property holding each record's identity. */
+    protected readonly key: K;
+    /** Assigns the identity for newly created records. */
+    protected readonly generateId: IdGenerator<T, K>;
+    protected constructor(key: K, generateId?: IdGenerator<T, K>);
+    /** Current contents of the backing collection. */
+    protected abstract read(): readonly T[];
+    /** Replace the backing collection. */
+    protected abstract write(records: readonly T[]): void;
+    /**
+     * Hook for values a subclass stamps onto every write, such as timestamps.
+     * Returns nothing extra by default.
+     */
+    protected decorate(_record: CrudDraft<T>, _operation: 'create' | 'update'): CrudDraft<T>;
+    private indexOf;
+    list(query: CrudQuery<T>): Promise<CrudPage<T>>;
+    listAll(query: Omit<CrudQuery<T>, 'page' | 'pageSize'>): Promise<readonly T[]>;
+    create(draft: CrudDraft<T>): Promise<T>;
+    update(id: T[K], draft: CrudDraft<T>): Promise<T>;
+    remove(id: T[K]): Promise<void>;
+}

package/dist/core/LocalStorageDataSource.d.ts

@@ -0,0 +1,30 @@
+import { InMemoryDataSource } from './InMemoryDataSource';
+import { CrudDraft, IdGenerator } from './types';
+/** Fields stamped onto records by the localStorage strategy. */
+export interface Timestamped {
+    /** ISO timestamp set once, when the record is created. */
+    createdAt?: string;
+    /** ISO timestamp refreshed on every write. */
+    updatedAt?: string;
+}
+/**
+ * A source persisting to `localStorage` under a fixed key.
+ *
+ * Reads go through storage on every call rather than through a cache, so a
+ * second tab writing the same key is picked up on the next query instead of
+ * being shadowed by stale in-memory state.
+ *
+ * Storage is best-effort: a read that fails or returns malformed JSON falls
+ * back to the seed rather than throwing, since an unreadable cache should not
+ * take the table down. Writes that fail (quota, private mode) *do* throw -
+ * silently dropping a write the user believes succeeded is worse than an error.
+ */
+export declare class LocalStorageDataSource<T extends object, K extends keyof T> extends InMemoryDataSource<T, K> {
+    private readonly storageKey;
+    private readonly seed;
+    constructor(storageKey: string, key: K, seed?: readonly T[], generateId?: IdGenerator<T, K>);
+    protected read(): readonly T[];
+    protected write(records: readonly T[]): void;
+    /** Stamps creation and modification times onto every write. */
+    protected decorate(_draft: CrudDraft<T>, operation: 'create' | 'update'): CrudDraft<T>;
+}

package/dist/core/RestDataSource.d.ts

@@ -0,0 +1,120 @@
+import { CrudDataSource, CrudDraft, CrudPage, CrudQuery, CrudSort } from './types';
+/** Paths appended to `baseUrl` for each operation. */
+export interface RestEndpoints {
+    /** Path listing records. */
+    list: string;
+    /** Path accepting a new record. */
+    create: string;
+    /** Path for updating one record; the id is appended by `buildRecordPath`. */
+    update: string;
+    /** Path for deleting one record; the id is appended by `buildRecordPath`. */
+    remove: string;
+}
+/** Query-string parameter names, for APIs that do not speak ProTable's vocabulary. */
+export interface RestParamNames {
+    /** Parameter carrying the 1-based page number. Defaults to `current`. */
+    page: string;
+    /** Parameter carrying the page size. Defaults to `pageSize`. */
+    pageSize: string;
+    /** Parameter carrying the field to sort by. Defaults to `sortBy`. */
+    sortBy: string;
+    /** Parameter carrying the sort direction. Defaults to `sortOrder`. */
+    sortOrder: string;
+}
+/** HTTP verbs used per mutating operation. */
+export interface RestMethods {
+    /** Verb for creating a record. Defaults to `POST`. */
+    create: 'POST' | 'PUT';
+    /** Verb for updating a record. Defaults to `PUT`. */
+    update: 'PUT' | 'PATCH' | 'POST';
+    /** Verb for deleting a record. Defaults to `DELETE`. */
+    remove: 'DELETE' | 'POST';
+}
+/** Everything needed to point a {@link RestDataSource} at an API. */
+export interface RestDataSourceOptions<T> {
+    /** Prefixed to every request path, exactly once. */
+    baseUrl?: string;
+    /** Overrides for the per-operation paths. */
+    endpoints?: Partial<RestEndpoints>;
+    /** Overrides for query-parameter names, for APIs with another vocabulary. */
+    paramNames?: Partial<RestParamNames>;
+    /** Overrides for the HTTP verb used by each mutating operation. */
+    methods?: Partial<RestMethods>;
+    /** Sent with every request, merged over the default content type. */
+    headers?: Readonly<Record<string, string>>;
+    /** Maps a draft onto the request body. Defaults to sending the draft as-is. */
+    serializeRequest?: (draft: CrudDraft<T>) => unknown;
+    /** Maps a list response onto a page. Required when the API wraps its payload. */
+    parseResponse?: (payload: unknown) => CrudPage<T>;
+    /** Injected for testing; defaults to the global `fetch`. */
+    fetchImpl?: typeof fetch;
+}
+/**
+ * Raised when the server answers with a non-2xx status.
+ *
+ * Carries the status and the raw body so consumers can branch on a 409 or
+ * surface a validation payload, rather than receiving a flattened string.
+ */
+export declare class RestError extends Error {
+    /** The HTTP status the server responded with. */
+    readonly status: number;
+    /** The raw response body, for reading a validation payload. */
+    readonly body: string;
+    constructor(status: number, body: string, url: string);
+}
+/**
+ * A source over a REST API.
+ *
+ * URL and payload construction live in `protected` methods rather than inline,
+ * so an API that does not match the default dialect is a small subclass
+ * instead of a full reimplementation of the strategy.
+ */
+export declare class RestDataSource<T extends object, K extends keyof T> implements CrudDataSource<T, K> {
+    /** Prefixed to every request path, exactly once. */
+    protected readonly baseUrl: string;
+    /** Resolved per-operation paths. */
+    protected readonly endpoints: RestEndpoints;
+    /** Resolved query-parameter names. */
+    protected readonly paramNames: RestParamNames;
+    /** Resolved HTTP verbs. */
+    protected readonly methods: RestMethods;
+    /** Headers sent with every request. */
+    protected readonly headers: Readonly<Record<string, string>>;
+    /** Maps a draft onto the request body. */
+    protected readonly serializeRequest: (draft: CrudDraft<T>) => unknown;
+    /** Maps a list payload onto a page, when the API wraps its results. */
+    protected readonly parseResponse?: (payload: unknown) => CrudPage<T>;
+    private readonly fetchImpl;
+    constructor(options?: RestDataSourceOptions<T>);
+    /**
+     * Encode sort instructions as query parameters.
+     *
+     * Only the first instruction is sent: `sortBy`/`sortOrder` is a single-sort
+     * shape, and inventing a multi-sort encoding would guess at a convention the
+     * server may not share. Override to support one.
+     */
+    protected serializeSort(sort: readonly CrudSort<T>[] | undefined, params: URLSearchParams): void;
+    /** Build the list URL, including pagination, sort and filters. */
+    protected buildListUrl(query: CrudQuery<T>): string;
+    /** Path addressing a single record. Override for `?id=` style APIs. */
+    protected buildRecordPath(endpoint: string, id: T[K]): string;
+    /**
+     * Interpret a list payload.
+     *
+     * Without a `parseResponse`, accepts either a bare array or the
+     * `{ data, total }` shape the previous implementation assumed.
+     */
+    protected toPage(payload: unknown): CrudPage<T>;
+    /**
+     * Single point where `baseUrl`, headers and error handling are applied.
+     *
+     * Every request goes through here so `baseUrl` is prefixed exactly once -
+     * building a full URL earlier and prefixing again is how it ended up
+     * duplicated for relative bases.
+     */
+    protected request(path: string, init?: RequestInit): Promise<unknown>;
+    list(query: CrudQuery<T>): Promise<CrudPage<T>>;
+    create(draft: CrudDraft<T>): Promise<T>;
+    update(id: T[K], draft: CrudDraft<T>): Promise<T>;
+    remove(id: T[K]): Promise<void>;
+}

package/dist/core/StaticDataSource.d.ts

@@ -0,0 +1,20 @@
+import { InMemoryDataSource } from './InMemoryDataSource';
+import { IdGenerator } from './types';
+/**
+ * A source over an in-process array, for fixtures, demos and tests.
+ *
+ * The collection is instance state, seeded once from the array passed to the
+ * constructor and never re-read from it. That is the fix for the old
+ * closure-factory behaviour: identity of the caller's array no longer
+ * controls the dataset's lifetime, so passing an inline literal from a
+ * component no longer discards every created and edited row when the parent
+ * happens to re-render.
+ *
+ * The seed array is copied, so mutations never write back to the caller's data.
+ */
+export declare class StaticDataSource<T extends object, K extends keyof T> extends InMemoryDataSource<T, K> {
+    private records;
+    constructor(seed: readonly T[], key: K, generateId?: IdGenerator<T, K>);
+    protected read(): readonly T[];
+    protected write(records: readonly T[]): void;
+}

package/dist/core/identity.d.ts

@@ -0,0 +1,28 @@
+import { IdGenerator } from './types';
+/**
+ * Fresh RFC-4122 v4 identifier.
+ *
+ * `crypto.randomUUID` needs a secure context and is absent in some test
+ * environments, so this falls back to `getRandomValues` and, failing that,
+ * to `Math.random`. The fallback is for uniqueness within a client-side
+ * dataset, not for anything security-bearing.
+ */
+declare const randomUuid: () => string;
+/**
+ * Default identity policy for in-memory sources.
+ *
+ * Chooses from the *runtime type of the existing keys* rather than coercing
+ * them to numbers. Coercion was the old bug: `Number('a3f9-...')` is `NaN`,
+ * `|| 0` collapsed it to `0`, and every created row came back as `1` -
+ * duplicate keys, and `update`/`remove` then resolving to the wrong record.
+ *
+ * - numeric keys      -> highest + 1
+ * - digit-like strings -> highest + 1, kept as a string
+ * - any other string  -> a fresh UUID
+ * - empty dataset     -> `1`, matching the previous behaviour for the common case
+ *
+ * Mixed or non-primitive key types cannot be continued safely, so those throw
+ * rather than silently colliding. Pass an explicit generator for those.
+ */
+export declare const defaultIdGenerator: <T, K extends keyof T>(key: K) => IdGenerator<T, K>;
+export { randomUuid };

package/dist/core/inMemoryQuery.d.ts

@@ -0,0 +1,26 @@
+import { CrudFilters, CrudPage, CrudQuery, CrudSort } from './types';
+/**
+ * Apply filters to an in-memory collection.
+ *
+ * Filters whose value is undefined, null or the empty string are ignored, so
+ * a cleared search box does not exclude everything. A record missing the
+ * filtered field never matches.
+ */
+export declare const filterRecords: <T>(records: readonly T[], filters?: CrudFilters<T>) => readonly T[];
+/**
+ * Apply an ordered list of sort instructions.
+ *
+ * Earlier entries take precedence; later ones break ties. Missing values sort
+ * last in both directions - they carry no ordering information, so surfacing
+ * them ahead of real data in one direction would be arbitrary.
+ */
+export declare const sortRecords: <T>(records: readonly T[], sort?: readonly CrudSort<T>[]) => readonly T[];
+/** Take the requested page. Pages are 1-based; out-of-range pages yield an empty slice. */
+export declare const paginateRecords: <T>(records: readonly T[], page: number, pageSize: number) => readonly T[];
+/**
+ * The shared filter-then-sort-then-paginate pipeline.
+ *
+ * Every strategy backed by a local collection routes through this, so their
+ * querying behaviour cannot drift apart.
+ */
+export declare const queryRecords: <T>(records: readonly T[], query: CrudQuery<T>) => CrudPage<T>;

package/dist/core/index.d.ts

@@ -0,0 +1,11 @@
+export type { CrudDataSource, CrudDraft, CrudFilters, CrudFilterValue, CrudPage, CrudQuery, CrudSort, IdGenerator, SortDirection, } from './types';
+export { defaultIdGenerator, randomUuid } from './identity';
+export { filterRecords, paginateRecords, queryRecords, sortRecords } from './inMemoryQuery';
+export { InMemoryDataSource } from './InMemoryDataSource';
+export { StaticDataSource } from './StaticDataSource';
+export { LocalStorageDataSource } from './LocalStorageDataSource';
+export type { Timestamped } from './LocalStorageDataSource';
+export { RestDataSource, RestError } from './RestDataSource';
+export type { RestDataSourceOptions, RestEndpoints, RestMethods, RestParamNames, } from './RestDataSource';
+export { CustomDataSource, UnsupportedOperationError } from './CustomDataSource';
+export type { CrudOperations } from './CustomDataSource';

package/dist/core/types.d.ts

@@ -0,0 +1,86 @@
+/**
+ * The core data-access contract every CRUD strategy implements.
+ *
+ * `T` is the record shape and `K` the property holding its identity, so
+ * `T[K]` is the precise type of an id throughout - never `any`, never a
+ * widened `string | number`.
+ */
+/** Sort direction, matching the vocabulary ProTable reports. */
+export type SortDirection = 'ascend' | 'descend';
+/** One sort instruction. Queries carry an ordered list to support multi-sort. */
+export interface CrudSort<T> {
+    /** The property to order by. */
+    readonly field: keyof T;
+    /** Ascending or descending. */
+    readonly direction: SortDirection;
+}
+/**
+ * A value a column can be filtered by.
+ *
+ * Deliberately narrow: filters arrive from form inputs and query strings, so
+ * this is the complete set of things a user can actually express. Anything
+ * richer belongs in a custom data source.
+ */
+export type CrudFilterValue = string | number | boolean;
+/** Field-keyed filters. Absent keys are unfiltered. */
+export type CrudFilters<T> = {
+    readonly [P in keyof T]?: CrudFilterValue;
+};
+/** A complete read request: which slice, in what order, matching what. */
+export interface CrudQuery<T> {
+    /** 1-based, matching ProTable's `current`. */
+    readonly page: number;
+    /** Rows per page. */
+    readonly pageSize: number;
+    /** Ordered sort instructions; earlier entries take precedence. */
+    readonly sort?: readonly CrudSort<T>[];
+    /** Field-keyed filters. Absent keys are unfiltered. */
+    readonly filters?: CrudFilters<T>;
+}
+/** One page of results plus the total matching the filters (not the page size). */
+export interface CrudPage<T> {
+    /** The records on this page. */
+    readonly items: readonly T[];
+    /** Records matching the filters, across all pages. */
+    readonly total: number;
+}
+/**
+ * A record being written.
+ *
+ * Partial because the identity is assigned by the source on create, and an
+ * update legitimately touches a subset of fields.
+ */
+export type CrudDraft<T> = Partial<T>;
+/**
+ * Produces the identity for a newly created record.
+ *
+ * Receives the existing records so a strategy can derive the next value
+ * (max + 1, a fresh UUID, a sequence). Supplying one replaces the built-in
+ * policy entirely.
+ */
+export type IdGenerator<T, K extends keyof T> = (existing: readonly T[]) => T[K];
+/**
+ * The interface every strategy implements: static fixtures, REST,
+ * localStorage, or a consumer's own.
+ *
+ * Implementations own their storage and lifetime. They are plain objects -
+ * no React involvement - so each is unit-testable without a renderer.
+ */
+export interface CrudDataSource<T, K extends keyof T> {
+    /** Read one page. Implementations must apply filters before paginating. */
+    list(query: CrudQuery<T>): Promise<CrudPage<T>>;
+    /** Persist a new record and return it as stored, identity included. */
+    create(draft: CrudDraft<T>): Promise<T>;
+    /** Merge `draft` into the record at `id` and return the stored result. */
+    update(id: T[K], draft: CrudDraft<T>): Promise<T>;
+    /** Delete the record at `id`. */
+    remove(id: T[K]): Promise<void>;
+    /**
+     * Every record matching the query, ignoring pagination.
+     *
+     * Exists so export can cover the whole result set rather than the current
+     * page. Optional: a source over an unbounded remote collection may have no
+     * safe way to honour it, and callers must degrade to `list` when absent.
+     */
+    listAll?(query: Omit<CrudQuery<T>, 'page' | 'pageSize'>): Promise<readonly T[]>;
+}

package/dist/en_US-D3Kl6g3n.cjs

@@ -0,0 +1 @@
+var e={actions:`Actions`,edit:`Edit`,delete:`Delete`,create:`New`,refresh:`Refresh`,createTitle:`Create Item`,editTitle:`Edit Item`,ok:`OK`,cancel:`Cancel`,requiredField:e=>`${e} is required`,confirmDeleteTitle:`Are you sure?`,confirmDeleteContent:`This action cannot be undone.`,confirmDeleteOk:`Yes, Delete`,confirmBulkDeleteTitle:e=>`Delete ${e} items?`,confirmBulkDeleteOk:`Yes, Delete All`,deleteSelected:e=>`Delete Selected (${e})`,selectItemsToDelete:`Please select items to delete`,bulkDeleteSuccess:e=>`Deleted ${e} items`,bulkDeletePartial:(e,t,n)=>`Deleted ${e} of ${t}. ${n} failed.`,exportAll:e=>`Export all as ${e}`,exportPage:e=>`Export page as ${e}`,nothingToExport:`Nothing to export`,exportFailed:e=>`Export failed: ${e}`,createSuccess:`Created successfully`,updateSuccess:`Updated successfully`,deleteSuccess:`Deleted successfully`,loading:`Loading CRUD table…`,yes:`Yes`,no:`No`,empty:`-`,selectPlaceholder:e=>`Select ${e.toLowerCase()}`,tagsPlaceholder:`Type and press enter`,invalidEmail:`Please enter a valid email`,invalidUrl:`Please enter a valid URL`,invalidImageUrl:`Please enter a valid image URL`,invalidJson:`Please enter valid JSON`};Object.defineProperty(exports,"t",{enumerable:!0,get:function(){return e}});

package/dist/en_US-DGCMDOdX.js

@@ -0,0 +1,41 @@
+//#region lib/locale/en_US.ts
+var e = {
+	actions: "Actions",
+	edit: "Edit",
+	delete: "Delete",
+	create: "New",
+	refresh: "Refresh",
+	createTitle: "Create Item",
+	editTitle: "Edit Item",
+	ok: "OK",
+	cancel: "Cancel",
+	requiredField: (e) => `${e} is required`,
+	confirmDeleteTitle: "Are you sure?",
+	confirmDeleteContent: "This action cannot be undone.",
+	confirmDeleteOk: "Yes, Delete",
+	confirmBulkDeleteTitle: (e) => `Delete ${e} items?`,
+	confirmBulkDeleteOk: "Yes, Delete All",
+	deleteSelected: (e) => `Delete Selected (${e})`,
+	selectItemsToDelete: "Please select items to delete",
+	bulkDeleteSuccess: (e) => `Deleted ${e} items`,
+	bulkDeletePartial: (e, t, n) => `Deleted ${e} of ${t}. ${n} failed.`,
+	exportAll: (e) => `Export all as ${e}`,
+	exportPage: (e) => `Export page as ${e}`,
+	nothingToExport: "Nothing to export",
+	exportFailed: (e) => `Export failed: ${e}`,
+	createSuccess: "Created successfully",
+	updateSuccess: "Updated successfully",
+	deleteSuccess: "Deleted successfully",
+	loading: "Loading CRUD table…",
+	yes: "Yes",
+	no: "No",
+	empty: "-",
+	selectPlaceholder: (e) => `Select ${e.toLowerCase()}`,
+	tagsPlaceholder: "Type and press enter",
+	invalidEmail: "Please enter a valid email",
+	invalidUrl: "Please enter a valid URL",
+	invalidImageUrl: "Please enter a valid image URL",
+	invalidJson: "Please enter valid JSON"
+};
+//#endregion
+export { e as t };

package/dist/exportData.cjs

@@ -1,5 +1,5 @@
-Object.defineProperties(exports,{__esModule:{value:!0},[Symbol.toStringTag]:{value:`Module`}});var e=(e,t)=>{let n=t.filter(e=>e.fieldType!==`option`&&e.dataIndex),r=n.map(e=>String(e.title||e.dataIndex)),i=e.map(e=>n.map(t=>{let n=e[t.dataIndex];return n==null?``:t.fieldType===`boolean`?n?`Yes`:`No`:t.fieldType===`date`?String(n):t.fieldType===`enum`&&t.enumOptions&&t.enumOptions[n]?.text||String(n)}));return[r.map(e=>`"${e}"`).join(`,`),...i.map(e=>e.map(e=>`"${String(e).replace(/"/g,`""`)}"`).join(`,`))].join(`
-`)},t=(e,t,n)=>{let r=new Blob([e],{type:n}),i=URL.createObjectURL(r),a=document.createElement(`a`);a.href=i,a.download=t,document.body.appendChild(a),a.click(),document.body.removeChild(a),URL.revokeObjectURL(i)},n=n=>{let{data:r,columns:i,filename:a=`export`}=n;t(e(r,i),`${a}.csv`,`text/csv;charset=utf-8;`)},r=e=>{let{data:n,filename:r=`export`}=e;t(JSON.stringify(n,null,2),`${r}.json`,`application/json`)},i=e=>{let{data:n,columns:r,filename:i=`export`}=e,a=r.filter(e=>e.fieldType!==`option`&&e.dataIndex),o=a.map(e=>String(e.title||e.dataIndex)),s=n.map(e=>a.map(t=>{let n=e[t.dataIndex];return n==null?``:t.fieldType===`boolean`?n?`Yes`:`No`:t.fieldType===`enum`&&t.enumOptions?t.enumOptions[n]?.text||String(n):typeof n==`number`?n:String(n)})),c=e=>e.replace(/&/g,`&amp;`).replace(/</g,`&lt;`).replace(/>/g,`&gt;`).replace(/"/g,`&quot;`).replace(/'/g,`&apos;`),l=e=>`<Cell><Data ss:Type="${typeof e==`number`?`Number`:`String`}">${typeof e==`number`?String(e):c(e)}</Data></Cell>`;t(`<?xml version="1.0"?>
+Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});var e=[`=`,`+`,`-`,`@`,`	`,`\r`],t=/^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/,n=n=>{if(n===``)return n;let r=n.trimStart();if(t.test(r))return n;let i=t=>t!==``&&e.includes(t[0]);return i(n)||i(r)?`'${n}`:n},r=(e,t)=>{let r=t.filter(e=>e.fieldType!==`option`&&e.dataIndex),i=r.map(e=>String(e.title||e.dataIndex)),a=e.map(e=>r.map(t=>{let n=e[t.dataIndex];return n==null?``:t.fieldType===`boolean`?n?`Yes`:`No`:t.fieldType===`date`?String(n):t.fieldType===`enum`&&t.enumOptions&&t.enumOptions[n]?.text||String(n)})),o=e=>`"${n(e).replace(/"/g,`""`)}"`;return[i.map(o).join(`,`),...a.map(e=>e.map(e=>o(String(e))).join(`,`))].join(`
+`)},i=(e,t,n)=>{let r=new Blob([e],{type:n}),i=URL.createObjectURL(r),a=document.createElement(`a`);a.href=i,a.download=t,document.body.appendChild(a),a.click(),document.body.removeChild(a),URL.revokeObjectURL(i)},a=e=>{let{data:t,columns:n,filename:a=`export`}=e;i(r(t,n),`${a}.csv`,`text/csv;charset=utf-8;`)},o=e=>{let{data:t,filename:n=`export`}=e;i(JSON.stringify(t,null,2),`${n}.json`,`application/json`)},s=e=>{let{data:t,columns:n,filename:r=`export`}=e,a=n.filter(e=>e.fieldType!==`option`&&e.dataIndex),o=a.map(e=>String(e.title||e.dataIndex)),s=t.map(e=>a.map(t=>{let n=e[t.dataIndex];return n==null?``:t.fieldType===`boolean`?n?`Yes`:`No`:t.fieldType===`enum`&&t.enumOptions?t.enumOptions[n]?.text||String(n):typeof n==`number`?n:String(n)})),c=e=>e.replace(/&/g,`&amp;`).replace(/</g,`&lt;`).replace(/>/g,`&gt;`).replace(/"/g,`&quot;`).replace(/'/g,`&apos;`),l=e=>`<Cell><Data ss:Type="${typeof e==`number`?`Number`:`String`}">${typeof e==`number`?String(e):c(e)}</Data></Cell>`;i(`<?xml version="1.0"?>
 <?mso-application progid="Excel.Sheet"?>
 <Workbook xmlns="urn:schemas-microsoft-com:office:spreadsheet"
  xmlns:ss="urn:schemas-microsoft-com:office:spreadsheet">
@@ -10,4 +10,4 @@ ${s.map(e=>`<Row>${e.map(e=>l(e)).join(``)}</Row>`).join(`
 `)}
   </Table>
  </Worksheet>
-</Workbook>`,`${i}.xls`,`application/vnd.ms-excel`)},a=e=>{let{format:t=`csv`}=e;switch(t){case`csv`:n(e);break;case`json`:r(e);break;case`xlsx`:i(e);break;default:n(e)}},o=async(e,t,n=`export`,r=`csv`)=>{try{a({data:await e(),columns:t,filename:n,format:r})}catch(e){throw console.error(`Export failed:`,e),e}};exports.default=a,exports.exportData=a,exports.exportAllData=o,exports.exportToCSV=n,exports.exportToJSON=r,exports.exportToXLSX=i;
+</Workbook>`,`${r}.xls`,`application/vnd.ms-excel`)},c=e=>{let{format:t=`csv`}=e;switch(t){case`csv`:a(e);break;case`json`:o(e);break;case`excel`:s(e);break;default:a(e)}},l=async(e,t,n=`export`,r=`csv`)=>{try{c({data:await e(),columns:t,filename:n,format:r})}catch(e){throw console.error(`Export failed:`,e),e}};exports.exportAllData=l,exports.exportData=c,exports.exportToCSV=a,exports.exportToExcel=s,exports.exportToJSON=o;