@mono-lit/helper 0.0.2 → 0.0.3

package/dist/src/search/data-search.d.ts

@@ -1,5 +1,5 @@
-import { MonoSearchExpr, MonoSearchExprEntry } from './search-expr.js';
-export type { MonoSearchExpr, MonoSearchExprEntry };
+import { MonoSearchExpr, MonoSearchExprEntry } from "./search-expr.js";
+//#region src/search/data-search.d.ts
 /**
  * A `search-value` prop as authored: the comma-separated string form, or the
  * array form (which additionally allows `{ field, custom }` entries).
@@ -23,10 +23,10 @@ export declare function parseSearchValue(value: MonoSearchValue | undefined | nu
  * purely for back-compat.
  */
 export interface MonoSearchFieldsAliases {
-    searchExpr?: MonoSearchValue | null;
-    'search-expr'?: MonoSearchValue | null;
-    searchValue?: MonoSearchValue | null;
-    'search-value'?: MonoSearchValue | null;
+  searchExpr?: MonoSearchValue | null;
+  'search-expr'?: MonoSearchValue | null;
+  searchValue?: MonoSearchValue | null;
+  'search-value'?: MonoSearchValue | null;
 }
 /** The spellings, in the order a merge reads them. */
 export declare const SEARCH_FIELDS_KEYS: readonly ["searchExpr", "search-expr", "searchValue", "search-value"];
@@ -46,34 +46,34 @@ export declare const SEARCH_FIELDS_KEYS: readonly ["searchExpr", "search-expr",
 export declare function mergeSearchFields(src: MonoSearchFieldsAliases | undefined | null): MonoSearchExprEntry[] | undefined;
 /** Inputs to {@link resolveSearchFields}. */
 export interface ResolveSearchFieldsOptions {
-    /** The component's `search-value` prop, in either form. */
-    searchValue?: MonoSearchValue | null;
-    /**
-     * Fields to search when `search-value` is empty — a component's natural
-     * defaults (`display-value` when it's a string, then `key-value`).
-     */
-    fallbackFields?: Array<string | undefined | null>;
-    /** Loaded rows, sampled to resolve `*` patterns. */
-    rows?: readonly unknown[];
-    /**
-     * Whether the source is remote (store-backed). A remote `$filter` can only
-     * `contains` a **string** column, so a `*` pattern expands to string leaves
-     * only — `contains(Price,'x')` is invalid OData and would reject the request.
-     */
-    remote?: boolean;
-    /**
-     * Search **everything** when `search-value` is empty: `'*'` is prepended ahead
-     * of {@link fallbackFields} rather than the fallbacks being used alone.
-     *
-     * The fallbacks are kept as a safety net rather than replaced, for two reasons:
-     * a `'*'` resolves against `rows`, so before a remote source's first page has
-     * landed it expands to NOTHING and the query would silently match everything;
-     * and `textOnly` drops non-string leaves on a remote source, which would stop a
-     * numeric `key-value` being searchable. A concrete fallback entry is exempt from
-     * both — `resolveSearchEntries` treats an explicitly named field as explicit, so
-     * it survives expansion and appears exactly once.
-     */
-    defaultToWildcard?: boolean;
+  /** The component's `search-value` prop, in either form. */
+  searchValue?: MonoSearchValue | null;
+  /**
+   * Fields to search when `search-value` is empty — a component's natural
+   * defaults (`display-value` when it's a string, then `key-value`).
+   */
+  fallbackFields?: Array<string | undefined | null>;
+  /** Loaded rows, sampled to resolve `*` patterns. */
+  rows?: readonly unknown[];
+  /**
+   * Whether the source is remote (store-backed). A remote `$filter` can only
+   * `contains` a **string** column, so a `*` pattern expands to string leaves
+   * only — `contains(Price,'x')` is invalid OData and would reject the request.
+   */
+  remote?: boolean;
+  /**
+   * Search **everything** when `search-value` is empty: `'*'` is prepended ahead
+   * of {@link fallbackFields} rather than the fallbacks being used alone.
+   *
+   * The fallbacks are kept as a safety net rather than replaced, for two reasons:
+   * a `'*'` resolves against `rows`, so before a remote source's first page has
+   * landed it expands to NOTHING and the query would silently match everything;
+   * and `textOnly` drops non-string leaves on a remote source, which would stop a
+   * numeric `key-value` being searchable. A concrete fallback entry is exempt from
+   * both — `resolveSearchEntries` treats an explicitly named field as explicit, so
+   * it survives expansion and appears exactly once.
+   */
+  defaultToWildcard?: boolean;
 }
 /** The default when nothing is configured: every top-level field. */
 export declare const DEFAULT_SEARCH_FIELDS: readonly string[];
@@ -115,19 +115,19 @@ export declare function searchRowPredicate(entries: readonly MonoSearchExprEntry
 export declare function searchRemoteFilter(entries: readonly MonoSearchExprEntry[], query: string, operation?: string): unknown;
 /** The structural slice of a devextreme DataSource a search touches. */
 export interface SearchableSource {
-    searchOperation?: (op?: string) => unknown;
-    searchExpr?: (expr?: unknown) => unknown;
-    searchValue?: (v?: unknown) => unknown;
-    filter?: (v?: unknown) => unknown;
-    pageIndex?: (n?: number) => unknown;
-    load?: () => PromiseLike<unknown> | unknown;
+  searchOperation?: (op?: string) => unknown;
+  searchExpr?: (expr?: unknown) => unknown;
+  searchValue?: (v?: unknown) => unknown;
+  filter?: (v?: unknown) => unknown;
+  pageIndex?: (n?: number) => unknown;
+  load?: () => PromiseLike<unknown> | unknown;
 }
 /** Inputs to {@link MonoSourceSearch.apply}. */
 export interface ApplySourceSearchOptions extends ResolveSearchFieldsOptions {
-    /** The text the user typed. */
-    query: string;
-    /** devextreme search operation (default `'contains'`). */
-    operation?: string;
+  /** The text the user typed. */
+  query: string;
+  /** devextreme search operation (default `'contains'`). */
+  operation?: string;
 }
 /**
  * Applies a search to a bound DataSource, choosing between the source's own
@@ -158,50 +158,52 @@ export interface ApplySourceSearchOptions extends ResolveSearchFieldsOptions {
  * ```
  */
 export declare class MonoSourceSearch {
-    /** The source the captured base filter belongs to. */
-    private _source;
-    /** The consumer's own `filter()`, as it was before any search touched it. */
-    private _baseFilter;
-    /** Whether the last apply wrote a search clause into `filter()`. */
-    private _wroteFilter;
-    /** What the source HELD after this instance's last `filter()` write (read back). */
-    private _lastWritten;
-    /**
-     * Snapshot a source's own filter. Safe to call repeatedly — the snapshot is
-     * only (re)taken when the source identity actually changes, so it can be driven
-     * straight from a `willUpdate` branch. A change on the SAME source is picked up
-     * by `_syncBase` at the next apply/clear instead.
-     */
-    bind(source: unknown): void;
-    /**
-     * Adopt a filter the consumer set on the source since the last write —
-     * anything the source holds that is not what this instance last put there.
-     * `_writeFilter` records what the source HOLDS after a write (read back), so a
-     * source that ignores writes reads back as its own last write and is never
-     * re-adopted, and one that normalises compares against its normalised value.
-     */
-    private _syncBase;
-    /** Write `filter()` and remember what the source holds afterwards. */
-    private _writeFilter;
-    /**
-     * Undo whatever this instance wrote onto the source, then forget it.
-     *
-     * `reset()` alone is not enough at teardown. With `defaultToWildcard`, a `'*'`
-     * entry is never foldable, so the search is AND-ed into `source.filter()` — the
-     * same slot the CONSUMER's own filter lives in. Only `apply()` ever restores the
-     * captured base (and only when the next apply happens to be foldable), so an
-     * element torn down mid-query used to leave its clause behind on a DataSource
-     * the app still owns and shares.
-     *
-     * Deliberately does NOT `load()`: teardown must not issue a request. The next
-     * consumer of the source reloads on its own terms.
-     */
-    clear(source?: unknown): void;
-    /** Forget the captured state without touching the source. */
-    reset(): void;
-    /**
-     * Push `query` onto `source` and reload it. Returns the resolved entries so a
-     * caller can reuse them for its own client-side rendering without re-resolving.
-     */
-    apply(source: unknown, options: ApplySourceSearchOptions): Promise<MonoSearchExprEntry[]>;
+  /** The source the captured base filter belongs to. */
+  private _source;
+  /** The consumer's own `filter()`, as it was before any search touched it. */
+  private _baseFilter;
+  /** Whether the last apply wrote a search clause into `filter()`. */
+  private _wroteFilter;
+  /** What the source HELD after this instance's last `filter()` write (read back). */
+  private _lastWritten;
+  /**
+   * Snapshot a source's own filter. Safe to call repeatedly — the snapshot is
+   * only (re)taken when the source identity actually changes, so it can be driven
+   * straight from a `willUpdate` branch. A change on the SAME source is picked up
+   * by `_syncBase` at the next apply/clear instead.
+   */
+  bind(source: unknown): void;
+  /**
+   * Adopt a filter the consumer set on the source since the last write —
+   * anything the source holds that is not what this instance last put there.
+   * `_writeFilter` records what the source HOLDS after a write (read back), so a
+   * source that ignores writes reads back as its own last write and is never
+   * re-adopted, and one that normalises compares against its normalised value.
+   */
+  private _syncBase;
+  /** Write `filter()` and remember what the source holds afterwards. */
+  private _writeFilter;
+  /**
+   * Undo whatever this instance wrote onto the source, then forget it.
+   *
+   * `reset()` alone is not enough at teardown. With `defaultToWildcard`, a `'*'`
+   * entry is never foldable, so the search is AND-ed into `source.filter()` — the
+   * same slot the CONSUMER's own filter lives in. Only `apply()` ever restores the
+   * captured base (and only when the next apply happens to be foldable), so an
+   * element torn down mid-query used to leave its clause behind on a DataSource
+   * the app still owns and shares.
+   *
+   * Deliberately does NOT `load()`: teardown must not issue a request. The next
+   * consumer of the source reloads on its own terms.
+   */
+  clear(source?: unknown): void;
+  /** Forget the captured state without touching the source. */
+  reset(): void;
+  /**
+   * Push `query` onto `source` and reload it. Returns the resolved entries so a
+   * caller can reuse them for its own client-side rendering without re-resolving.
+   */
+  apply(source: unknown, options: ApplySourceSearchOptions): Promise<MonoSearchExprEntry[]>;
 }
+//#endregion
+export type { MonoSearchExpr, MonoSearchExprEntry };

package/dist/src/search/field-path.d.ts

@@ -1,3 +1,4 @@
+//#region src/search/field-path.d.ts
 /**
  * Path field expressions.
  *
@@ -20,18 +21,18 @@
  * to plain `row[field]` when it returns false, so plain fields are unchanged.
  */
 export type FieldSegment = {
-    kind: 'key';
-    name: string;
+  kind: 'key';
+  name: string;
 } | {
-    kind: 'index';
-    index: number;
+  kind: 'index';
+  index: number;
 } | {
-    kind: 'wildcard';
+  kind: 'wildcard';
 };
 export interface ParsedFieldPath {
-    segments: FieldSegment[];
-    hasWildcard: boolean;
-    raw: string;
+  segments: FieldSegment[];
+  hasWildcard: boolean;
+  raw: string;
 }
 /** Whether `field` is a path expression (contains `.` or `[`) vs a plain key. */
 export declare function isPath(field: string): boolean;
@@ -105,3 +106,4 @@ export declare function odataComparison(op: string): string | null;
  * index segment mixed into a remote path); the caller warns + skips.
  */
 export declare function toODataClause(field: string, op: string, value: unknown): ODataClause | null;
+//#endregion

package/dist/src/search/filter-eval.d.ts

@@ -1,3 +1,4 @@
+//#region src/search/filter-eval.d.ts
 /**
  * Compile a devextreme filter expression (the array form `monoFilterBuilder`
  * emits via `changed({ type: 'array' })`) into a client-side row predicate, so a
@@ -28,3 +29,4 @@ export declare function andPredicates(...fns: Array<RowPredicate | null | undefi
  * members (`[a, 'or', b, 'or', c]`) rather than nesting pairs.
  */
 export declare function joinFilters(parts: unknown[], join: 'and' | 'or'): unknown;
+//#endregion

package/dist/src/search/index.d.ts

@@ -1,22 +1,6 @@
-/**
- * `@mono-lit/helper/search` — the shared data-search module.
- *
- * Everything about "which fields does a typed term match, and how does that
- * become a filter" lives here, independent of any component: path expressions,
- * `*` patterns, custom clause builders, the client predicate, the remote
- * `$filter`, and the DataSource application strategy.
- *
- * Consumed by `monoDataGrid`, `mono-select`, `mono-tag-input` and
- * `mono-dropdown-table`. It imports nothing outside this folder, so it can be
- * lifted into another package unchanged.
- */
-export { isPath, parseFieldPath, getFieldValue, setFieldValue, projectFields, mergePatch, toODataSelector, odataLiteral, odataComparison, toODataClause, } from './field-path.js';
-export type { FieldSegment, ParsedFieldPath, ODataClause } from './field-path.js';
-export { compileFilterPredicate, andFilters, andPredicates, joinFilters } from './filter-eval.js';
-export type { RowPredicate } from './filter-eval.js';
-export { normalizeSearchExpr, plainSearchColumns, searchEntryField, searchEntryFor, hasCustomSearch, hasWildcardSearch, isWildcardPattern, expandWildcard, resolveSearchEntries, customRemoteClause, customPredicate, } from './search-expr.js';
-export type { MonoSearchCustomCtx, MonoSearchCustomResult, MonoSearchExpr, MonoSearchExprCustom, MonoSearchExprEntry, ResolveSearchOptions, } from './search-expr.js';
-export { odataSearchExpr } from './odata-search.js';
-export type { MonoODataSearchOptions } from './odata-search.js';
-export { DEFAULT_SEARCH_OPERATION, SEARCH_FIELDS_KEYS, parseSearchValue, mergeSearchFields, resolveSearchFields, isFoldableSearch, plainSearchFields, readSearchField, searchRowPredicate, searchRemoteFilter, MonoSourceSearch, } from './data-search.js';
-export type { MonoSearchValue, MonoSearchFieldsAliases, ResolveSearchFieldsOptions, ApplySourceSearchOptions, SearchableSource, } from './data-search.js';
+import { MonoSearchCustomCtx, MonoSearchCustomResult, MonoSearchExpr, MonoSearchExprCustom, MonoSearchExprEntry, ResolveSearchOptions, customPredicate, customRemoteClause, expandWildcard, hasCustomSearch, hasWildcardSearch, isWildcardPattern, normalizeSearchExpr, plainSearchColumns, resolveSearchEntries, searchEntryField, searchEntryFor } from "./search-expr.js";
+import { ApplySourceSearchOptions, DEFAULT_SEARCH_OPERATION, MonoSearchFieldsAliases, MonoSearchValue, MonoSourceSearch, ResolveSearchFieldsOptions, SEARCH_FIELDS_KEYS, SearchableSource, isFoldableSearch, mergeSearchFields, parseSearchValue, plainSearchFields, readSearchField, resolveSearchFields, searchRemoteFilter, searchRowPredicate } from "./data-search.js";
+import { FieldSegment, ODataClause, ParsedFieldPath, getFieldValue, isPath, mergePatch, odataComparison, odataLiteral, parseFieldPath, projectFields, setFieldValue, toODataClause, toODataSelector } from "./field-path.js";
+import { MonoODataSearchOptions, odataSearchExpr } from "./odata-search.js";
+import { RowPredicate, andFilters, andPredicates, compileFilterPredicate, joinFilters } from "./filter-eval.js";
+export { type ApplySourceSearchOptions, DEFAULT_SEARCH_OPERATION, type FieldSegment, type MonoODataSearchOptions, type MonoSearchCustomCtx, type MonoSearchCustomResult, type MonoSearchExpr, type MonoSearchExprCustom, type MonoSearchExprEntry, type MonoSearchFieldsAliases, type MonoSearchValue, MonoSourceSearch, type ODataClause, type ParsedFieldPath, type ResolveSearchFieldsOptions, type ResolveSearchOptions, type RowPredicate, SEARCH_FIELDS_KEYS, type SearchableSource, andFilters, andPredicates, compileFilterPredicate, customPredicate, customRemoteClause, expandWildcard, getFieldValue, hasCustomSearch, hasWildcardSearch, isFoldableSearch, isPath, isWildcardPattern, joinFilters, mergePatch, mergeSearchFields, normalizeSearchExpr, odataComparison, odataLiteral, odataSearchExpr, parseFieldPath, parseSearchValue, plainSearchColumns, plainSearchFields, projectFields, readSearchField, resolveSearchEntries, resolveSearchFields, searchEntryField, searchEntryFor, searchRemoteFilter, searchRowPredicate, setFieldValue, toODataClause, toODataSelector };

package/dist/src/search/odata-search.d.ts

@@ -1,12 +1,13 @@
-import { MonoSearchExpr } from './search-expr.js';
+import { MonoSearchExpr } from "./search-expr.js";
+//#region src/search/odata-search.d.ts
 /** Metadata and selected properties used to compile a safe remote OData search. */
 export interface MonoODataSearchOptions {
-    /** CSDL returned by the service's `$metadata` endpoint. */
-    metadata: string | XMLDocument;
-    /** Fully qualified EDM type (`Default.Customer`) or its short name (`Customer`). */
-    entityType: string;
-    /** Properties made available to the search box, in display order. */
-    fields: readonly string[];
+  /** CSDL returned by the service's `$metadata` endpoint. */
+  metadata: string | XMLDocument;
+  /** Fully qualified EDM type (`Default.Customer`) or its short name (`Customer`). */
+  entityType: string;
+  /** Properties made available to the search box, in display order. */
+  fields: readonly string[];
 }
 /**
  * Compile selected CSDL properties into the grid's existing `searchExpr` contract.
@@ -16,3 +17,4 @@ export interface MonoODataSearchOptions {
  * input as equality. Unsupported EDM types do not generate invalid text predicates.
  */
 export declare function odataSearchExpr(options: MonoODataSearchOptions): MonoSearchExpr;
+//#endregion

package/dist/src/search/search-expr.d.ts

@@ -1,3 +1,4 @@
+//#region src/search/search-expr.d.ts
 /**
  * Search-expression entries: the fields a typed term is matched against.
  *
@@ -63,12 +64,12 @@
  */
 /** What a `custom` builder is handed for the term being applied. */
 export interface MonoSearchCustomCtx {
-    /** The column this entry declares — echoed so the builder needn't repeat it. */
-    field: string;
-    /** The raw text the user typed, exactly as typed. */
-    value: string;
-    /** The grid's configured `searchOperation` (default `'contains'`). */
-    operation: string;
+  /** The column this entry declares — echoed so the builder needn't repeat it. */
+  field: string;
+  /** The raw text the user typed, exactly as typed. */
+  value: string;
+  /** The grid's configured `searchOperation` (default `'contains'`). */
+  operation: string;
 }
 /**
  * What a `custom` builder may return. `null` / `undefined` / `false` all mean
@@ -77,10 +78,10 @@ export interface MonoSearchCustomCtx {
 export type MonoSearchCustomResult = string | unknown[] | ((row: any) => boolean) | null | undefined | false;
 /** A `searchExpr` entry that builds its own clause. */
 export interface MonoSearchExprCustom {
-    /** Column this entry covers — the name a bound `MonoSearchTerm.field` matches. */
-    field: string;
-    /** Build the clause for one term. See {@link MonoSearchCustomResult}. */
-    custom: (ctx: MonoSearchCustomCtx) => MonoSearchCustomResult;
+  /** Column this entry covers — the name a bound `MonoSearchTerm.field` matches. */
+  field: string;
+  /** Build the clause for one term. See {@link MonoSearchCustomResult}. */
+  custom: (ctx: MonoSearchCustomCtx) => MonoSearchCustomResult;
 }
 /** One `searchExpr` entry: a plain column name, or a custom builder. */
 export type MonoSearchExprEntry = string | MonoSearchExprCustom;
@@ -124,10 +125,10 @@ export declare function isWildcardPattern(field: string): boolean;
 export declare function expandWildcard(pattern: string, rows: readonly unknown[], textOnly: boolean): string[];
 /** Options for {@link resolveSearchEntries}. */
 export interface ResolveSearchOptions {
-    /** Rows to resolve `*` patterns against (the loaded data). */
-    rows?: readonly unknown[];
-    /** Keep only string-valued leaves — required for a remote OData source. */
-    textOnly?: boolean;
+  /** Rows to resolve `*` patterns against (the loaded data). */
+  rows?: readonly unknown[];
+  /** Keep only string-valued leaves — required for a remote OData source. */
+  textOnly?: boolean;
 }
 /**
  * The entries a search actually runs over: every `*` pattern replaced by the
@@ -158,3 +159,4 @@ export declare function customRemoteClause(entry: MonoSearchExprCustom, value: s
  * `[field, op, value]` a remote source receives also narrows an array source.
  */
 export declare function customPredicate(entry: MonoSearchExprCustom, value: string, operation: string): ((row: any) => boolean) | null;
+//#endregion

package/dist/src/utils/data-source-apply.d.ts

@@ -1,3 +1,4 @@
+//#region src/utils/data-source-apply.d.ts
 /**
  * ONE `$apply` request through a devextreme OData store.
  *
@@ -30,13 +31,13 @@
  */
 /** The slice of a devextreme store this module touches. */
 export interface ApplyStore {
-    load(options?: unknown): PromiseLike<unknown> | unknown;
-    /** OData protocol version (`ODataStore` only). */
-    version?(): number;
+  load(options?: unknown): PromiseLike<unknown> | unknown;
+  /** OData protocol version (`ODataStore` only). */
+  version?(): number;
 }
 export interface ApplyLoadOptions {
-    /** Cap the rolled-up rows (`$top`). */
-    top?: number;
+  /** Cap the rolled-up rows (`$top`). */
+  top?: number;
 }
 /** The store's OData version, or `null` for anything that is not an OData store. */
 export declare function odataStoreVersion(store: unknown): number | null;
@@ -80,10 +81,10 @@ export declare function isRolledUp(rows: readonly unknown[], keys: readonly stri
  */
 export declare function isApplyRejected(err: unknown): boolean;
 export interface ApplyGate {
-    /** `true` once the path is off — disabled by option, or rejected by the backend. */
-    readonly skip: boolean;
-    /** Report a failed request; a definite rejection turns the gate off for good. */
-    reject(err: unknown): void;
+  /** `true` once the path is off — disabled by option, or rejected by the backend. */
+  readonly skip: boolean;
+  /** Report a failed request; a definite rejection turns the gate off for good. */
+  reject(err: unknown): void;
 }
 /**
  * Per-controller "is the `$apply` path still worth trying?" switch.
@@ -95,3 +96,4 @@ export interface ApplyGate {
  * the next attempt goes out normally.
  */
 export declare function createApplyGate(enabled: boolean): ApplyGate;
+//#endregion

package/dist/src/utils/data-source-options.d.ts

@@ -1,8 +1,9 @@
-import { MaybeReactive } from '../composables/reactive.js';
+import { MaybeReactive } from "../composables/reactive.js";
+//#region src/utils/data-source-options.d.ts
 /** One sort entry, in devextreme's object form. */
 export interface MonoSourceSortEntry {
-    selector: string;
-    desc: boolean;
+  selector: string;
+  desc: boolean;
 }
 /**
  * DataSource-level knobs a controller keeps STICKY — `{ dataSourceOptions }`.
@@ -18,33 +19,33 @@ export interface MonoSourceSortEntry {
  * request. Changing it does not by itself run a query — that is `refresh()`.
  */
 export interface MonoDataSourceOptions {
-    /** Base filter, AND-ed under everything the controller adds. Array sources take a predicate too. */
-    filter?: unknown;
-    /** `$select`. */
-    select?: string | string[];
-    /** `$expand`. Simple navigation names union; a nested `Nav($select=…)` string is kept verbatim. */
-    expand?: string | string[];
-    /**
-     * Base sort. A sort the user picks wins; these follow as tiebreakers (entries
-     * whose selector is already sorted are skipped).
-     */
-    sort?: string | {
-        selector: string;
-        desc?: boolean;
-    } | Array<string | {
-        selector: string;
-        desc?: boolean;
-    }>;
-    /** Extra query-string parameters (ODataStore `customQueryParams`). */
-    customQueryParams?: Record<string, unknown>;
-    paginate?: boolean;
-    /** Source page size. A component's own page-size control still wins. */
-    pageSize?: number;
-    requireTotalCount?: boolean;
-    /** Source-level search columns/operation — used only when the controller declares none of its own. */
-    searchExpr?: string | string[];
-    searchOperation?: string;
-    [key: string]: unknown;
+  /** Base filter, AND-ed under everything the controller adds. Array sources take a predicate too. */
+  filter?: unknown;
+  /** `$select`. */
+  select?: string | string[];
+  /** `$expand`. Simple navigation names union; a nested `Nav($select=…)` string is kept verbatim. */
+  expand?: string | string[];
+  /**
+   * Base sort. A sort the user picks wins; these follow as tiebreakers (entries
+   * whose selector is already sorted are skipped).
+   */
+  sort?: string | {
+    selector: string;
+    desc?: boolean;
+  } | Array<string | {
+    selector: string;
+    desc?: boolean;
+  }>;
+  /** Extra query-string parameters (ODataStore `customQueryParams`). */
+  customQueryParams?: Record<string, unknown>;
+  paginate?: boolean;
+  /** Source page size. A component's own page-size control still wins. */
+  pageSize?: number;
+  requireTotalCount?: boolean;
+  /** Source-level search columns/operation — used only when the controller declares none of its own. */
+  searchExpr?: string | string[];
+  searchOperation?: string;
+  [key: string]: unknown;
 }
 /**
  * The same thing in raw OData vocabulary — `{ odataOptions }`.
@@ -62,11 +63,11 @@ export interface MonoDataSourceOptions {
  * sources cannot evaluate a raw string and ignore it (with one console warning).
  */
 export interface MonoOdataOptions {
-    $select?: string | string[];
-    $expand?: string | string[];
-    $orderby?: string;
-    $filter?: string;
-    [key: string]: unknown;
+  $select?: string | string[];
+  $expand?: string | string[];
+  $orderby?: string;
+  $filter?: string;
+  [key: string]: unknown;
 }
 /** The knobs with a meaning of their own; anything else is passed through as a load option. */
 export declare const DATA_SOURCE_KNOBS: ReadonlySet<string>;
@@ -114,3 +115,4 @@ export declare function resolveDataSourceOptions(dataSourceOptions: MaybeReactiv
 export declare function dataSourceOptionsKey(o: MonoDataSourceOptions): string;
 /** `expand` / `customQueryParams` / unknown keys — what goes onto a `store.load()` beside the knobs. */
 export declare function extraLoadOptions(o: MonoDataSourceOptions): Record<string, unknown>;
+//#endregion

package/dist/src/utils/data-source-read.d.ts

@@ -1,58 +1,49 @@
-import { andFilters } from '../search/filter-eval';
-import { unwrapReactive } from '../composables/reactive';
+import { unwrapReactive } from "../composables/reactive.js";
+import { andFilters } from "../search/filter-eval.js";
+//#region src/utils/data-source-read.d.ts
 /** The structural surface of a devextreme DataSource this module touches. */
 export interface ReadableDataSource<T = any> {
-    load(): PromiseLike<T[]> | T[];
-    items(): T[];
-    store?(): ReadableStore | undefined;
-    filter?(value?: unknown): unknown;
-    /** The source's own `$select`, inherited by a drain unless overridden. */
-    select?(value?: unknown): unknown;
-    sort?(value?: unknown): unknown;
-    searchValue?(value?: unknown): unknown;
-    searchExpr?(value?: unknown): unknown;
-    searchOperation?(value?: string): string;
-    paginate?(value?: boolean): boolean;
-    pageIndex?(value?: number): number;
-    totalCount?(): number;
+  load(): PromiseLike<T[]> | T[];
+  items(): T[];
+  store?(): ReadableStore | undefined;
+  filter?(value?: unknown): unknown;
+  /** The source's own `$select`, inherited by a drain unless overridden. */
+  select?(value?: unknown): unknown;
+  sort?(value?: unknown): unknown;
+  searchValue?(value?: unknown): unknown;
+  searchExpr?(value?: unknown): unknown;
+  searchOperation?(value?: string): string;
+  paginate?(value?: boolean): boolean;
+  pageIndex?(value?: number): number;
+  totalCount?(): number;
 }
 /** The structural surface of a devextreme store. */
 export interface ReadableStore {
-    load(options?: unknown): PromiseLike<unknown> | unknown;
-    key?(): unknown;
-    byKey?(key: unknown): unknown;
-    /** OData protocol version (a devextreme `ODataStore`); absent on a CustomStore. */
-    version?(): number;
+  load(options?: unknown): PromiseLike<unknown> | unknown;
+  key?(): unknown;
+  byKey?(key: unknown): unknown;
+  /** OData protocol version (a devextreme `ODataStore`); absent on a CustomStore. */
+  version?(): number;
 }
 export interface ReadAllRowsOptions {
-    /**
-     * Rows per request (default `100`). The total is unknowable up front for a
-     * remote source, so the read walks in fixed chunks until one comes back short.
-     */
-    chunkSize?: number;
-    /** Restrict the columns fetched (remote sources only). */
-    select?: string[];
-    /** Sort override. Defaults to whatever the source itself carries. */
-    sort?: unknown;
-    /**
-     * An extra filter AND-ed onto the source's own (and its search) — a controller's
-     * base, which is not written on the source when the read goes to the STORE.
-     * Remote sources only; an array source is filtered by what it holds.
-     */
-    filter?: unknown;
-    /** Extra load options spread into every chunk request (`expand`, `customQueryParams`, …). */
-    loadOptions?: Record<string, unknown>;
+  /**
+   * Rows per request (default `100`). The total is unknowable up front for a
+   * remote source, so the read walks in fixed chunks until one comes back short.
+   */
+  chunkSize?: number;
+  /** Restrict the columns fetched (remote sources only). */
+  select?: string[];
+  /** Sort override. Defaults to whatever the source itself carries. */
+  sort?: unknown;
+  /**
+   * An extra filter AND-ed onto the source's own (and its search) — a controller's
+   * base, which is not written on the source when the read goes to the STORE.
+   * Remote sources only; an array source is filtered by what it holds.
+   */
+  filter?: unknown;
+  /** Extra load options spread into every chunk request (`expand`, `customQueryParams`, …). */
+  loadOptions?: Record<string, unknown>;
 }
-/**
- * Unwrap Vue reactivity. A `ref(dataSource)` renders as nothing (the template
- * sees the wrapper, not the source), and a *reactive proxy* around a DataSource
- * can break its internals — devextreme stores identity-sensitive state that
- * doesn't survive being proxied.
- *
- * Re-exported (not redefined) from `composables/reactive` so the components that
- * need the same unwrap for value identity share one implementation.
- */
-export { unwrapReactive };
 /** A devextreme DataSource: it both loads and holds a current page. */
 export declare function isDataSourceLike(value: unknown): value is ReadableDataSource;
 /** A bare store (ODataStore / CustomStore / ArrayStore) — loads, but has no page. */
@@ -69,13 +60,6 @@ export declare function isReadableSource(value: unknown): boolean;
  * Reconstructing the filter here keeps the store path faithful to the grid.
  */
 export declare function searchFilterOf(source: ReadableDataSource): unknown;
-/**
- * AND-combine two optional devextreme filter expressions.
- *
- * Re-exported (not redefined) from the shared search module so the grid's filter
- * composition and a drain's composition can never disagree.
- */
-export { andFilters };
 /**
  * Read every row a source can produce, in chunks.
  *
@@ -83,3 +67,5 @@ export { andFilters };
  * "array or DataSource" without branching.
  */
 export declare function readAllRows<T = any>(source: unknown, options?: ReadAllRowsOptions): Promise<T[]>;
+//#endregion
+export { andFilters, unwrapReactive };