@tanstack/table-core 9.0.0-alpha.48 → 9.0.0-alpha.51

package/dist/core/headers/coreHeadersFeature.utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"coreHeadersFeature.utils.js","names":[],"sources":["../../../src/core/headers/coreHeadersFeature.utils.ts"],"sourcesContent":["import { getDefaultColumnPinningState } from '../../features/column-pinning/columnPinningFeature.utils'\nimport {\n  column_getIsVisible,\n  table_getVisibleLeafColumns,\n} from '../../features/column-visibility/columnVisibilityFeature.utils'\nimport { callMemoOrStaticFn } from '../../utils'\nimport { buildHeaderGroups } from './buildHeaderGroups'\nimport type { Table_Internal } from '../../types/Table'\nimport type { Header } from '../../types/Header'\nimport type { RowData } from '../../types/type-utils'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { Header_Header } from './coreHeadersFeature.types'\nimport type { Column } from '../../types/Column'\n\n/**\n * Walks a header tree and collects all descendant leaf headers.\n *\n * The header itself is included after its descendants, matching the recursive\n * shape used by nested header groups.\n *\n * @example\n * ```ts\n * const leafHeaders = header_getLeafHeaders(header)\n * ```\n */\nexport function header_getLeafHeaders<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue,\n>(header: Header<TFeatures, TData, TValue>) {\n  const leafHeaders: Array<Header<TFeatures, TData, TValue>> = []\n\n  const recurseHeader = (h: Header_Header<TFeatures, TData, TValue>) => {\n    if (h.subHeaders.length) {\n      h.subHeaders.map(recurseHeader)\n    }\n    leafHeaders.push(h as Header<TFeatures, TData, TValue>)\n  }\n\n  recurseHeader(header)\n\n  return leafHeaders\n}\n\n/**\n * Builds the render context passed to a column's `header` or `footer` template.\n *\n * The context contains the header, its column, and the owning table instance.\n *\n * @example\n * ```ts\n * const context = header_getContext(header)\n * ```\n */\nexport function header_getContext<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue,\n>(header: Header<TFeatures, TData, TValue>) {\n  return {\n    column: header.column,\n    header,\n    table: header.column.table,\n  }\n}\n\n/**\n * Builds visible header groups for the current column tree.\n *\n * Column visibility and pinning are applied before groups are built. When no\n * columns are pinned, the fast path skips pin partitioning.\n *\n * @example\n * ```ts\n * const headerGroups = table_getHeaderGroups(table)\n * ```\n */\nexport function table_getHeaderGroups<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  const { left, right } =\n    table.atoms.columnPinning?.get() ?? getDefaultColumnPinningState()\n  const allColumns = table.getAllColumns()\n  const leafColumns = callMemoOrStaticFn(\n    table,\n    'getVisibleLeafColumns',\n    table_getVisibleLeafColumns,\n  ) as Array<Column<TFeatures, TData, unknown>>\n\n  // Fast path: no columns are pinned — skip per-side lookups, partition, and spread.\n  if (!left.length && !right.length) {\n    return buildHeaderGroups(allColumns, leafColumns, table)\n  }\n\n  const leafColumnsById = table.getAllLeafColumnsById()\n\n  const leftColumns: typeof leafColumns = []\n  for (let i = 0; i < left.length; i++) {\n    const column = leafColumnsById[left[i]!]\n    if (\n      column &&\n      callMemoOrStaticFn(column, 'getIsVisible', column_getIsVisible)\n    ) {\n      leftColumns.push(column)\n    }\n  }\n\n  const rightColumns: typeof leafColumns = []\n  for (let i = 0; i < right.length; i++) {\n    const column = leafColumnsById[right[i]!]\n    if (\n      column &&\n      callMemoOrStaticFn(column, 'getIsVisible', column_getIsVisible)\n    ) {\n      rightColumns.push(column)\n    }\n  }\n\n  const centerColumns = leafColumns.filter(\n    (column) => !left.includes(column.id) && !right.includes(column.id),\n  )\n\n  return buildHeaderGroups(\n    allColumns,\n    [...leftColumns, ...centerColumns, ...rightColumns],\n    table,\n  )\n}\n\n/**\n * Builds footer groups by reversing the current header groups.\n *\n * Footer rendering uses the same header objects and grouping structure, but\n * renders them from leaf level back toward the root.\n *\n * @example\n * ```ts\n * const footerGroups = table_getFooterGroups(table)\n * ```\n */\nexport function table_getFooterGroups<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  const headerGroups = table.getHeaderGroups()\n  return [...headerGroups].reverse()\n}\n\n/**\n * Flattens every header from every header group into one array.\n *\n * The result includes parent headers and placeholder headers, in header-group\n * order from top to bottom.\n *\n * @example\n * ```ts\n * const flatHeaders = table_getFlatHeaders(table)\n * ```\n */\nexport function table_getFlatHeaders<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  const headerGroups = table.getHeaderGroups()\n  const result: Array<Header<TFeatures, TData, unknown>> = []\n  for (let i = 0; i < headerGroups.length; i++) {\n    const headers = headerGroups[i]!.headers\n    for (let j = 0; j < headers.length; j++) {\n      result.push(headers[j]!)\n    }\n  }\n  return result\n}\n\n/**\n * Collects only the leaf headers from the current header tree.\n *\n * Parent/group headers are skipped, making the result suitable for rendering\n * one header per visible leaf column.\n *\n * @example\n * ```ts\n * const leafHeaders = table_getLeafHeaders(table)\n * ```\n */\nexport function table_getLeafHeaders<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  const topHeaders = table.getHeaderGroups()[0]?.headers ?? []\n  const result: Array<Header<TFeatures, TData, unknown>> = []\n  for (let i = 0; i < topHeaders.length; i++) {\n    const leafHeaders = topHeaders[i]!.getLeafHeaders()\n    for (let j = 0; j < leafHeaders.length; j++) {\n      result.push(leafHeaders[j]!)\n    }\n  }\n  return result\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAyBA,SAAgB,sBAId,QAA0C;CAC1C,MAAM,cAAuD,EAAE;CAE/D,MAAM,iBAAiB,MAA+C;EACpE,IAAI,EAAE,WAAW,QACf,EAAE,WAAW,IAAI,cAAc;EAEjC,YAAY,KAAK,EAAsC;;CAGzD,cAAc,OAAO;CAErB,OAAO;;;;;;;;;;;;AAaT,SAAgB,kBAId,QAA0C;CAC1C,OAAO;EACL,QAAQ,OAAO;EACf;EACA,OAAO,OAAO,OAAO;EACtB;;;;;;;;;;;;;AAcH,SAAgB,sBAGd,OAAyC;;CACzC,MAAM,EAAE,MAAM,oCACZ,MAAM,MAAM,6FAAe,KAAK,KAAI,8BAA8B;CACpE,MAAM,aAAa,MAAM,eAAe;CACxC,MAAM,cAAc,mBAClB,OACA,yBACA,4BACD;CAGD,IAAI,CAAC,KAAK,UAAU,CAAC,MAAM,QACzB,OAAO,kBAAkB,YAAY,aAAa,MAAM;CAG1D,MAAM,kBAAkB,MAAM,uBAAuB;CAErD,MAAM,cAAkC,EAAE;CAC1C,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;EACpC,MAAM,SAAS,gBAAgB,KAAK;EACpC,IACE,UACA,mBAAmB,QAAQ,gBAAgB,oBAAoB,EAE/D,YAAY,KAAK,OAAO;;CAI5B,MAAM,eAAmC,EAAE;CAC3C,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;EACrC,MAAM,SAAS,gBAAgB,MAAM;EACrC,IACE,UACA,mBAAmB,QAAQ,gBAAgB,oBAAoB,EAE/D,aAAa,KAAK,OAAO;;CAI7B,MAAM,gBAAgB,YAAY,QAC/B,WAAW,CAAC,KAAK,SAAS,OAAO,GAAG,IAAI,CAAC,MAAM,SAAS,OAAO,GAAG,CACpE;CAED,OAAO,kBACL,YACA;EAAC,GAAG;EAAa,GAAG;EAAe,GAAG;EAAa,EACnD,MACD;;;;;;;;;;;;;AAcH,SAAgB,sBAGd,OAAyC;CAEzC,OAAO,CAAC,GADa,MAAM,iBACJ,CAAC,CAAC,SAAS;;;;;;;;;;;;;AAcpC,SAAgB,qBAGd,OAAyC;CACzC,MAAM,eAAe,MAAM,iBAAiB;CAC5C,MAAM,SAAmD,EAAE;CAC3D,KAAK,IAAI,IAAI,GAAG,IAAI,aAAa,QAAQ,KAAK;EAC5C,MAAM,UAAU,aAAa,GAAI;EACjC,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAClC,OAAO,KAAK,QAAQ,GAAI;;CAG5B,OAAO;;;;;;;;;;;;;AAcT,SAAgB,qBAGd,OAAyC;;CACzC,MAAM,uCAAa,MAAM,iBAAiB,CAAC,kFAAI,YAAW,EAAE;CAC5D,MAAM,SAAmD,EAAE;CAC3D,KAAK,IAAI,IAAI,GAAG,IAAI,WAAW,QAAQ,KAAK;EAC1C,MAAM,cAAc,WAAW,GAAI,gBAAgB;EACnD,KAAK,IAAI,IAAI,GAAG,IAAI,YAAY,QAAQ,KACtC,OAAO,KAAK,YAAY,GAAI;;CAGhC,OAAO"}
+{"version":3,"file":"coreHeadersFeature.utils.js","names":[],"sources":["../../../src/core/headers/coreHeadersFeature.utils.ts"],"sourcesContent":["import { getDefaultColumnPinningState } from '../../features/column-pinning/columnPinningFeature.utils'\nimport {\n  column_getIsVisible,\n  table_getVisibleLeafColumns,\n} from '../../features/column-visibility/columnVisibilityFeature.utils'\nimport { callMemoOrStaticFn } from '../../utils'\nimport { buildHeaderGroups } from './buildHeaderGroups'\nimport type { Table_Internal } from '../../types/Table'\nimport type { Header } from '../../types/Header'\nimport type { RowData } from '../../types/type-utils'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { Header_Header } from './coreHeadersFeature.types'\nimport type { Column } from '../../types/Column'\n\n/**\n * Walks a header tree and collects all descendant leaf headers.\n *\n * The header itself is included after its descendants, matching the recursive\n * shape used by nested header groups.\n *\n * @example\n * ```ts\n * const leafHeaders = header_getLeafHeaders(header)\n * ```\n */\nexport function header_getLeafHeaders<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue,\n>(header: Header<TFeatures, TData, TValue>) {\n  const leafHeaders: Array<Header<TFeatures, TData, TValue>> = []\n\n  const recurseHeader = (h: Header_Header<TFeatures, TData, TValue>) => {\n    if (h.subHeaders.length) {\n      h.subHeaders.map(recurseHeader)\n    }\n    leafHeaders.push(h as Header<TFeatures, TData, TValue>)\n  }\n\n  recurseHeader(header)\n\n  return leafHeaders\n}\n\n/**\n * Builds the render context passed to a column's `header` or `footer` template.\n *\n * The context contains the header, its column, and the owning table instance.\n *\n * @example\n * ```ts\n * const context = header_getContext(header)\n * ```\n */\nexport function header_getContext<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n  TValue,\n>(header: Header<TFeatures, TData, TValue>) {\n  return {\n    column: header.column,\n    header,\n    table: header.column.table,\n  }\n}\n\n/**\n * Builds visible header groups for the current column tree.\n *\n * Column visibility and pinning are applied before groups are built. When no\n * columns are pinned, the fast path skips pin partitioning.\n *\n * @example\n * ```ts\n * const headerGroups = table_getHeaderGroups(table)\n * ```\n */\nexport function table_getHeaderGroups<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  const { left, right } =\n    table.atoms.columnPinning?.get() ?? getDefaultColumnPinningState()\n  const allColumns = table.getAllColumns()\n  const leafColumns = callMemoOrStaticFn(\n    table,\n    'getVisibleLeafColumns',\n    table_getVisibleLeafColumns,\n  ) as Array<Column<TFeatures, TData, unknown>>\n\n  // Fast path: no columns are pinned — skip per-side lookups, partition, and spread.\n  if (!left.length && !right.length) {\n    return buildHeaderGroups(allColumns, leafColumns, table)\n  }\n\n  const leafColumnsById = table.getAllLeafColumnsById()\n\n  const leftColumns: typeof leafColumns = []\n  for (let i = 0; i < left.length; i++) {\n    const column = leafColumnsById[left[i]!]\n    if (\n      column &&\n      callMemoOrStaticFn(column, 'getIsVisible', column_getIsVisible)\n    ) {\n      leftColumns.push(column)\n    }\n  }\n\n  const rightColumns: typeof leafColumns = []\n  for (let i = 0; i < right.length; i++) {\n    const column = leafColumnsById[right[i]!]\n    if (\n      column &&\n      callMemoOrStaticFn(column, 'getIsVisible', column_getIsVisible)\n    ) {\n      rightColumns.push(column)\n    }\n  }\n\n  const centerColumns = leafColumns.filter(\n    (column) => !left.includes(column.id) && !right.includes(column.id),\n  )\n\n  return buildHeaderGroups(\n    allColumns,\n    [...leftColumns, ...centerColumns, ...rightColumns],\n    table,\n  )\n}\n\n/**\n * Builds footer groups by reversing the current header groups.\n *\n * Footer rendering uses the same header objects and grouping structure, but\n * renders them from leaf level back toward the root.\n *\n * @example\n * ```ts\n * const footerGroups = table_getFooterGroups(table)\n * ```\n */\nexport function table_getFooterGroups<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  const headerGroups = table.getHeaderGroups()\n  return [...headerGroups].reverse()\n}\n\n/**\n * Flattens every header from every header group into one array.\n *\n * The result includes parent headers and placeholder headers, in header-group\n * order from top to bottom.\n *\n * @example\n * ```ts\n * const flatHeaders = table_getFlatHeaders(table)\n * ```\n */\nexport function table_getFlatHeaders<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  const headerGroups = table.getHeaderGroups()\n  const result: Array<Header<TFeatures, TData, unknown>> = []\n  for (let i = 0; i < headerGroups.length; i++) {\n    const headers = headerGroups[i]!.headers\n    for (let j = 0; j < headers.length; j++) {\n      result.push(headers[j]!)\n    }\n  }\n  return result\n}\n\n/**\n * Collects only the leaf headers from the current header tree.\n *\n * Parent/group headers are skipped, making the result suitable for rendering\n * one header per visible leaf column.\n *\n * @example\n * ```ts\n * const leafHeaders = table_getLeafHeaders(table)\n * ```\n */\nexport function table_getLeafHeaders<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>) {\n  const topHeaders = table.getHeaderGroups()[0]?.headers ?? []\n  const result: Array<Header<TFeatures, TData, unknown>> = []\n  for (let i = 0; i < topHeaders.length; i++) {\n    const leafHeaders = topHeaders[i]!.getLeafHeaders()\n    for (let j = 0; j < leafHeaders.length; j++) {\n      result.push(leafHeaders[j]!)\n    }\n  }\n  return result\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAyBA,SAAgB,sBAId,QAA0C;CAC1C,MAAM,cAAuD,CAAC;CAE9D,MAAM,iBAAiB,MAA+C;EACpE,IAAI,EAAE,WAAW,QACf,EAAE,WAAW,IAAI,aAAa;EAEhC,YAAY,KAAK,CAAqC;CACxD;CAEA,cAAc,MAAM;CAEpB,OAAO;AACT;;;;;;;;;;;AAYA,SAAgB,kBAId,QAA0C;CAC1C,OAAO;EACL,QAAQ,OAAO;EACf;EACA,OAAO,OAAO,OAAO;CACvB;AACF;;;;;;;;;;;;AAaA,SAAgB,sBAGd,OAAyC;;CACzC,MAAM,EAAE,MAAM,oCACZ,MAAM,MAAM,6FAAe,IAAI,MAAK,6BAA6B;CACnE,MAAM,aAAa,MAAM,cAAc;CACvC,MAAM,cAAc,mBAClB,OACA,yBACA,2BACF;CAGA,IAAI,CAAC,KAAK,UAAU,CAAC,MAAM,QACzB,OAAO,kBAAkB,YAAY,aAAa,KAAK;CAGzD,MAAM,kBAAkB,MAAM,sBAAsB;CAEpD,MAAM,cAAkC,CAAC;CACzC,KAAK,IAAI,IAAI,GAAG,IAAI,KAAK,QAAQ,KAAK;EACpC,MAAM,SAAS,gBAAgB,KAAK;EACpC,IACE,UACA,mBAAmB,QAAQ,gBAAgB,mBAAmB,GAE9D,YAAY,KAAK,MAAM;CAE3B;CAEA,MAAM,eAAmC,CAAC;CAC1C,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;EACrC,MAAM,SAAS,gBAAgB,MAAM;EACrC,IACE,UACA,mBAAmB,QAAQ,gBAAgB,mBAAmB,GAE9D,aAAa,KAAK,MAAM;CAE5B;CAEA,MAAM,gBAAgB,YAAY,QAC/B,WAAW,CAAC,KAAK,SAAS,OAAO,EAAE,KAAK,CAAC,MAAM,SAAS,OAAO,EAAE,CACpE;CAEA,OAAO,kBACL,YACA;EAAC,GAAG;EAAa,GAAG;EAAe,GAAG;CAAY,GAClD,KACF;AACF;;;;;;;;;;;;AAaA,SAAgB,sBAGd,OAAyC;CAEzC,OAAO,CAAC,GADa,MAAM,gBACL,CAAC,EAAE,QAAQ;AACnC;;;;;;;;;;;;AAaA,SAAgB,qBAGd,OAAyC;CACzC,MAAM,eAAe,MAAM,gBAAgB;CAC3C,MAAM,SAAmD,CAAC;CAC1D,KAAK,IAAI,IAAI,GAAG,IAAI,aAAa,QAAQ,KAAK;EAC5C,MAAM,UAAU,aAAa,GAAI;EACjC,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAClC,OAAO,KAAK,QAAQ,EAAG;CAE3B;CACA,OAAO;AACT;;;;;;;;;;;;AAaA,SAAgB,qBAGd,OAAyC;;CACzC,MAAM,uCAAa,MAAM,gBAAgB,EAAE,kFAAI,YAAW,CAAC;CAC3D,MAAM,SAAmD,CAAC;CAC1D,KAAK,IAAI,IAAI,GAAG,IAAI,WAAW,QAAQ,KAAK;EAC1C,MAAM,cAAc,WAAW,GAAI,eAAe;EAClD,KAAK,IAAI,IAAI,GAAG,IAAI,YAAY,QAAQ,KACtC,OAAO,KAAK,YAAY,EAAG;CAE/B;CACA,OAAO;AACT"}

package/dist/core/reactivity/coreReactivityFeature.utils.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"coreReactivityFeature.utils.cjs","names":[],"sources":["../../../src/core/reactivity/coreReactivityFeature.utils.ts"],"sourcesContent":["import type { Atom, ReadonlyAtom, ReadonlyStore, Store } from '@tanstack/store'\n\n/**\n * Converts a writable atom to the store-compatible shape expected by core.\n *\n * @example\n * ```ts\n * const store = atomToStore(atom)\n * ```\n */\nexport function atomToStore<T>(atom: Atom<T>): Store<T>\n/**\n * Converts a readonly atom to a readonly store-compatible shape.\n *\n * @example\n * ```ts\n * const store = atomToStore(atom)\n * ```\n */\nexport function atomToStore<T>(atom: ReadonlyAtom<T>): ReadonlyStore<T>\n/**\n * Bridges atom instances to the `Store`/`ReadonlyStore` API by exposing\n * a `state` getter backed by `atom.get()`, and wiring `setState` for\n * writable atoms.\n *\n * @example\n * ```ts\n * const store = atomToStore(atom)\n * ```\n */\nexport function atomToStore<T>(\n  atom: Atom<T> | ReadonlyAtom<T>,\n): Store<T> | ReadonlyStore<T> {\n  const store: Store<T> = atom as Store<T>\n  Object.defineProperty(atom, 'state', {\n    get() {\n      return atom.get()\n    },\n  })\n  if ('set' in atom) {\n    store.setState = atom.set.bind(atom)\n  }\n  return store\n}\n"],"mappings":";;;;;;;;;;;;AA8BA,SAAgB,YACd,MAC6B;CAC7B,MAAM,QAAkB;CACxB,OAAO,eAAe,MAAM,SAAS,EACnC,MAAM;EACJ,OAAO,KAAK,KAAK;IAEpB,CAAC;CACF,IAAI,SAAS,MACX,MAAM,WAAW,KAAK,IAAI,KAAK,KAAK;CAEtC,OAAO"}
+{"version":3,"file":"coreReactivityFeature.utils.cjs","names":[],"sources":["../../../src/core/reactivity/coreReactivityFeature.utils.ts"],"sourcesContent":["import type { Atom, ReadonlyAtom, ReadonlyStore, Store } from '@tanstack/store'\n\n/**\n * Converts a writable atom to the store-compatible shape expected by core.\n *\n * @example\n * ```ts\n * const store = atomToStore(atom)\n * ```\n */\nexport function atomToStore<T>(atom: Atom<T>): Store<T>\n/**\n * Converts a readonly atom to a readonly store-compatible shape.\n *\n * @example\n * ```ts\n * const store = atomToStore(atom)\n * ```\n */\nexport function atomToStore<T>(atom: ReadonlyAtom<T>): ReadonlyStore<T>\n/**\n * Bridges atom instances to the `Store`/`ReadonlyStore` API by exposing\n * a `state` getter backed by `atom.get()`, and wiring `setState` for\n * writable atoms.\n *\n * @example\n * ```ts\n * const store = atomToStore(atom)\n * ```\n */\nexport function atomToStore<T>(\n  atom: Atom<T> | ReadonlyAtom<T>,\n): Store<T> | ReadonlyStore<T> {\n  const store: Store<T> = atom as Store<T>\n  Object.defineProperty(atom, 'state', {\n    get() {\n      return atom.get()\n    },\n  })\n  if ('set' in atom) {\n    store.setState = atom.set.bind(atom)\n  }\n  return store\n}\n"],"mappings":";;;;;;;;;;;;AA8BA,SAAgB,YACd,MAC6B;CAC7B,MAAM,QAAkB;CACxB,OAAO,eAAe,MAAM,SAAS,EACnC,MAAM;EACJ,OAAO,KAAK,IAAI;CAClB,EACF,CAAC;CACD,IAAI,SAAS,MACX,MAAM,WAAW,KAAK,IAAI,KAAK,IAAI;CAErC,OAAO;AACT"}

package/dist/core/reactivity/coreReactivityFeature.utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"coreReactivityFeature.utils.js","names":[],"sources":["../../../src/core/reactivity/coreReactivityFeature.utils.ts"],"sourcesContent":["import type { Atom, ReadonlyAtom, ReadonlyStore, Store } from '@tanstack/store'\n\n/**\n * Converts a writable atom to the store-compatible shape expected by core.\n *\n * @example\n * ```ts\n * const store = atomToStore(atom)\n * ```\n */\nexport function atomToStore<T>(atom: Atom<T>): Store<T>\n/**\n * Converts a readonly atom to a readonly store-compatible shape.\n *\n * @example\n * ```ts\n * const store = atomToStore(atom)\n * ```\n */\nexport function atomToStore<T>(atom: ReadonlyAtom<T>): ReadonlyStore<T>\n/**\n * Bridges atom instances to the `Store`/`ReadonlyStore` API by exposing\n * a `state` getter backed by `atom.get()`, and wiring `setState` for\n * writable atoms.\n *\n * @example\n * ```ts\n * const store = atomToStore(atom)\n * ```\n */\nexport function atomToStore<T>(\n  atom: Atom<T> | ReadonlyAtom<T>,\n): Store<T> | ReadonlyStore<T> {\n  const store: Store<T> = atom as Store<T>\n  Object.defineProperty(atom, 'state', {\n    get() {\n      return atom.get()\n    },\n  })\n  if ('set' in atom) {\n    store.setState = atom.set.bind(atom)\n  }\n  return store\n}\n"],"mappings":";;;;;;;;;;;AA8BA,SAAgB,YACd,MAC6B;CAC7B,MAAM,QAAkB;CACxB,OAAO,eAAe,MAAM,SAAS,EACnC,MAAM;EACJ,OAAO,KAAK,KAAK;IAEpB,CAAC;CACF,IAAI,SAAS,MACX,MAAM,WAAW,KAAK,IAAI,KAAK,KAAK;CAEtC,OAAO"}
+{"version":3,"file":"coreReactivityFeature.utils.js","names":[],"sources":["../../../src/core/reactivity/coreReactivityFeature.utils.ts"],"sourcesContent":["import type { Atom, ReadonlyAtom, ReadonlyStore, Store } from '@tanstack/store'\n\n/**\n * Converts a writable atom to the store-compatible shape expected by core.\n *\n * @example\n * ```ts\n * const store = atomToStore(atom)\n * ```\n */\nexport function atomToStore<T>(atom: Atom<T>): Store<T>\n/**\n * Converts a readonly atom to a readonly store-compatible shape.\n *\n * @example\n * ```ts\n * const store = atomToStore(atom)\n * ```\n */\nexport function atomToStore<T>(atom: ReadonlyAtom<T>): ReadonlyStore<T>\n/**\n * Bridges atom instances to the `Store`/`ReadonlyStore` API by exposing\n * a `state` getter backed by `atom.get()`, and wiring `setState` for\n * writable atoms.\n *\n * @example\n * ```ts\n * const store = atomToStore(atom)\n * ```\n */\nexport function atomToStore<T>(\n  atom: Atom<T> | ReadonlyAtom<T>,\n): Store<T> | ReadonlyStore<T> {\n  const store: Store<T> = atom as Store<T>\n  Object.defineProperty(atom, 'state', {\n    get() {\n      return atom.get()\n    },\n  })\n  if ('set' in atom) {\n    store.setState = atom.set.bind(atom)\n  }\n  return store\n}\n"],"mappings":";;;;;;;;;;;AA8BA,SAAgB,YACd,MAC6B;CAC7B,MAAM,QAAkB;CACxB,OAAO,eAAe,MAAM,SAAS,EACnC,MAAM;EACJ,OAAO,KAAK,IAAI;CAClB,EACF,CAAC;CACD,IAAI,SAAS,MACX,MAAM,WAAW,KAAK,IAAI,KAAK,IAAI;CAErC,OAAO;AACT"}

package/dist/core/row-models/coreRowModelsFeature.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"coreRowModelsFeature.cjs","names":["table_getCoreRowModel","table_getPreFilteredRowModel","table_getFilteredRowModel","table_getPreGroupedRowModel","table_getGroupedRowModel","table_getPreSortedRowModel","table_getSortedRowModel","table_getPreExpandedRowModel","table_getExpandedRowModel","table_getPrePaginatedRowModel","table_getPaginatedRowModel","table_getRowModel"],"sources":["../../../src/core/row-models/coreRowModelsFeature.ts"],"sourcesContent":["import { assignTableAPIs } from '../../utils'\nimport {\n  table_getCoreRowModel,\n  table_getExpandedRowModel,\n  table_getFilteredRowModel,\n  table_getGroupedRowModel,\n  table_getPaginatedRowModel,\n  table_getPreExpandedRowModel,\n  table_getPreFilteredRowModel,\n  table_getPreGroupedRowModel,\n  table_getPrePaginatedRowModel,\n  table_getPreSortedRowModel,\n  table_getRowModel,\n  table_getSortedRowModel,\n} from './coreRowModelsFeature.utils'\nimport type { RowData } from '../../types/type-utils'\nimport type { TableFeature, TableFeatures } from '../../types/TableFeatures'\n// import type { Table_RowModels } from './coreRowModelsFeature.types'\n\nexport interface CoreRowModelsFeatureConstructors<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n> {\n  // Table: Table_RowModels<TFeatures, TData>\n}\n\n/**\n * Creates the stock core row models feature.\n *\n * The returned feature registers its state defaults, option defaults, and instance APIs so it can be included in a `tableFeatures({ ... })` call.\n */\nexport function constructCoreRowModelsFeature<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(): TableFeature<CoreRowModelsFeatureConstructors<TFeatures, TData>> {\n  return {\n    constructTableAPIs: (table) => {\n      assignTableAPIs('coreRowModelsFeature', table, {\n        table_getCoreRowModel: {\n          fn: () => table_getCoreRowModel(table),\n        },\n        table_getPreFilteredRowModel: {\n          fn: () => table_getPreFilteredRowModel(table),\n        },\n        table_getFilteredRowModel: {\n          fn: () => table_getFilteredRowModel(table),\n        },\n        table_getPreGroupedRowModel: {\n          fn: () => table_getPreGroupedRowModel(table),\n        },\n        table_getGroupedRowModel: {\n          fn: () => table_getGroupedRowModel(table),\n        },\n        table_getPreSortedRowModel: {\n          fn: () => table_getPreSortedRowModel(table),\n        },\n        table_getSortedRowModel: {\n          fn: () => table_getSortedRowModel(table),\n        },\n        table_getPreExpandedRowModel: {\n          fn: () => table_getPreExpandedRowModel(table),\n        },\n        table_getExpandedRowModel: {\n          fn: () => table_getExpandedRowModel(table),\n        },\n        table_getPrePaginatedRowModel: {\n          fn: () => table_getPrePaginatedRowModel(table),\n        },\n        table_getPaginatedRowModel: {\n          fn: () => table_getPaginatedRowModel(table),\n        },\n        table_getRowModel: {\n          fn: () => table_getRowModel(table),\n        },\n      })\n    },\n  }\n}\n\n/**\n * The Core Row Models feature provides the core row model functionality.\n */\nexport const coreRowModelsFeature = constructCoreRowModelsFeature()\n"],"mappings":";;;;;;;;;AA+BA,SAAgB,gCAGsD;CACpE,OAAO,EACL,qBAAqB,UAAU;EAC7B,8BAAgB,wBAAwB,OAAO;GAC7C,uBAAuB,EACrB,UAAUA,yDAAsB,MAAM,EACvC;GACD,8BAA8B,EAC5B,UAAUC,gEAA6B,MAAM,EAC9C;GACD,2BAA2B,EACzB,UAAUC,6DAA0B,MAAM,EAC3C;GACD,6BAA6B,EAC3B,UAAUC,+DAA4B,MAAM,EAC7C;GACD,0BAA0B,EACxB,UAAUC,4DAAyB,MAAM,EAC1C;GACD,4BAA4B,EAC1B,UAAUC,8DAA2B,MAAM,EAC5C;GACD,yBAAyB,EACvB,UAAUC,2DAAwB,MAAM,EACzC;GACD,8BAA8B,EAC5B,UAAUC,gEAA6B,MAAM,EAC9C;GACD,2BAA2B,EACzB,UAAUC,6DAA0B,MAAM,EAC3C;GACD,+BAA+B,EAC7B,UAAUC,iEAA8B,MAAM,EAC/C;GACD,4BAA4B,EAC1B,UAAUC,8DAA2B,MAAM,EAC5C;GACD,mBAAmB,EACjB,UAAUC,qDAAkB,MAAM,EACnC;GACF,CAAC;IAEL;;;;;AAMH,MAAa,uBAAuB,+BAA+B"}
+{"version":3,"file":"coreRowModelsFeature.cjs","names":["table_getCoreRowModel","table_getPreFilteredRowModel","table_getFilteredRowModel","table_getPreGroupedRowModel","table_getGroupedRowModel","table_getPreSortedRowModel","table_getSortedRowModel","table_getPreExpandedRowModel","table_getExpandedRowModel","table_getPrePaginatedRowModel","table_getPaginatedRowModel","table_getRowModel"],"sources":["../../../src/core/row-models/coreRowModelsFeature.ts"],"sourcesContent":["import { assignTableAPIs } from '../../utils'\nimport {\n  table_getCoreRowModel,\n  table_getExpandedRowModel,\n  table_getFilteredRowModel,\n  table_getGroupedRowModel,\n  table_getPaginatedRowModel,\n  table_getPreExpandedRowModel,\n  table_getPreFilteredRowModel,\n  table_getPreGroupedRowModel,\n  table_getPrePaginatedRowModel,\n  table_getPreSortedRowModel,\n  table_getRowModel,\n  table_getSortedRowModel,\n} from './coreRowModelsFeature.utils'\nimport type { RowData } from '../../types/type-utils'\nimport type { TableFeature, TableFeatures } from '../../types/TableFeatures'\n// import type { Table_RowModels } from './coreRowModelsFeature.types'\n\nexport interface CoreRowModelsFeatureConstructors<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n> {\n  // Table: Table_RowModels<TFeatures, TData>\n}\n\n/**\n * Creates the stock core row models feature.\n *\n * The returned feature registers its state defaults, option defaults, and instance APIs so it can be included in a `tableFeatures({ ... })` call.\n */\nexport function constructCoreRowModelsFeature<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(): TableFeature<CoreRowModelsFeatureConstructors<TFeatures, TData>> {\n  return {\n    constructTableAPIs: (table) => {\n      assignTableAPIs('coreRowModelsFeature', table, {\n        table_getCoreRowModel: {\n          fn: () => table_getCoreRowModel(table),\n        },\n        table_getPreFilteredRowModel: {\n          fn: () => table_getPreFilteredRowModel(table),\n        },\n        table_getFilteredRowModel: {\n          fn: () => table_getFilteredRowModel(table),\n        },\n        table_getPreGroupedRowModel: {\n          fn: () => table_getPreGroupedRowModel(table),\n        },\n        table_getGroupedRowModel: {\n          fn: () => table_getGroupedRowModel(table),\n        },\n        table_getPreSortedRowModel: {\n          fn: () => table_getPreSortedRowModel(table),\n        },\n        table_getSortedRowModel: {\n          fn: () => table_getSortedRowModel(table),\n        },\n        table_getPreExpandedRowModel: {\n          fn: () => table_getPreExpandedRowModel(table),\n        },\n        table_getExpandedRowModel: {\n          fn: () => table_getExpandedRowModel(table),\n        },\n        table_getPrePaginatedRowModel: {\n          fn: () => table_getPrePaginatedRowModel(table),\n        },\n        table_getPaginatedRowModel: {\n          fn: () => table_getPaginatedRowModel(table),\n        },\n        table_getRowModel: {\n          fn: () => table_getRowModel(table),\n        },\n      })\n    },\n  }\n}\n\n/**\n * The Core Row Models feature provides the core row model functionality.\n */\nexport const coreRowModelsFeature = constructCoreRowModelsFeature()\n"],"mappings":";;;;;;;;;AA+BA,SAAgB,gCAGsD;CACpE,OAAO,EACL,qBAAqB,UAAU;EAC7B,8BAAgB,wBAAwB,OAAO;GAC7C,uBAAuB,EACrB,UAAUA,yDAAsB,KAAK,EACvC;GACA,8BAA8B,EAC5B,UAAUC,gEAA6B,KAAK,EAC9C;GACA,2BAA2B,EACzB,UAAUC,6DAA0B,KAAK,EAC3C;GACA,6BAA6B,EAC3B,UAAUC,+DAA4B,KAAK,EAC7C;GACA,0BAA0B,EACxB,UAAUC,4DAAyB,KAAK,EAC1C;GACA,4BAA4B,EAC1B,UAAUC,8DAA2B,KAAK,EAC5C;GACA,yBAAyB,EACvB,UAAUC,2DAAwB,KAAK,EACzC;GACA,8BAA8B,EAC5B,UAAUC,gEAA6B,KAAK,EAC9C;GACA,2BAA2B,EACzB,UAAUC,6DAA0B,KAAK,EAC3C;GACA,+BAA+B,EAC7B,UAAUC,iEAA8B,KAAK,EAC/C;GACA,4BAA4B,EAC1B,UAAUC,8DAA2B,KAAK,EAC5C;GACA,mBAAmB,EACjB,UAAUC,qDAAkB,KAAK,EACnC;EACF,CAAC;CACH,EACF;AACF;;;;AAKA,MAAa,uBAAuB,8BAA8B"}

package/dist/core/row-models/coreRowModelsFeature.js.map

@@ -1 +1 @@
-{"version":3,"file":"coreRowModelsFeature.js","names":[],"sources":["../../../src/core/row-models/coreRowModelsFeature.ts"],"sourcesContent":["import { assignTableAPIs } from '../../utils'\nimport {\n  table_getCoreRowModel,\n  table_getExpandedRowModel,\n  table_getFilteredRowModel,\n  table_getGroupedRowModel,\n  table_getPaginatedRowModel,\n  table_getPreExpandedRowModel,\n  table_getPreFilteredRowModel,\n  table_getPreGroupedRowModel,\n  table_getPrePaginatedRowModel,\n  table_getPreSortedRowModel,\n  table_getRowModel,\n  table_getSortedRowModel,\n} from './coreRowModelsFeature.utils'\nimport type { RowData } from '../../types/type-utils'\nimport type { TableFeature, TableFeatures } from '../../types/TableFeatures'\n// import type { Table_RowModels } from './coreRowModelsFeature.types'\n\nexport interface CoreRowModelsFeatureConstructors<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n> {\n  // Table: Table_RowModels<TFeatures, TData>\n}\n\n/**\n * Creates the stock core row models feature.\n *\n * The returned feature registers its state defaults, option defaults, and instance APIs so it can be included in a `tableFeatures({ ... })` call.\n */\nexport function constructCoreRowModelsFeature<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(): TableFeature<CoreRowModelsFeatureConstructors<TFeatures, TData>> {\n  return {\n    constructTableAPIs: (table) => {\n      assignTableAPIs('coreRowModelsFeature', table, {\n        table_getCoreRowModel: {\n          fn: () => table_getCoreRowModel(table),\n        },\n        table_getPreFilteredRowModel: {\n          fn: () => table_getPreFilteredRowModel(table),\n        },\n        table_getFilteredRowModel: {\n          fn: () => table_getFilteredRowModel(table),\n        },\n        table_getPreGroupedRowModel: {\n          fn: () => table_getPreGroupedRowModel(table),\n        },\n        table_getGroupedRowModel: {\n          fn: () => table_getGroupedRowModel(table),\n        },\n        table_getPreSortedRowModel: {\n          fn: () => table_getPreSortedRowModel(table),\n        },\n        table_getSortedRowModel: {\n          fn: () => table_getSortedRowModel(table),\n        },\n        table_getPreExpandedRowModel: {\n          fn: () => table_getPreExpandedRowModel(table),\n        },\n        table_getExpandedRowModel: {\n          fn: () => table_getExpandedRowModel(table),\n        },\n        table_getPrePaginatedRowModel: {\n          fn: () => table_getPrePaginatedRowModel(table),\n        },\n        table_getPaginatedRowModel: {\n          fn: () => table_getPaginatedRowModel(table),\n        },\n        table_getRowModel: {\n          fn: () => table_getRowModel(table),\n        },\n      })\n    },\n  }\n}\n\n/**\n * The Core Row Models feature provides the core row model functionality.\n */\nexport const coreRowModelsFeature = constructCoreRowModelsFeature()\n"],"mappings":";;;;;;;;;AA+BA,SAAgB,gCAGsD;CACpE,OAAO,EACL,qBAAqB,UAAU;EAC7B,gBAAgB,wBAAwB,OAAO;GAC7C,uBAAuB,EACrB,UAAU,sBAAsB,MAAM,EACvC;GACD,8BAA8B,EAC5B,UAAU,6BAA6B,MAAM,EAC9C;GACD,2BAA2B,EACzB,UAAU,0BAA0B,MAAM,EAC3C;GACD,6BAA6B,EAC3B,UAAU,4BAA4B,MAAM,EAC7C;GACD,0BAA0B,EACxB,UAAU,yBAAyB,MAAM,EAC1C;GACD,4BAA4B,EAC1B,UAAU,2BAA2B,MAAM,EAC5C;GACD,yBAAyB,EACvB,UAAU,wBAAwB,MAAM,EACzC;GACD,8BAA8B,EAC5B,UAAU,6BAA6B,MAAM,EAC9C;GACD,2BAA2B,EACzB,UAAU,0BAA0B,MAAM,EAC3C;GACD,+BAA+B,EAC7B,UAAU,8BAA8B,MAAM,EAC/C;GACD,4BAA4B,EAC1B,UAAU,2BAA2B,MAAM,EAC5C;GACD,mBAAmB,EACjB,UAAU,kBAAkB,MAAM,EACnC;GACF,CAAC;IAEL;;;;;AAMH,MAAa,uBAAuB,+BAA+B"}
+{"version":3,"file":"coreRowModelsFeature.js","names":[],"sources":["../../../src/core/row-models/coreRowModelsFeature.ts"],"sourcesContent":["import { assignTableAPIs } from '../../utils'\nimport {\n  table_getCoreRowModel,\n  table_getExpandedRowModel,\n  table_getFilteredRowModel,\n  table_getGroupedRowModel,\n  table_getPaginatedRowModel,\n  table_getPreExpandedRowModel,\n  table_getPreFilteredRowModel,\n  table_getPreGroupedRowModel,\n  table_getPrePaginatedRowModel,\n  table_getPreSortedRowModel,\n  table_getRowModel,\n  table_getSortedRowModel,\n} from './coreRowModelsFeature.utils'\nimport type { RowData } from '../../types/type-utils'\nimport type { TableFeature, TableFeatures } from '../../types/TableFeatures'\n// import type { Table_RowModels } from './coreRowModelsFeature.types'\n\nexport interface CoreRowModelsFeatureConstructors<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n> {\n  // Table: Table_RowModels<TFeatures, TData>\n}\n\n/**\n * Creates the stock core row models feature.\n *\n * The returned feature registers its state defaults, option defaults, and instance APIs so it can be included in a `tableFeatures({ ... })` call.\n */\nexport function constructCoreRowModelsFeature<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(): TableFeature<CoreRowModelsFeatureConstructors<TFeatures, TData>> {\n  return {\n    constructTableAPIs: (table) => {\n      assignTableAPIs('coreRowModelsFeature', table, {\n        table_getCoreRowModel: {\n          fn: () => table_getCoreRowModel(table),\n        },\n        table_getPreFilteredRowModel: {\n          fn: () => table_getPreFilteredRowModel(table),\n        },\n        table_getFilteredRowModel: {\n          fn: () => table_getFilteredRowModel(table),\n        },\n        table_getPreGroupedRowModel: {\n          fn: () => table_getPreGroupedRowModel(table),\n        },\n        table_getGroupedRowModel: {\n          fn: () => table_getGroupedRowModel(table),\n        },\n        table_getPreSortedRowModel: {\n          fn: () => table_getPreSortedRowModel(table),\n        },\n        table_getSortedRowModel: {\n          fn: () => table_getSortedRowModel(table),\n        },\n        table_getPreExpandedRowModel: {\n          fn: () => table_getPreExpandedRowModel(table),\n        },\n        table_getExpandedRowModel: {\n          fn: () => table_getExpandedRowModel(table),\n        },\n        table_getPrePaginatedRowModel: {\n          fn: () => table_getPrePaginatedRowModel(table),\n        },\n        table_getPaginatedRowModel: {\n          fn: () => table_getPaginatedRowModel(table),\n        },\n        table_getRowModel: {\n          fn: () => table_getRowModel(table),\n        },\n      })\n    },\n  }\n}\n\n/**\n * The Core Row Models feature provides the core row model functionality.\n */\nexport const coreRowModelsFeature = constructCoreRowModelsFeature()\n"],"mappings":";;;;;;;;;AA+BA,SAAgB,gCAGsD;CACpE,OAAO,EACL,qBAAqB,UAAU;EAC7B,gBAAgB,wBAAwB,OAAO;GAC7C,uBAAuB,EACrB,UAAU,sBAAsB,KAAK,EACvC;GACA,8BAA8B,EAC5B,UAAU,6BAA6B,KAAK,EAC9C;GACA,2BAA2B,EACzB,UAAU,0BAA0B,KAAK,EAC3C;GACA,6BAA6B,EAC3B,UAAU,4BAA4B,KAAK,EAC7C;GACA,0BAA0B,EACxB,UAAU,yBAAyB,KAAK,EAC1C;GACA,4BAA4B,EAC1B,UAAU,2BAA2B,KAAK,EAC5C;GACA,yBAAyB,EACvB,UAAU,wBAAwB,KAAK,EACzC;GACA,8BAA8B,EAC5B,UAAU,6BAA6B,KAAK,EAC9C;GACA,2BAA2B,EACzB,UAAU,0BAA0B,KAAK,EAC3C;GACA,+BAA+B,EAC7B,UAAU,8BAA8B,KAAK,EAC/C;GACA,4BAA4B,EAC1B,UAAU,2BAA2B,KAAK,EAC5C;GACA,mBAAmB,EACjB,UAAU,kBAAkB,KAAK,EACnC;EACF,CAAC;CACH,EACF;AACF;;;;AAKA,MAAa,uBAAuB,8BAA8B"}

package/dist/core/row-models/coreRowModelsFeature.utils.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"coreRowModelsFeature.utils.cjs","names":["createCoreRowModel"],"sources":["../../../src/core/row-models/coreRowModelsFeature.utils.ts"],"sourcesContent":["import { createCoreRowModel } from './createCoreRowModel'\nimport type { Table_Internal } from '../../types/Table'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { RowData } from '../../types/type-utils'\nimport type { RowModel } from './coreRowModelsFeature.types'\n\n/**\n * Resolves the table's unmodified core row model.\n *\n * The factory is created once per table, either from `options._rowModels.coreRowModel`\n * or the built-in `createCoreRowModel()`, then reused for later calls.\n *\n * @example\n * ```ts\n * const coreRows = table_getCoreRowModel(table)\n * ```\n */\nexport function table_getCoreRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.coreRowModel) {\n    table._rowModels.coreRowModel =\n      table.options._rowModels?.coreRowModel?.(table) ??\n      createCoreRowModel<TFeatures, TData>()(table)\n  }\n\n  return table._rowModels.coreRowModel()\n}\n\n/**\n * Reads the row model immediately before column/global filtering.\n *\n * Filtering is the first derived row-model stage, so this currently aliases\n * `table.getCoreRowModel()`.\n *\n * @example\n * ```ts\n * const rowsBeforeFiltering = table_getPreFilteredRowModel(table)\n * ```\n */\nexport function table_getPreFilteredRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getCoreRowModel()\n}\n\n/**\n * Resolves the row model after column and global filtering.\n *\n * When `manualFiltering` is enabled, or no filtered row-model factory was\n * registered, this returns the pre-filtered row model because filtering is\n * expected to happen outside the table.\n *\n * @example\n * ```ts\n * const filteredRows = table_getFilteredRowModel(table)\n * ```\n */\nexport function table_getFilteredRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.filteredRowModel) {\n    table._rowModels.filteredRowModel =\n      table.options._rowModels?.filteredRowModel?.(table)\n  }\n\n  if (table.options.manualFiltering || !table._rowModels.filteredRowModel) {\n    return table.getPreFilteredRowModel()\n  }\n\n  return table._rowModels.filteredRowModel()\n}\n\n/**\n * Reads the row model immediately before grouping.\n *\n * Grouping runs after filtering, so this aliases `table.getFilteredRowModel()`.\n *\n * @example\n * ```ts\n * const rowsBeforeGrouping = table_getPreGroupedRowModel(table)\n * ```\n */\nexport function table_getPreGroupedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getFilteredRowModel()\n}\n\n/**\n * Resolves the row model after grouping has produced grouped and aggregated rows.\n *\n * When `manualGrouping` is enabled, or no grouped row-model factory was\n * registered, this returns the pre-grouped row model unchanged.\n *\n * @example\n * ```ts\n * const groupedRows = table_getGroupedRowModel(table)\n * ```\n */\nexport function table_getGroupedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.groupedRowModel) {\n    table._rowModels.groupedRowModel =\n      table.options._rowModels?.groupedRowModel?.(table)\n  }\n\n  if (table.options.manualGrouping || !table._rowModels.groupedRowModel) {\n    return table.getPreGroupedRowModel()\n  }\n\n  return table._rowModels.groupedRowModel()\n}\n\n/**\n * Reads the row model immediately before sorting.\n *\n * Sorting runs after grouping, so this aliases `table.getGroupedRowModel()`.\n *\n * @example\n * ```ts\n * const rowsBeforeSorting = table_getPreSortedRowModel(table)\n * ```\n */\nexport function table_getPreSortedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getGroupedRowModel()\n}\n\n/**\n * Resolves the row model after sorting has been applied.\n *\n * When `manualSorting` is enabled, or no sorted row-model factory was\n * registered, this returns the pre-sorted row model because sorted data is\n * expected to be supplied by the caller.\n *\n * @example\n * ```ts\n * const sortedRows = table_getSortedRowModel(table)\n * ```\n */\nexport function table_getSortedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.sortedRowModel) {\n    table._rowModels.sortedRowModel =\n      table.options._rowModels?.sortedRowModel?.(table)\n  }\n\n  if (table.options.manualSorting || !table._rowModels.sortedRowModel) {\n    return table.getPreSortedRowModel()\n  }\n\n  return table._rowModels.sortedRowModel()\n}\n\n/**\n * Reads the row model immediately before row expansion.\n *\n * Expansion runs after sorting, so this aliases `table.getSortedRowModel()`.\n *\n * @example\n * ```ts\n * const rowsBeforeExpansion = table_getPreExpandedRowModel(table)\n * ```\n */\nexport function table_getPreExpandedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getSortedRowModel()\n}\n\n/**\n * Resolves the row model after expanded rows have been flattened into view.\n *\n * When `manualExpanding` is enabled, or no expanded row-model factory was\n * registered, this returns the pre-expanded row model unchanged.\n *\n * @example\n * ```ts\n * const expandedRows = table_getExpandedRowModel(table)\n * ```\n */\nexport function table_getExpandedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.expandedRowModel) {\n    table._rowModels.expandedRowModel =\n      table.options._rowModels?.expandedRowModel?.(table)\n  }\n\n  if (table.options.manualExpanding || !table._rowModels.expandedRowModel) {\n    return table.getPreExpandedRowModel()\n  }\n\n  return table._rowModels.expandedRowModel()\n}\n\n/**\n * Reads the row model immediately before pagination.\n *\n * Pagination is the final built-in row-model stage, so this aliases\n * `table.getExpandedRowModel()`.\n *\n * @example\n * ```ts\n * const rowsBeforePagination = table_getPrePaginatedRowModel(table)\n * ```\n */\nexport function table_getPrePaginatedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getExpandedRowModel()\n}\n\n/**\n * Resolves the row model after pagination has sliced rows for the current page.\n *\n * When `manualPagination` is enabled, or no paginated row-model factory was\n * registered, this returns the pre-paginated row model because pagination is\n * expected to happen before data reaches the table.\n *\n * @example\n * ```ts\n * const pageRows = table_getPaginatedRowModel(table)\n * ```\n */\nexport function table_getPaginatedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.paginatedRowModel) {\n    table._rowModels.paginatedRowModel =\n      table.options._rowModels?.paginatedRowModel?.(table)\n  }\n\n  if (table.options.manualPagination || !table._rowModels.paginatedRowModel) {\n    return table.getPrePaginatedRowModel()\n  }\n\n  return table._rowModels.paginatedRowModel()\n}\n\n/**\n * Resolves the final row model consumed by renderers.\n *\n * This is the end of the built-in row-model pipeline: core -> filtering ->\n * grouping -> sorting -> expanding -> pagination.\n *\n * @example\n * ```ts\n * const visibleRows = table_getRowModel(table)\n * ```\n */\nexport function table_getRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getPaginatedRowModel()\n}\n"],"mappings":";;;;;;;;;;;;;;AAiBA,SAAgB,sBAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,cAAc;;EAClC,MAAM,WAAW,yCACf,MAAM,QAAQ,4GAAY,0HAAe,MAAM,KAC/CA,+CAAsC,CAAC,MAAM;;CAGjD,OAAO,MAAM,WAAW,cAAc;;;;;;;;;;;;;AAcxC,SAAgB,6BAGd,OAAqE;CACrE,OAAO,MAAM,iBAAiB;;;;;;;;;;;;;;AAehC,SAAgB,0BAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,kBAAkB;;EACtC,MAAM,WAAW,6CACf,MAAM,QAAQ,8GAAY,+HAAmB,MAAM;;CAGvD,IAAI,MAAM,QAAQ,mBAAmB,CAAC,MAAM,WAAW,kBACrD,OAAO,MAAM,wBAAwB;CAGvC,OAAO,MAAM,WAAW,kBAAkB;;;;;;;;;;;;AAa5C,SAAgB,4BAGd,OAAqE;CACrE,OAAO,MAAM,qBAAqB;;;;;;;;;;;;;AAcpC,SAAgB,yBAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,iBAAiB;;EACrC,MAAM,WAAW,4CACf,MAAM,QAAQ,8GAAY,8HAAkB,MAAM;;CAGtD,IAAI,MAAM,QAAQ,kBAAkB,CAAC,MAAM,WAAW,iBACpD,OAAO,MAAM,uBAAuB;CAGtC,OAAO,MAAM,WAAW,iBAAiB;;;;;;;;;;;;AAa3C,SAAgB,2BAGd,OAAqE;CACrE,OAAO,MAAM,oBAAoB;;;;;;;;;;;;;;AAenC,SAAgB,wBAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,gBAAgB;;EACpC,MAAM,WAAW,2CACf,MAAM,QAAQ,8GAAY,6HAAiB,MAAM;;CAGrD,IAAI,MAAM,QAAQ,iBAAiB,CAAC,MAAM,WAAW,gBACnD,OAAO,MAAM,sBAAsB;CAGrC,OAAO,MAAM,WAAW,gBAAgB;;;;;;;;;;;;AAa1C,SAAgB,6BAGd,OAAqE;CACrE,OAAO,MAAM,mBAAmB;;;;;;;;;;;;;AAclC,SAAgB,0BAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,kBAAkB;;EACtC,MAAM,WAAW,6CACf,MAAM,QAAQ,+GAAY,iIAAmB,MAAM;;CAGvD,IAAI,MAAM,QAAQ,mBAAmB,CAAC,MAAM,WAAW,kBACrD,OAAO,MAAM,wBAAwB;CAGvC,OAAO,MAAM,WAAW,kBAAkB;;;;;;;;;;;;;AAc5C,SAAgB,8BAGd,OAAqE;CACrE,OAAO,MAAM,qBAAqB;;;;;;;;;;;;;;AAepC,SAAgB,2BAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,mBAAmB;;EACvC,MAAM,WAAW,+CACf,MAAM,QAAQ,iHAAY,mIAAoB,MAAM;;CAGxD,IAAI,MAAM,QAAQ,oBAAoB,CAAC,MAAM,WAAW,mBACtD,OAAO,MAAM,yBAAyB;CAGxC,OAAO,MAAM,WAAW,mBAAmB;;;;;;;;;;;;;AAc7C,SAAgB,kBAGd,OAAqE;CACrE,OAAO,MAAM,sBAAsB"}
+{"version":3,"file":"coreRowModelsFeature.utils.cjs","names":["createCoreRowModel"],"sources":["../../../src/core/row-models/coreRowModelsFeature.utils.ts"],"sourcesContent":["import { createCoreRowModel } from './createCoreRowModel'\nimport type { Table_Internal } from '../../types/Table'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { RowData } from '../../types/type-utils'\nimport type { RowModel } from './coreRowModelsFeature.types'\n\n/**\n * Resolves the table's unmodified core row model.\n *\n * The factory is created once per table, either from `options._rowModels.coreRowModel`\n * or the built-in `createCoreRowModel()`, then reused for later calls.\n *\n * @example\n * ```ts\n * const coreRows = table_getCoreRowModel(table)\n * ```\n */\nexport function table_getCoreRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.coreRowModel) {\n    table._rowModels.coreRowModel =\n      table.options._rowModels?.coreRowModel?.(table) ??\n      createCoreRowModel<TFeatures, TData>()(table)\n  }\n\n  return table._rowModels.coreRowModel()\n}\n\n/**\n * Reads the row model immediately before column/global filtering.\n *\n * Filtering is the first derived row-model stage, so this currently aliases\n * `table.getCoreRowModel()`.\n *\n * @example\n * ```ts\n * const rowsBeforeFiltering = table_getPreFilteredRowModel(table)\n * ```\n */\nexport function table_getPreFilteredRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getCoreRowModel()\n}\n\n/**\n * Resolves the row model after column and global filtering.\n *\n * When `manualFiltering` is enabled, or no filtered row-model factory was\n * registered, this returns the pre-filtered row model because filtering is\n * expected to happen outside the table.\n *\n * @example\n * ```ts\n * const filteredRows = table_getFilteredRowModel(table)\n * ```\n */\nexport function table_getFilteredRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.filteredRowModel) {\n    table._rowModels.filteredRowModel =\n      table.options._rowModels?.filteredRowModel?.(table)\n  }\n\n  if (table.options.manualFiltering || !table._rowModels.filteredRowModel) {\n    return table.getPreFilteredRowModel()\n  }\n\n  return table._rowModels.filteredRowModel()\n}\n\n/**\n * Reads the row model immediately before grouping.\n *\n * Grouping runs after filtering, so this aliases `table.getFilteredRowModel()`.\n *\n * @example\n * ```ts\n * const rowsBeforeGrouping = table_getPreGroupedRowModel(table)\n * ```\n */\nexport function table_getPreGroupedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getFilteredRowModel()\n}\n\n/**\n * Resolves the row model after grouping has produced grouped and aggregated rows.\n *\n * When `manualGrouping` is enabled, or no grouped row-model factory was\n * registered, this returns the pre-grouped row model unchanged.\n *\n * @example\n * ```ts\n * const groupedRows = table_getGroupedRowModel(table)\n * ```\n */\nexport function table_getGroupedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.groupedRowModel) {\n    table._rowModels.groupedRowModel =\n      table.options._rowModels?.groupedRowModel?.(table)\n  }\n\n  if (table.options.manualGrouping || !table._rowModels.groupedRowModel) {\n    return table.getPreGroupedRowModel()\n  }\n\n  return table._rowModels.groupedRowModel()\n}\n\n/**\n * Reads the row model immediately before sorting.\n *\n * Sorting runs after grouping, so this aliases `table.getGroupedRowModel()`.\n *\n * @example\n * ```ts\n * const rowsBeforeSorting = table_getPreSortedRowModel(table)\n * ```\n */\nexport function table_getPreSortedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getGroupedRowModel()\n}\n\n/**\n * Resolves the row model after sorting has been applied.\n *\n * When `manualSorting` is enabled, or no sorted row-model factory was\n * registered, this returns the pre-sorted row model because sorted data is\n * expected to be supplied by the caller.\n *\n * @example\n * ```ts\n * const sortedRows = table_getSortedRowModel(table)\n * ```\n */\nexport function table_getSortedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.sortedRowModel) {\n    table._rowModels.sortedRowModel =\n      table.options._rowModels?.sortedRowModel?.(table)\n  }\n\n  if (table.options.manualSorting || !table._rowModels.sortedRowModel) {\n    return table.getPreSortedRowModel()\n  }\n\n  return table._rowModels.sortedRowModel()\n}\n\n/**\n * Reads the row model immediately before row expansion.\n *\n * Expansion runs after sorting, so this aliases `table.getSortedRowModel()`.\n *\n * @example\n * ```ts\n * const rowsBeforeExpansion = table_getPreExpandedRowModel(table)\n * ```\n */\nexport function table_getPreExpandedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getSortedRowModel()\n}\n\n/**\n * Resolves the row model after expanded rows have been flattened into view.\n *\n * When `manualExpanding` is enabled, or no expanded row-model factory was\n * registered, this returns the pre-expanded row model unchanged.\n *\n * @example\n * ```ts\n * const expandedRows = table_getExpandedRowModel(table)\n * ```\n */\nexport function table_getExpandedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.expandedRowModel) {\n    table._rowModels.expandedRowModel =\n      table.options._rowModels?.expandedRowModel?.(table)\n  }\n\n  if (table.options.manualExpanding || !table._rowModels.expandedRowModel) {\n    return table.getPreExpandedRowModel()\n  }\n\n  return table._rowModels.expandedRowModel()\n}\n\n/**\n * Reads the row model immediately before pagination.\n *\n * Pagination is the final built-in row-model stage, so this aliases\n * `table.getExpandedRowModel()`.\n *\n * @example\n * ```ts\n * const rowsBeforePagination = table_getPrePaginatedRowModel(table)\n * ```\n */\nexport function table_getPrePaginatedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getExpandedRowModel()\n}\n\n/**\n * Resolves the row model after pagination has sliced rows for the current page.\n *\n * When `manualPagination` is enabled, or no paginated row-model factory was\n * registered, this returns the pre-paginated row model because pagination is\n * expected to happen before data reaches the table.\n *\n * @example\n * ```ts\n * const pageRows = table_getPaginatedRowModel(table)\n * ```\n */\nexport function table_getPaginatedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.paginatedRowModel) {\n    table._rowModels.paginatedRowModel =\n      table.options._rowModels?.paginatedRowModel?.(table)\n  }\n\n  if (table.options.manualPagination || !table._rowModels.paginatedRowModel) {\n    return table.getPrePaginatedRowModel()\n  }\n\n  return table._rowModels.paginatedRowModel()\n}\n\n/**\n * Resolves the final row model consumed by renderers.\n *\n * This is the end of the built-in row-model pipeline: core -> filtering ->\n * grouping -> sorting -> expanding -> pagination.\n *\n * @example\n * ```ts\n * const visibleRows = table_getRowModel(table)\n * ```\n */\nexport function table_getRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getPaginatedRowModel()\n}\n"],"mappings":";;;;;;;;;;;;;;AAiBA,SAAgB,sBAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,cAAc;;EAClC,MAAM,WAAW,yCACf,MAAM,QAAQ,4GAAY,0HAAe,KAAK,MAC9CA,8CAAqC,EAAE,KAAK;CAChD;CAEA,OAAO,MAAM,WAAW,aAAa;AACvC;;;;;;;;;;;;AAaA,SAAgB,6BAGd,OAAqE;CACrE,OAAO,MAAM,gBAAgB;AAC/B;;;;;;;;;;;;;AAcA,SAAgB,0BAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,kBAAkB;;EACtC,MAAM,WAAW,6CACf,MAAM,QAAQ,8GAAY,+HAAmB,KAAK;CACtD;CAEA,IAAI,MAAM,QAAQ,mBAAmB,CAAC,MAAM,WAAW,kBACrD,OAAO,MAAM,uBAAuB;CAGtC,OAAO,MAAM,WAAW,iBAAiB;AAC3C;;;;;;;;;;;AAYA,SAAgB,4BAGd,OAAqE;CACrE,OAAO,MAAM,oBAAoB;AACnC;;;;;;;;;;;;AAaA,SAAgB,yBAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,iBAAiB;;EACrC,MAAM,WAAW,4CACf,MAAM,QAAQ,8GAAY,8HAAkB,KAAK;CACrD;CAEA,IAAI,MAAM,QAAQ,kBAAkB,CAAC,MAAM,WAAW,iBACpD,OAAO,MAAM,sBAAsB;CAGrC,OAAO,MAAM,WAAW,gBAAgB;AAC1C;;;;;;;;;;;AAYA,SAAgB,2BAGd,OAAqE;CACrE,OAAO,MAAM,mBAAmB;AAClC;;;;;;;;;;;;;AAcA,SAAgB,wBAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,gBAAgB;;EACpC,MAAM,WAAW,2CACf,MAAM,QAAQ,8GAAY,6HAAiB,KAAK;CACpD;CAEA,IAAI,MAAM,QAAQ,iBAAiB,CAAC,MAAM,WAAW,gBACnD,OAAO,MAAM,qBAAqB;CAGpC,OAAO,MAAM,WAAW,eAAe;AACzC;;;;;;;;;;;AAYA,SAAgB,6BAGd,OAAqE;CACrE,OAAO,MAAM,kBAAkB;AACjC;;;;;;;;;;;;AAaA,SAAgB,0BAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,kBAAkB;;EACtC,MAAM,WAAW,6CACf,MAAM,QAAQ,+GAAY,iIAAmB,KAAK;CACtD;CAEA,IAAI,MAAM,QAAQ,mBAAmB,CAAC,MAAM,WAAW,kBACrD,OAAO,MAAM,uBAAuB;CAGtC,OAAO,MAAM,WAAW,iBAAiB;AAC3C;;;;;;;;;;;;AAaA,SAAgB,8BAGd,OAAqE;CACrE,OAAO,MAAM,oBAAoB;AACnC;;;;;;;;;;;;;AAcA,SAAgB,2BAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,mBAAmB;;EACvC,MAAM,WAAW,+CACf,MAAM,QAAQ,iHAAY,mIAAoB,KAAK;CACvD;CAEA,IAAI,MAAM,QAAQ,oBAAoB,CAAC,MAAM,WAAW,mBACtD,OAAO,MAAM,wBAAwB;CAGvC,OAAO,MAAM,WAAW,kBAAkB;AAC5C;;;;;;;;;;;;AAaA,SAAgB,kBAGd,OAAqE;CACrE,OAAO,MAAM,qBAAqB;AACpC"}

package/dist/core/row-models/coreRowModelsFeature.utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"coreRowModelsFeature.utils.js","names":[],"sources":["../../../src/core/row-models/coreRowModelsFeature.utils.ts"],"sourcesContent":["import { createCoreRowModel } from './createCoreRowModel'\nimport type { Table_Internal } from '../../types/Table'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { RowData } from '../../types/type-utils'\nimport type { RowModel } from './coreRowModelsFeature.types'\n\n/**\n * Resolves the table's unmodified core row model.\n *\n * The factory is created once per table, either from `options._rowModels.coreRowModel`\n * or the built-in `createCoreRowModel()`, then reused for later calls.\n *\n * @example\n * ```ts\n * const coreRows = table_getCoreRowModel(table)\n * ```\n */\nexport function table_getCoreRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.coreRowModel) {\n    table._rowModels.coreRowModel =\n      table.options._rowModels?.coreRowModel?.(table) ??\n      createCoreRowModel<TFeatures, TData>()(table)\n  }\n\n  return table._rowModels.coreRowModel()\n}\n\n/**\n * Reads the row model immediately before column/global filtering.\n *\n * Filtering is the first derived row-model stage, so this currently aliases\n * `table.getCoreRowModel()`.\n *\n * @example\n * ```ts\n * const rowsBeforeFiltering = table_getPreFilteredRowModel(table)\n * ```\n */\nexport function table_getPreFilteredRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getCoreRowModel()\n}\n\n/**\n * Resolves the row model after column and global filtering.\n *\n * When `manualFiltering` is enabled, or no filtered row-model factory was\n * registered, this returns the pre-filtered row model because filtering is\n * expected to happen outside the table.\n *\n * @example\n * ```ts\n * const filteredRows = table_getFilteredRowModel(table)\n * ```\n */\nexport function table_getFilteredRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.filteredRowModel) {\n    table._rowModels.filteredRowModel =\n      table.options._rowModels?.filteredRowModel?.(table)\n  }\n\n  if (table.options.manualFiltering || !table._rowModels.filteredRowModel) {\n    return table.getPreFilteredRowModel()\n  }\n\n  return table._rowModels.filteredRowModel()\n}\n\n/**\n * Reads the row model immediately before grouping.\n *\n * Grouping runs after filtering, so this aliases `table.getFilteredRowModel()`.\n *\n * @example\n * ```ts\n * const rowsBeforeGrouping = table_getPreGroupedRowModel(table)\n * ```\n */\nexport function table_getPreGroupedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getFilteredRowModel()\n}\n\n/**\n * Resolves the row model after grouping has produced grouped and aggregated rows.\n *\n * When `manualGrouping` is enabled, or no grouped row-model factory was\n * registered, this returns the pre-grouped row model unchanged.\n *\n * @example\n * ```ts\n * const groupedRows = table_getGroupedRowModel(table)\n * ```\n */\nexport function table_getGroupedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.groupedRowModel) {\n    table._rowModels.groupedRowModel =\n      table.options._rowModels?.groupedRowModel?.(table)\n  }\n\n  if (table.options.manualGrouping || !table._rowModels.groupedRowModel) {\n    return table.getPreGroupedRowModel()\n  }\n\n  return table._rowModels.groupedRowModel()\n}\n\n/**\n * Reads the row model immediately before sorting.\n *\n * Sorting runs after grouping, so this aliases `table.getGroupedRowModel()`.\n *\n * @example\n * ```ts\n * const rowsBeforeSorting = table_getPreSortedRowModel(table)\n * ```\n */\nexport function table_getPreSortedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getGroupedRowModel()\n}\n\n/**\n * Resolves the row model after sorting has been applied.\n *\n * When `manualSorting` is enabled, or no sorted row-model factory was\n * registered, this returns the pre-sorted row model because sorted data is\n * expected to be supplied by the caller.\n *\n * @example\n * ```ts\n * const sortedRows = table_getSortedRowModel(table)\n * ```\n */\nexport function table_getSortedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.sortedRowModel) {\n    table._rowModels.sortedRowModel =\n      table.options._rowModels?.sortedRowModel?.(table)\n  }\n\n  if (table.options.manualSorting || !table._rowModels.sortedRowModel) {\n    return table.getPreSortedRowModel()\n  }\n\n  return table._rowModels.sortedRowModel()\n}\n\n/**\n * Reads the row model immediately before row expansion.\n *\n * Expansion runs after sorting, so this aliases `table.getSortedRowModel()`.\n *\n * @example\n * ```ts\n * const rowsBeforeExpansion = table_getPreExpandedRowModel(table)\n * ```\n */\nexport function table_getPreExpandedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getSortedRowModel()\n}\n\n/**\n * Resolves the row model after expanded rows have been flattened into view.\n *\n * When `manualExpanding` is enabled, or no expanded row-model factory was\n * registered, this returns the pre-expanded row model unchanged.\n *\n * @example\n * ```ts\n * const expandedRows = table_getExpandedRowModel(table)\n * ```\n */\nexport function table_getExpandedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.expandedRowModel) {\n    table._rowModels.expandedRowModel =\n      table.options._rowModels?.expandedRowModel?.(table)\n  }\n\n  if (table.options.manualExpanding || !table._rowModels.expandedRowModel) {\n    return table.getPreExpandedRowModel()\n  }\n\n  return table._rowModels.expandedRowModel()\n}\n\n/**\n * Reads the row model immediately before pagination.\n *\n * Pagination is the final built-in row-model stage, so this aliases\n * `table.getExpandedRowModel()`.\n *\n * @example\n * ```ts\n * const rowsBeforePagination = table_getPrePaginatedRowModel(table)\n * ```\n */\nexport function table_getPrePaginatedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getExpandedRowModel()\n}\n\n/**\n * Resolves the row model after pagination has sliced rows for the current page.\n *\n * When `manualPagination` is enabled, or no paginated row-model factory was\n * registered, this returns the pre-paginated row model because pagination is\n * expected to happen before data reaches the table.\n *\n * @example\n * ```ts\n * const pageRows = table_getPaginatedRowModel(table)\n * ```\n */\nexport function table_getPaginatedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.paginatedRowModel) {\n    table._rowModels.paginatedRowModel =\n      table.options._rowModels?.paginatedRowModel?.(table)\n  }\n\n  if (table.options.manualPagination || !table._rowModels.paginatedRowModel) {\n    return table.getPrePaginatedRowModel()\n  }\n\n  return table._rowModels.paginatedRowModel()\n}\n\n/**\n * Resolves the final row model consumed by renderers.\n *\n * This is the end of the built-in row-model pipeline: core -> filtering ->\n * grouping -> sorting -> expanding -> pagination.\n *\n * @example\n * ```ts\n * const visibleRows = table_getRowModel(table)\n * ```\n */\nexport function table_getRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getPaginatedRowModel()\n}\n"],"mappings":";;;;;;;;;;;;;;AAiBA,SAAgB,sBAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,cAAc;;EAClC,MAAM,WAAW,yCACf,MAAM,QAAQ,4GAAY,0HAAe,MAAM,KAC/C,oBAAsC,CAAC,MAAM;;CAGjD,OAAO,MAAM,WAAW,cAAc;;;;;;;;;;;;;AAcxC,SAAgB,6BAGd,OAAqE;CACrE,OAAO,MAAM,iBAAiB;;;;;;;;;;;;;;AAehC,SAAgB,0BAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,kBAAkB;;EACtC,MAAM,WAAW,6CACf,MAAM,QAAQ,8GAAY,+HAAmB,MAAM;;CAGvD,IAAI,MAAM,QAAQ,mBAAmB,CAAC,MAAM,WAAW,kBACrD,OAAO,MAAM,wBAAwB;CAGvC,OAAO,MAAM,WAAW,kBAAkB;;;;;;;;;;;;AAa5C,SAAgB,4BAGd,OAAqE;CACrE,OAAO,MAAM,qBAAqB;;;;;;;;;;;;;AAcpC,SAAgB,yBAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,iBAAiB;;EACrC,MAAM,WAAW,4CACf,MAAM,QAAQ,8GAAY,8HAAkB,MAAM;;CAGtD,IAAI,MAAM,QAAQ,kBAAkB,CAAC,MAAM,WAAW,iBACpD,OAAO,MAAM,uBAAuB;CAGtC,OAAO,MAAM,WAAW,iBAAiB;;;;;;;;;;;;AAa3C,SAAgB,2BAGd,OAAqE;CACrE,OAAO,MAAM,oBAAoB;;;;;;;;;;;;;;AAenC,SAAgB,wBAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,gBAAgB;;EACpC,MAAM,WAAW,2CACf,MAAM,QAAQ,8GAAY,6HAAiB,MAAM;;CAGrD,IAAI,MAAM,QAAQ,iBAAiB,CAAC,MAAM,WAAW,gBACnD,OAAO,MAAM,sBAAsB;CAGrC,OAAO,MAAM,WAAW,gBAAgB;;;;;;;;;;;;AAa1C,SAAgB,6BAGd,OAAqE;CACrE,OAAO,MAAM,mBAAmB;;;;;;;;;;;;;AAclC,SAAgB,0BAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,kBAAkB;;EACtC,MAAM,WAAW,6CACf,MAAM,QAAQ,+GAAY,iIAAmB,MAAM;;CAGvD,IAAI,MAAM,QAAQ,mBAAmB,CAAC,MAAM,WAAW,kBACrD,OAAO,MAAM,wBAAwB;CAGvC,OAAO,MAAM,WAAW,kBAAkB;;;;;;;;;;;;;AAc5C,SAAgB,8BAGd,OAAqE;CACrE,OAAO,MAAM,qBAAqB;;;;;;;;;;;;;;AAepC,SAAgB,2BAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,mBAAmB;;EACvC,MAAM,WAAW,+CACf,MAAM,QAAQ,iHAAY,mIAAoB,MAAM;;CAGxD,IAAI,MAAM,QAAQ,oBAAoB,CAAC,MAAM,WAAW,mBACtD,OAAO,MAAM,yBAAyB;CAGxC,OAAO,MAAM,WAAW,mBAAmB;;;;;;;;;;;;;AAc7C,SAAgB,kBAGd,OAAqE;CACrE,OAAO,MAAM,sBAAsB"}
+{"version":3,"file":"coreRowModelsFeature.utils.js","names":[],"sources":["../../../src/core/row-models/coreRowModelsFeature.utils.ts"],"sourcesContent":["import { createCoreRowModel } from './createCoreRowModel'\nimport type { Table_Internal } from '../../types/Table'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { RowData } from '../../types/type-utils'\nimport type { RowModel } from './coreRowModelsFeature.types'\n\n/**\n * Resolves the table's unmodified core row model.\n *\n * The factory is created once per table, either from `options._rowModels.coreRowModel`\n * or the built-in `createCoreRowModel()`, then reused for later calls.\n *\n * @example\n * ```ts\n * const coreRows = table_getCoreRowModel(table)\n * ```\n */\nexport function table_getCoreRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.coreRowModel) {\n    table._rowModels.coreRowModel =\n      table.options._rowModels?.coreRowModel?.(table) ??\n      createCoreRowModel<TFeatures, TData>()(table)\n  }\n\n  return table._rowModels.coreRowModel()\n}\n\n/**\n * Reads the row model immediately before column/global filtering.\n *\n * Filtering is the first derived row-model stage, so this currently aliases\n * `table.getCoreRowModel()`.\n *\n * @example\n * ```ts\n * const rowsBeforeFiltering = table_getPreFilteredRowModel(table)\n * ```\n */\nexport function table_getPreFilteredRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getCoreRowModel()\n}\n\n/**\n * Resolves the row model after column and global filtering.\n *\n * When `manualFiltering` is enabled, or no filtered row-model factory was\n * registered, this returns the pre-filtered row model because filtering is\n * expected to happen outside the table.\n *\n * @example\n * ```ts\n * const filteredRows = table_getFilteredRowModel(table)\n * ```\n */\nexport function table_getFilteredRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.filteredRowModel) {\n    table._rowModels.filteredRowModel =\n      table.options._rowModels?.filteredRowModel?.(table)\n  }\n\n  if (table.options.manualFiltering || !table._rowModels.filteredRowModel) {\n    return table.getPreFilteredRowModel()\n  }\n\n  return table._rowModels.filteredRowModel()\n}\n\n/**\n * Reads the row model immediately before grouping.\n *\n * Grouping runs after filtering, so this aliases `table.getFilteredRowModel()`.\n *\n * @example\n * ```ts\n * const rowsBeforeGrouping = table_getPreGroupedRowModel(table)\n * ```\n */\nexport function table_getPreGroupedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getFilteredRowModel()\n}\n\n/**\n * Resolves the row model after grouping has produced grouped and aggregated rows.\n *\n * When `manualGrouping` is enabled, or no grouped row-model factory was\n * registered, this returns the pre-grouped row model unchanged.\n *\n * @example\n * ```ts\n * const groupedRows = table_getGroupedRowModel(table)\n * ```\n */\nexport function table_getGroupedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.groupedRowModel) {\n    table._rowModels.groupedRowModel =\n      table.options._rowModels?.groupedRowModel?.(table)\n  }\n\n  if (table.options.manualGrouping || !table._rowModels.groupedRowModel) {\n    return table.getPreGroupedRowModel()\n  }\n\n  return table._rowModels.groupedRowModel()\n}\n\n/**\n * Reads the row model immediately before sorting.\n *\n * Sorting runs after grouping, so this aliases `table.getGroupedRowModel()`.\n *\n * @example\n * ```ts\n * const rowsBeforeSorting = table_getPreSortedRowModel(table)\n * ```\n */\nexport function table_getPreSortedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getGroupedRowModel()\n}\n\n/**\n * Resolves the row model after sorting has been applied.\n *\n * When `manualSorting` is enabled, or no sorted row-model factory was\n * registered, this returns the pre-sorted row model because sorted data is\n * expected to be supplied by the caller.\n *\n * @example\n * ```ts\n * const sortedRows = table_getSortedRowModel(table)\n * ```\n */\nexport function table_getSortedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.sortedRowModel) {\n    table._rowModels.sortedRowModel =\n      table.options._rowModels?.sortedRowModel?.(table)\n  }\n\n  if (table.options.manualSorting || !table._rowModels.sortedRowModel) {\n    return table.getPreSortedRowModel()\n  }\n\n  return table._rowModels.sortedRowModel()\n}\n\n/**\n * Reads the row model immediately before row expansion.\n *\n * Expansion runs after sorting, so this aliases `table.getSortedRowModel()`.\n *\n * @example\n * ```ts\n * const rowsBeforeExpansion = table_getPreExpandedRowModel(table)\n * ```\n */\nexport function table_getPreExpandedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getSortedRowModel()\n}\n\n/**\n * Resolves the row model after expanded rows have been flattened into view.\n *\n * When `manualExpanding` is enabled, or no expanded row-model factory was\n * registered, this returns the pre-expanded row model unchanged.\n *\n * @example\n * ```ts\n * const expandedRows = table_getExpandedRowModel(table)\n * ```\n */\nexport function table_getExpandedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.expandedRowModel) {\n    table._rowModels.expandedRowModel =\n      table.options._rowModels?.expandedRowModel?.(table)\n  }\n\n  if (table.options.manualExpanding || !table._rowModels.expandedRowModel) {\n    return table.getPreExpandedRowModel()\n  }\n\n  return table._rowModels.expandedRowModel()\n}\n\n/**\n * Reads the row model immediately before pagination.\n *\n * Pagination is the final built-in row-model stage, so this aliases\n * `table.getExpandedRowModel()`.\n *\n * @example\n * ```ts\n * const rowsBeforePagination = table_getPrePaginatedRowModel(table)\n * ```\n */\nexport function table_getPrePaginatedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getExpandedRowModel()\n}\n\n/**\n * Resolves the row model after pagination has sliced rows for the current page.\n *\n * When `manualPagination` is enabled, or no paginated row-model factory was\n * registered, this returns the pre-paginated row model because pagination is\n * expected to happen before data reaches the table.\n *\n * @example\n * ```ts\n * const pageRows = table_getPaginatedRowModel(table)\n * ```\n */\nexport function table_getPaginatedRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  if (!table._rowModels.paginatedRowModel) {\n    table._rowModels.paginatedRowModel =\n      table.options._rowModels?.paginatedRowModel?.(table)\n  }\n\n  if (table.options.manualPagination || !table._rowModels.paginatedRowModel) {\n    return table.getPrePaginatedRowModel()\n  }\n\n  return table._rowModels.paginatedRowModel()\n}\n\n/**\n * Resolves the final row model consumed by renderers.\n *\n * This is the end of the built-in row-model pipeline: core -> filtering ->\n * grouping -> sorting -> expanding -> pagination.\n *\n * @example\n * ```ts\n * const visibleRows = table_getRowModel(table)\n * ```\n */\nexport function table_getRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): RowModel<TFeatures, TData> {\n  return table.getPaginatedRowModel()\n}\n"],"mappings":";;;;;;;;;;;;;;AAiBA,SAAgB,sBAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,cAAc;;EAClC,MAAM,WAAW,yCACf,MAAM,QAAQ,4GAAY,0HAAe,KAAK,MAC9C,mBAAqC,EAAE,KAAK;CAChD;CAEA,OAAO,MAAM,WAAW,aAAa;AACvC;;;;;;;;;;;;AAaA,SAAgB,6BAGd,OAAqE;CACrE,OAAO,MAAM,gBAAgB;AAC/B;;;;;;;;;;;;;AAcA,SAAgB,0BAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,kBAAkB;;EACtC,MAAM,WAAW,6CACf,MAAM,QAAQ,8GAAY,+HAAmB,KAAK;CACtD;CAEA,IAAI,MAAM,QAAQ,mBAAmB,CAAC,MAAM,WAAW,kBACrD,OAAO,MAAM,uBAAuB;CAGtC,OAAO,MAAM,WAAW,iBAAiB;AAC3C;;;;;;;;;;;AAYA,SAAgB,4BAGd,OAAqE;CACrE,OAAO,MAAM,oBAAoB;AACnC;;;;;;;;;;;;AAaA,SAAgB,yBAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,iBAAiB;;EACrC,MAAM,WAAW,4CACf,MAAM,QAAQ,8GAAY,8HAAkB,KAAK;CACrD;CAEA,IAAI,MAAM,QAAQ,kBAAkB,CAAC,MAAM,WAAW,iBACpD,OAAO,MAAM,sBAAsB;CAGrC,OAAO,MAAM,WAAW,gBAAgB;AAC1C;;;;;;;;;;;AAYA,SAAgB,2BAGd,OAAqE;CACrE,OAAO,MAAM,mBAAmB;AAClC;;;;;;;;;;;;;AAcA,SAAgB,wBAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,gBAAgB;;EACpC,MAAM,WAAW,2CACf,MAAM,QAAQ,8GAAY,6HAAiB,KAAK;CACpD;CAEA,IAAI,MAAM,QAAQ,iBAAiB,CAAC,MAAM,WAAW,gBACnD,OAAO,MAAM,qBAAqB;CAGpC,OAAO,MAAM,WAAW,eAAe;AACzC;;;;;;;;;;;AAYA,SAAgB,6BAGd,OAAqE;CACrE,OAAO,MAAM,kBAAkB;AACjC;;;;;;;;;;;;AAaA,SAAgB,0BAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,kBAAkB;;EACtC,MAAM,WAAW,6CACf,MAAM,QAAQ,+GAAY,iIAAmB,KAAK;CACtD;CAEA,IAAI,MAAM,QAAQ,mBAAmB,CAAC,MAAM,WAAW,kBACrD,OAAO,MAAM,uBAAuB;CAGtC,OAAO,MAAM,WAAW,iBAAiB;AAC3C;;;;;;;;;;;;AAaA,SAAgB,8BAGd,OAAqE;CACrE,OAAO,MAAM,oBAAoB;AACnC;;;;;;;;;;;;;AAcA,SAAgB,2BAGd,OAAqE;CACrE,IAAI,CAAC,MAAM,WAAW,mBAAmB;;EACvC,MAAM,WAAW,+CACf,MAAM,QAAQ,iHAAY,mIAAoB,KAAK;CACvD;CAEA,IAAI,MAAM,QAAQ,oBAAoB,CAAC,MAAM,WAAW,mBACtD,OAAO,MAAM,wBAAwB;CAGvC,OAAO,MAAM,WAAW,kBAAkB;AAC5C;;;;;;;;;;;;AAaA,SAAgB,kBAGd,OAAqE;CACrE,OAAO,MAAM,qBAAqB;AACpC"}

package/dist/core/row-models/createCoreRowModel.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"createCoreRowModel.cjs","names":["tableMemo","table_autoResetPageIndex","constructRow"],"sources":["../../../src/core/row-models/createCoreRowModel.ts"],"sourcesContent":["import { constructRow } from '../rows/constructRow'\nimport { tableMemo } from '../../utils'\nimport { table_autoResetPageIndex } from '../../features/row-pagination/rowPaginationFeature.utils'\nimport type { Table, Table_Internal } from '../../types/Table'\nimport type { RowModel } from './coreRowModelsFeature.types'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { Row } from '../../types/Row'\nimport type { RowData } from '../../types/type-utils'\n\n/**\n * Creates a memoized core row model factory.\n *\n * The factory reads the relevant table state atoms and options, then returns a row model function used by the table row-model pipeline.\n */\nexport function createCoreRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(): (table: Table<TFeatures, TData>) => () => RowModel<TFeatures, TData> {\n  return (_table) => {\n    const table: Table_Internal<TFeatures, TData> = _table\n    return tableMemo({\n      feature: 'coreRowModelsFeature',\n      table,\n      fnName: 'table.getCoreRowModel',\n      memoDeps: () => [table.options.data],\n      fn: () => _createCoreRowModel(table, table.options.data),\n      onAfterUpdate: () => table_autoResetPageIndex(table),\n    })\n  }\n}\n\nfunction _createCoreRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  table: Table_Internal<TFeatures, TData>,\n  data: ReadonlyArray<TData>,\n): {\n  rows: Array<Row<TFeatures, TData>>\n  flatRows: Array<Row<TFeatures, TData>>\n  rowsById: Record<string, Row<TFeatures, TData>>\n} {\n  const rowModel: RowModel<TFeatures, TData> = {\n    rows: [],\n    flatRows: [],\n    rowsById: {},\n  }\n\n  const accessRows = (\n    originalRows: ReadonlyArray<TData>,\n    depth = 0,\n    parentRow?: Row<TFeatures, TData>,\n  ): Array<Row<TFeatures, TData>> => {\n    const rows = [] as Array<Row<TFeatures, TData>>\n\n    for (let i = 0; i < originalRows.length; i++) {\n      const originalRow = originalRows[i]!\n      // Make the row\n      const row = constructRow(\n        table,\n        table.getRowId(originalRow, i, parentRow),\n        originalRow,\n        i,\n        depth,\n        undefined,\n        parentRow?.id,\n      )\n\n      // Keep track of every row in a flat array\n      rowModel.flatRows.push(row)\n      // Also keep track of every row by its ID\n      rowModel.rowsById[row.id] = row\n      // Push table row into parent\n      rows.push(row)\n\n      // Get the original subrows\n      if (table.options.getSubRows) {\n        row.originalSubRows = table.options.getSubRows(originalRow, i)\n\n        // Then recursively access them\n        if (row.originalSubRows?.length) {\n          row.subRows = accessRows(row.originalSubRows, depth + 1, row)\n        }\n      }\n    }\n\n    return rows\n  }\n\n  rowModel.rows = accessRows(data)\n\n  return rowModel\n}\n"],"mappings":";;;;;;;;;;AAcA,SAAgB,qBAG0D;CACxE,QAAQ,WAAW;EACjB,MAAM,QAA0C;EAChD,OAAOA,wBAAU;GACf,SAAS;GACT;GACA,QAAQ;GACR,gBAAgB,CAAC,MAAM,QAAQ,KAAK;GACpC,UAAU,oBAAoB,OAAO,MAAM,QAAQ,KAAK;GACxD,qBAAqBC,4DAAyB,MAAM;GACrD,CAAC;;;AAIN,SAAS,oBAIP,OACA,MAKA;CACA,MAAM,WAAuC;EAC3C,MAAM,EAAE;EACR,UAAU,EAAE;EACZ,UAAU,EAAE;EACb;CAED,MAAM,cACJ,cACA,QAAQ,GACR,cACiC;EACjC,MAAM,OAAO,EAAE;EAEf,KAAK,IAAI,IAAI,GAAG,IAAI,aAAa,QAAQ,KAAK;GAC5C,MAAM,cAAc,aAAa;GAEjC,MAAM,MAAMC,kCACV,OACA,MAAM,SAAS,aAAa,GAAG,UAAU,EACzC,aACA,GACA,OACA,8DACA,UAAW,GACZ;GAGD,SAAS,SAAS,KAAK,IAAI;GAE3B,SAAS,SAAS,IAAI,MAAM;GAE5B,KAAK,KAAK,IAAI;GAGd,IAAI,MAAM,QAAQ,YAAY;;IAC5B,IAAI,kBAAkB,MAAM,QAAQ,WAAW,aAAa,EAAE;IAG9D,4BAAI,IAAI,6FAAiB,QACvB,IAAI,UAAU,WAAW,IAAI,iBAAiB,QAAQ,GAAG,IAAI;;;EAKnE,OAAO;;CAGT,SAAS,OAAO,WAAW,KAAK;CAEhC,OAAO"}
+{"version":3,"file":"createCoreRowModel.cjs","names":["tableMemo","table_autoResetPageIndex","constructRow"],"sources":["../../../src/core/row-models/createCoreRowModel.ts"],"sourcesContent":["import { constructRow } from '../rows/constructRow'\nimport { tableMemo } from '../../utils'\nimport { table_autoResetPageIndex } from '../../features/row-pagination/rowPaginationFeature.utils'\nimport type { Table, Table_Internal } from '../../types/Table'\nimport type { RowModel } from './coreRowModelsFeature.types'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { Row } from '../../types/Row'\nimport type { RowData } from '../../types/type-utils'\n\n/**\n * Creates a memoized core row model factory.\n *\n * The factory reads the relevant table state atoms and options, then returns a row model function used by the table row-model pipeline.\n */\nexport function createCoreRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(): (table: Table<TFeatures, TData>) => () => RowModel<TFeatures, TData> {\n  return (_table) => {\n    const table: Table_Internal<TFeatures, TData> = _table\n    return tableMemo({\n      feature: 'coreRowModelsFeature',\n      table,\n      fnName: 'table.getCoreRowModel',\n      memoDeps: () => [table.options.data],\n      fn: () => _createCoreRowModel(table, table.options.data),\n      onAfterUpdate: () => table_autoResetPageIndex(table),\n    })\n  }\n}\n\nfunction _createCoreRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  table: Table_Internal<TFeatures, TData>,\n  data: ReadonlyArray<TData>,\n): {\n  rows: Array<Row<TFeatures, TData>>\n  flatRows: Array<Row<TFeatures, TData>>\n  rowsById: Record<string, Row<TFeatures, TData>>\n} {\n  const rowModel: RowModel<TFeatures, TData> = {\n    rows: [],\n    flatRows: [],\n    rowsById: {},\n  }\n\n  const accessRows = (\n    originalRows: ReadonlyArray<TData>,\n    depth = 0,\n    parentRow?: Row<TFeatures, TData>,\n  ): Array<Row<TFeatures, TData>> => {\n    const rows = [] as Array<Row<TFeatures, TData>>\n\n    for (let i = 0; i < originalRows.length; i++) {\n      const originalRow = originalRows[i]!\n      // Make the row\n      const row = constructRow(\n        table,\n        table.getRowId(originalRow, i, parentRow),\n        originalRow,\n        i,\n        depth,\n        undefined,\n        parentRow?.id,\n      )\n\n      // Keep track of every row in a flat array\n      rowModel.flatRows.push(row)\n      // Also keep track of every row by its ID\n      rowModel.rowsById[row.id] = row\n      // Push table row into parent\n      rows.push(row)\n\n      // Get the original subrows\n      if (table.options.getSubRows) {\n        row.originalSubRows = table.options.getSubRows(originalRow, i)\n\n        // Then recursively access them\n        if (row.originalSubRows?.length) {\n          row.subRows = accessRows(row.originalSubRows, depth + 1, row)\n        }\n      }\n    }\n\n    return rows\n  }\n\n  rowModel.rows = accessRows(data)\n\n  return rowModel\n}\n"],"mappings":";;;;;;;;;;AAcA,SAAgB,qBAG0D;CACxE,QAAQ,WAAW;EACjB,MAAM,QAA0C;EAChD,OAAOA,wBAAU;GACf,SAAS;GACT;GACA,QAAQ;GACR,gBAAgB,CAAC,MAAM,QAAQ,IAAI;GACnC,UAAU,oBAAoB,OAAO,MAAM,QAAQ,IAAI;GACvD,qBAAqBC,4DAAyB,KAAK;EACrD,CAAC;CACH;AACF;AAEA,SAAS,oBAIP,OACA,MAKA;CACA,MAAM,WAAuC;EAC3C,MAAM,CAAC;EACP,UAAU,CAAC;EACX,UAAU,CAAC;CACb;CAEA,MAAM,cACJ,cACA,QAAQ,GACR,cACiC;EACjC,MAAM,OAAO,CAAC;EAEd,KAAK,IAAI,IAAI,GAAG,IAAI,aAAa,QAAQ,KAAK;GAC5C,MAAM,cAAc,aAAa;GAEjC,MAAM,MAAMC,kCACV,OACA,MAAM,SAAS,aAAa,GAAG,SAAS,GACxC,aACA,GACA,OACA,8DACA,UAAW,EACb;GAGA,SAAS,SAAS,KAAK,GAAG;GAE1B,SAAS,SAAS,IAAI,MAAM;GAE5B,KAAK,KAAK,GAAG;GAGb,IAAI,MAAM,QAAQ,YAAY;;IAC5B,IAAI,kBAAkB,MAAM,QAAQ,WAAW,aAAa,CAAC;IAG7D,4BAAI,IAAI,6FAAiB,QACvB,IAAI,UAAU,WAAW,IAAI,iBAAiB,QAAQ,GAAG,GAAG;GAEhE;EACF;EAEA,OAAO;CACT;CAEA,SAAS,OAAO,WAAW,IAAI;CAE/B,OAAO;AACT"}

package/dist/core/row-models/createCoreRowModel.js.map

@@ -1 +1 @@
-{"version":3,"file":"createCoreRowModel.js","names":[],"sources":["../../../src/core/row-models/createCoreRowModel.ts"],"sourcesContent":["import { constructRow } from '../rows/constructRow'\nimport { tableMemo } from '../../utils'\nimport { table_autoResetPageIndex } from '../../features/row-pagination/rowPaginationFeature.utils'\nimport type { Table, Table_Internal } from '../../types/Table'\nimport type { RowModel } from './coreRowModelsFeature.types'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { Row } from '../../types/Row'\nimport type { RowData } from '../../types/type-utils'\n\n/**\n * Creates a memoized core row model factory.\n *\n * The factory reads the relevant table state atoms and options, then returns a row model function used by the table row-model pipeline.\n */\nexport function createCoreRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(): (table: Table<TFeatures, TData>) => () => RowModel<TFeatures, TData> {\n  return (_table) => {\n    const table: Table_Internal<TFeatures, TData> = _table\n    return tableMemo({\n      feature: 'coreRowModelsFeature',\n      table,\n      fnName: 'table.getCoreRowModel',\n      memoDeps: () => [table.options.data],\n      fn: () => _createCoreRowModel(table, table.options.data),\n      onAfterUpdate: () => table_autoResetPageIndex(table),\n    })\n  }\n}\n\nfunction _createCoreRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  table: Table_Internal<TFeatures, TData>,\n  data: ReadonlyArray<TData>,\n): {\n  rows: Array<Row<TFeatures, TData>>\n  flatRows: Array<Row<TFeatures, TData>>\n  rowsById: Record<string, Row<TFeatures, TData>>\n} {\n  const rowModel: RowModel<TFeatures, TData> = {\n    rows: [],\n    flatRows: [],\n    rowsById: {},\n  }\n\n  const accessRows = (\n    originalRows: ReadonlyArray<TData>,\n    depth = 0,\n    parentRow?: Row<TFeatures, TData>,\n  ): Array<Row<TFeatures, TData>> => {\n    const rows = [] as Array<Row<TFeatures, TData>>\n\n    for (let i = 0; i < originalRows.length; i++) {\n      const originalRow = originalRows[i]!\n      // Make the row\n      const row = constructRow(\n        table,\n        table.getRowId(originalRow, i, parentRow),\n        originalRow,\n        i,\n        depth,\n        undefined,\n        parentRow?.id,\n      )\n\n      // Keep track of every row in a flat array\n      rowModel.flatRows.push(row)\n      // Also keep track of every row by its ID\n      rowModel.rowsById[row.id] = row\n      // Push table row into parent\n      rows.push(row)\n\n      // Get the original subrows\n      if (table.options.getSubRows) {\n        row.originalSubRows = table.options.getSubRows(originalRow, i)\n\n        // Then recursively access them\n        if (row.originalSubRows?.length) {\n          row.subRows = accessRows(row.originalSubRows, depth + 1, row)\n        }\n      }\n    }\n\n    return rows\n  }\n\n  rowModel.rows = accessRows(data)\n\n  return rowModel\n}\n"],"mappings":";;;;;;;;;;AAcA,SAAgB,qBAG0D;CACxE,QAAQ,WAAW;EACjB,MAAM,QAA0C;EAChD,OAAO,UAAU;GACf,SAAS;GACT;GACA,QAAQ;GACR,gBAAgB,CAAC,MAAM,QAAQ,KAAK;GACpC,UAAU,oBAAoB,OAAO,MAAM,QAAQ,KAAK;GACxD,qBAAqB,yBAAyB,MAAM;GACrD,CAAC;;;AAIN,SAAS,oBAIP,OACA,MAKA;CACA,MAAM,WAAuC;EAC3C,MAAM,EAAE;EACR,UAAU,EAAE;EACZ,UAAU,EAAE;EACb;CAED,MAAM,cACJ,cACA,QAAQ,GACR,cACiC;EACjC,MAAM,OAAO,EAAE;EAEf,KAAK,IAAI,IAAI,GAAG,IAAI,aAAa,QAAQ,KAAK;GAC5C,MAAM,cAAc,aAAa;GAEjC,MAAM,MAAM,aACV,OACA,MAAM,SAAS,aAAa,GAAG,UAAU,EACzC,aACA,GACA,OACA,8DACA,UAAW,GACZ;GAGD,SAAS,SAAS,KAAK,IAAI;GAE3B,SAAS,SAAS,IAAI,MAAM;GAE5B,KAAK,KAAK,IAAI;GAGd,IAAI,MAAM,QAAQ,YAAY;;IAC5B,IAAI,kBAAkB,MAAM,QAAQ,WAAW,aAAa,EAAE;IAG9D,4BAAI,IAAI,6FAAiB,QACvB,IAAI,UAAU,WAAW,IAAI,iBAAiB,QAAQ,GAAG,IAAI;;;EAKnE,OAAO;;CAGT,SAAS,OAAO,WAAW,KAAK;CAEhC,OAAO"}
+{"version":3,"file":"createCoreRowModel.js","names":[],"sources":["../../../src/core/row-models/createCoreRowModel.ts"],"sourcesContent":["import { constructRow } from '../rows/constructRow'\nimport { tableMemo } from '../../utils'\nimport { table_autoResetPageIndex } from '../../features/row-pagination/rowPaginationFeature.utils'\nimport type { Table, Table_Internal } from '../../types/Table'\nimport type { RowModel } from './coreRowModelsFeature.types'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { Row } from '../../types/Row'\nimport type { RowData } from '../../types/type-utils'\n\n/**\n * Creates a memoized core row model factory.\n *\n * The factory reads the relevant table state atoms and options, then returns a row model function used by the table row-model pipeline.\n */\nexport function createCoreRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(): (table: Table<TFeatures, TData>) => () => RowModel<TFeatures, TData> {\n  return (_table) => {\n    const table: Table_Internal<TFeatures, TData> = _table\n    return tableMemo({\n      feature: 'coreRowModelsFeature',\n      table,\n      fnName: 'table.getCoreRowModel',\n      memoDeps: () => [table.options.data],\n      fn: () => _createCoreRowModel(table, table.options.data),\n      onAfterUpdate: () => table_autoResetPageIndex(table),\n    })\n  }\n}\n\nfunction _createCoreRowModel<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  table: Table_Internal<TFeatures, TData>,\n  data: ReadonlyArray<TData>,\n): {\n  rows: Array<Row<TFeatures, TData>>\n  flatRows: Array<Row<TFeatures, TData>>\n  rowsById: Record<string, Row<TFeatures, TData>>\n} {\n  const rowModel: RowModel<TFeatures, TData> = {\n    rows: [],\n    flatRows: [],\n    rowsById: {},\n  }\n\n  const accessRows = (\n    originalRows: ReadonlyArray<TData>,\n    depth = 0,\n    parentRow?: Row<TFeatures, TData>,\n  ): Array<Row<TFeatures, TData>> => {\n    const rows = [] as Array<Row<TFeatures, TData>>\n\n    for (let i = 0; i < originalRows.length; i++) {\n      const originalRow = originalRows[i]!\n      // Make the row\n      const row = constructRow(\n        table,\n        table.getRowId(originalRow, i, parentRow),\n        originalRow,\n        i,\n        depth,\n        undefined,\n        parentRow?.id,\n      )\n\n      // Keep track of every row in a flat array\n      rowModel.flatRows.push(row)\n      // Also keep track of every row by its ID\n      rowModel.rowsById[row.id] = row\n      // Push table row into parent\n      rows.push(row)\n\n      // Get the original subrows\n      if (table.options.getSubRows) {\n        row.originalSubRows = table.options.getSubRows(originalRow, i)\n\n        // Then recursively access them\n        if (row.originalSubRows?.length) {\n          row.subRows = accessRows(row.originalSubRows, depth + 1, row)\n        }\n      }\n    }\n\n    return rows\n  }\n\n  rowModel.rows = accessRows(data)\n\n  return rowModel\n}\n"],"mappings":";;;;;;;;;;AAcA,SAAgB,qBAG0D;CACxE,QAAQ,WAAW;EACjB,MAAM,QAA0C;EAChD,OAAO,UAAU;GACf,SAAS;GACT;GACA,QAAQ;GACR,gBAAgB,CAAC,MAAM,QAAQ,IAAI;GACnC,UAAU,oBAAoB,OAAO,MAAM,QAAQ,IAAI;GACvD,qBAAqB,yBAAyB,KAAK;EACrD,CAAC;CACH;AACF;AAEA,SAAS,oBAIP,OACA,MAKA;CACA,MAAM,WAAuC;EAC3C,MAAM,CAAC;EACP,UAAU,CAAC;EACX,UAAU,CAAC;CACb;CAEA,MAAM,cACJ,cACA,QAAQ,GACR,cACiC;EACjC,MAAM,OAAO,CAAC;EAEd,KAAK,IAAI,IAAI,GAAG,IAAI,aAAa,QAAQ,KAAK;GAC5C,MAAM,cAAc,aAAa;GAEjC,MAAM,MAAM,aACV,OACA,MAAM,SAAS,aAAa,GAAG,SAAS,GACxC,aACA,GACA,OACA,8DACA,UAAW,EACb;GAGA,SAAS,SAAS,KAAK,GAAG;GAE1B,SAAS,SAAS,IAAI,MAAM;GAE5B,KAAK,KAAK,GAAG;GAGb,IAAI,MAAM,QAAQ,YAAY;;IAC5B,IAAI,kBAAkB,MAAM,QAAQ,WAAW,aAAa,CAAC;IAG7D,4BAAI,IAAI,6FAAiB,QACvB,IAAI,UAAU,WAAW,IAAI,iBAAiB,QAAQ,GAAG,GAAG;GAEhE;EACF;EAEA,OAAO;CACT;CAEA,SAAS,OAAO,WAAW,IAAI;CAE/B,OAAO;AACT"}

package/dist/core/rows/constructRow.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"constructRow.cjs","names":[],"sources":["../../../src/core/rows/constructRow.ts"],"sourcesContent":["import type { Table_Internal } from '../../types/Table'\nimport type { RowData } from '../../types/type-utils'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { Row } from '../../types/Row'\nimport type { Row_CoreProperties } from './coreRowsFeature.types'\n\n/**\n * Creates or retrieves the row prototype for a table.\n * The prototype is cached on the table and shared by all row instances.\n */\nfunction getRowPrototype<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): object {\n  if (!table._rowPrototype) {\n    table._rowPrototype = { table }\n    const features = Object.values(table._features)\n    for (let i = 0; i < features.length; i++) {\n      features[i]!.assignRowPrototype?.(table._rowPrototype, table)\n    }\n  }\n  return table._rowPrototype\n}\n\n/**\n * Constructs a row instance from normalized table internals.\n *\n * This wires core properties, feature prototype APIs, and instance data used by table rendering and row-model operations.\n */\nexport const constructRow = <\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  table: Table_Internal<TFeatures, TData>,\n  id: string,\n  original: TData,\n  rowIndex: number,\n  depth: number,\n  subRows?: Array<Row<TFeatures, TData>>,\n  parentId?: string,\n): Row<TFeatures, TData> => {\n  // Create row with shared prototype for memory efficiency\n  const rowPrototype = getRowPrototype(table)\n  const row = Object.create(rowPrototype) as Row_CoreProperties<\n    TFeatures,\n    TData\n  >\n\n  // Only assign instance-specific properties\n  row._uniqueValuesCache = {}\n  row._valuesCache = {}\n  row.depth = depth\n  row.id = id\n  row.index = rowIndex\n  row.original = original\n  row.parentId = parentId\n  row.subRows = subRows ?? []\n\n  // Initialize instance-specific data (e.g., caches) for features that need it\n  const features = Object.values(table._features)\n  for (let i = 0; i < features.length; i++) {\n    features[i]!.initRowInstanceData?.(row)\n  }\n\n  return row as Row<TFeatures, TData>\n}\n"],"mappings":";;;;;;AAUA,SAAS,gBAGP,OAAiD;CACjD,IAAI,CAAC,MAAM,eAAe;EACxB,MAAM,gBAAgB,EAAE,OAAO;EAC/B,MAAM,WAAW,OAAO,OAAO,MAAM,UAAU;EAC/C,KAAK,IAAI,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;;GACxC,wCAAS,IAAI,iGAAqB,MAAM,eAAe,MAAM;;;CAGjE,OAAO,MAAM;;;;;;;AAQf,MAAa,gBAIX,OACA,IACA,UACA,UACA,OACA,SACA,aAC0B;CAE1B,MAAM,eAAe,gBAAgB,MAAM;CAC3C,MAAM,MAAM,OAAO,OAAO,aAAa;CAMvC,IAAI,qBAAqB,EAAE;CAC3B,IAAI,eAAe,EAAE;CACrB,IAAI,QAAQ;CACZ,IAAI,KAAK;CACT,IAAI,QAAQ;CACZ,IAAI,WAAW;CACf,IAAI,WAAW;CACf,IAAI,UAAU,WAAW,EAAE;CAG3B,MAAM,WAAW,OAAO,OAAO,MAAM,UAAU;CAC/C,KAAK,IAAI,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;;EACxC,0CAAS,IAAI,qGAAsB,IAAI;;CAGzC,OAAO"}
+{"version":3,"file":"constructRow.cjs","names":[],"sources":["../../../src/core/rows/constructRow.ts"],"sourcesContent":["import type { Table_Internal } from '../../types/Table'\nimport type { RowData } from '../../types/type-utils'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { Row } from '../../types/Row'\nimport type { Row_CoreProperties } from './coreRowsFeature.types'\n\n/**\n * Creates or retrieves the row prototype for a table.\n * The prototype is cached on the table and shared by all row instances.\n */\nfunction getRowPrototype<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): object {\n  if (!table._rowPrototype) {\n    table._rowPrototype = { table }\n    const features = Object.values(table._features)\n    for (let i = 0; i < features.length; i++) {\n      features[i]!.assignRowPrototype?.(table._rowPrototype, table)\n    }\n  }\n  return table._rowPrototype\n}\n\n/**\n * Constructs a row instance from normalized table internals.\n *\n * This wires core properties, feature prototype APIs, and instance data used by table rendering and row-model operations.\n */\nexport const constructRow = <\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  table: Table_Internal<TFeatures, TData>,\n  id: string,\n  original: TData,\n  rowIndex: number,\n  depth: number,\n  subRows?: Array<Row<TFeatures, TData>>,\n  parentId?: string,\n): Row<TFeatures, TData> => {\n  // Create row with shared prototype for memory efficiency\n  const rowPrototype = getRowPrototype(table)\n  const row = Object.create(rowPrototype) as Row_CoreProperties<\n    TFeatures,\n    TData\n  >\n\n  // Only assign instance-specific properties\n  row._uniqueValuesCache = {}\n  row._valuesCache = {}\n  row.depth = depth\n  row.id = id\n  row.index = rowIndex\n  row.original = original\n  row.parentId = parentId\n  row.subRows = subRows ?? []\n\n  // Initialize instance-specific data (e.g., caches) for features that need it\n  const features = Object.values(table._features)\n  for (let i = 0; i < features.length; i++) {\n    features[i]!.initRowInstanceData?.(row)\n  }\n\n  return row as Row<TFeatures, TData>\n}\n"],"mappings":";;;;;;AAUA,SAAS,gBAGP,OAAiD;CACjD,IAAI,CAAC,MAAM,eAAe;EACxB,MAAM,gBAAgB,EAAE,MAAM;EAC9B,MAAM,WAAW,OAAO,OAAO,MAAM,SAAS;EAC9C,KAAK,IAAI,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;;GACxC,wCAAS,IAAI,iGAAqB,MAAM,eAAe,KAAK;EAC9D;CACF;CACA,OAAO,MAAM;AACf;;;;;;AAOA,MAAa,gBAIX,OACA,IACA,UACA,UACA,OACA,SACA,aAC0B;CAE1B,MAAM,eAAe,gBAAgB,KAAK;CAC1C,MAAM,MAAM,OAAO,OAAO,YAAY;CAMtC,IAAI,qBAAqB,CAAC;CAC1B,IAAI,eAAe,CAAC;CACpB,IAAI,QAAQ;CACZ,IAAI,KAAK;CACT,IAAI,QAAQ;CACZ,IAAI,WAAW;CACf,IAAI,WAAW;CACf,IAAI,UAAU,WAAW,CAAC;CAG1B,MAAM,WAAW,OAAO,OAAO,MAAM,SAAS;CAC9C,KAAK,IAAI,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;;EACxC,0CAAS,IAAI,qGAAsB,GAAG;CACxC;CAEA,OAAO;AACT"}

package/dist/core/rows/constructRow.js.map

@@ -1 +1 @@
-{"version":3,"file":"constructRow.js","names":[],"sources":["../../../src/core/rows/constructRow.ts"],"sourcesContent":["import type { Table_Internal } from '../../types/Table'\nimport type { RowData } from '../../types/type-utils'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { Row } from '../../types/Row'\nimport type { Row_CoreProperties } from './coreRowsFeature.types'\n\n/**\n * Creates or retrieves the row prototype for a table.\n * The prototype is cached on the table and shared by all row instances.\n */\nfunction getRowPrototype<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): object {\n  if (!table._rowPrototype) {\n    table._rowPrototype = { table }\n    const features = Object.values(table._features)\n    for (let i = 0; i < features.length; i++) {\n      features[i]!.assignRowPrototype?.(table._rowPrototype, table)\n    }\n  }\n  return table._rowPrototype\n}\n\n/**\n * Constructs a row instance from normalized table internals.\n *\n * This wires core properties, feature prototype APIs, and instance data used by table rendering and row-model operations.\n */\nexport const constructRow = <\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  table: Table_Internal<TFeatures, TData>,\n  id: string,\n  original: TData,\n  rowIndex: number,\n  depth: number,\n  subRows?: Array<Row<TFeatures, TData>>,\n  parentId?: string,\n): Row<TFeatures, TData> => {\n  // Create row with shared prototype for memory efficiency\n  const rowPrototype = getRowPrototype(table)\n  const row = Object.create(rowPrototype) as Row_CoreProperties<\n    TFeatures,\n    TData\n  >\n\n  // Only assign instance-specific properties\n  row._uniqueValuesCache = {}\n  row._valuesCache = {}\n  row.depth = depth\n  row.id = id\n  row.index = rowIndex\n  row.original = original\n  row.parentId = parentId\n  row.subRows = subRows ?? []\n\n  // Initialize instance-specific data (e.g., caches) for features that need it\n  const features = Object.values(table._features)\n  for (let i = 0; i < features.length; i++) {\n    features[i]!.initRowInstanceData?.(row)\n  }\n\n  return row as Row<TFeatures, TData>\n}\n"],"mappings":";;;;;AAUA,SAAS,gBAGP,OAAiD;CACjD,IAAI,CAAC,MAAM,eAAe;EACxB,MAAM,gBAAgB,EAAE,OAAO;EAC/B,MAAM,WAAW,OAAO,OAAO,MAAM,UAAU;EAC/C,KAAK,IAAI,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;;GACxC,wCAAS,IAAI,iGAAqB,MAAM,eAAe,MAAM;;;CAGjE,OAAO,MAAM;;;;;;;AAQf,MAAa,gBAIX,OACA,IACA,UACA,UACA,OACA,SACA,aAC0B;CAE1B,MAAM,eAAe,gBAAgB,MAAM;CAC3C,MAAM,MAAM,OAAO,OAAO,aAAa;CAMvC,IAAI,qBAAqB,EAAE;CAC3B,IAAI,eAAe,EAAE;CACrB,IAAI,QAAQ;CACZ,IAAI,KAAK;CACT,IAAI,QAAQ;CACZ,IAAI,WAAW;CACf,IAAI,WAAW;CACf,IAAI,UAAU,WAAW,EAAE;CAG3B,MAAM,WAAW,OAAO,OAAO,MAAM,UAAU;CAC/C,KAAK,IAAI,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;;EACxC,0CAAS,IAAI,qGAAsB,IAAI;;CAGzC,OAAO"}
+{"version":3,"file":"constructRow.js","names":[],"sources":["../../../src/core/rows/constructRow.ts"],"sourcesContent":["import type { Table_Internal } from '../../types/Table'\nimport type { RowData } from '../../types/type-utils'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { Row } from '../../types/Row'\nimport type { Row_CoreProperties } from './coreRowsFeature.types'\n\n/**\n * Creates or retrieves the row prototype for a table.\n * The prototype is cached on the table and shared by all row instances.\n */\nfunction getRowPrototype<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(table: Table_Internal<TFeatures, TData>): object {\n  if (!table._rowPrototype) {\n    table._rowPrototype = { table }\n    const features = Object.values(table._features)\n    for (let i = 0; i < features.length; i++) {\n      features[i]!.assignRowPrototype?.(table._rowPrototype, table)\n    }\n  }\n  return table._rowPrototype\n}\n\n/**\n * Constructs a row instance from normalized table internals.\n *\n * This wires core properties, feature prototype APIs, and instance data used by table rendering and row-model operations.\n */\nexport const constructRow = <\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  table: Table_Internal<TFeatures, TData>,\n  id: string,\n  original: TData,\n  rowIndex: number,\n  depth: number,\n  subRows?: Array<Row<TFeatures, TData>>,\n  parentId?: string,\n): Row<TFeatures, TData> => {\n  // Create row with shared prototype for memory efficiency\n  const rowPrototype = getRowPrototype(table)\n  const row = Object.create(rowPrototype) as Row_CoreProperties<\n    TFeatures,\n    TData\n  >\n\n  // Only assign instance-specific properties\n  row._uniqueValuesCache = {}\n  row._valuesCache = {}\n  row.depth = depth\n  row.id = id\n  row.index = rowIndex\n  row.original = original\n  row.parentId = parentId\n  row.subRows = subRows ?? []\n\n  // Initialize instance-specific data (e.g., caches) for features that need it\n  const features = Object.values(table._features)\n  for (let i = 0; i < features.length; i++) {\n    features[i]!.initRowInstanceData?.(row)\n  }\n\n  return row as Row<TFeatures, TData>\n}\n"],"mappings":";;;;;AAUA,SAAS,gBAGP,OAAiD;CACjD,IAAI,CAAC,MAAM,eAAe;EACxB,MAAM,gBAAgB,EAAE,MAAM;EAC9B,MAAM,WAAW,OAAO,OAAO,MAAM,SAAS;EAC9C,KAAK,IAAI,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;;GACxC,wCAAS,IAAI,iGAAqB,MAAM,eAAe,KAAK;EAC9D;CACF;CACA,OAAO,MAAM;AACf;;;;;;AAOA,MAAa,gBAIX,OACA,IACA,UACA,UACA,OACA,SACA,aAC0B;CAE1B,MAAM,eAAe,gBAAgB,KAAK;CAC1C,MAAM,MAAM,OAAO,OAAO,YAAY;CAMtC,IAAI,qBAAqB,CAAC;CAC1B,IAAI,eAAe,CAAC;CACpB,IAAI,QAAQ;CACZ,IAAI,KAAK;CACT,IAAI,QAAQ;CACZ,IAAI,WAAW;CACf,IAAI,WAAW;CACf,IAAI,UAAU,WAAW,CAAC;CAG1B,MAAM,WAAW,OAAO,OAAO,MAAM,SAAS;CAC9C,KAAK,IAAI,IAAI,GAAG,IAAI,SAAS,QAAQ,KAAK;;EACxC,0CAAS,IAAI,qGAAsB,GAAG;CACxC;CAEA,OAAO;AACT"}

package/dist/core/rows/coreRowsFeature.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"coreRowsFeature.cjs","names":["row_getAllCellsByColumnId","row_getAllCells","row_getLeafRows","row_getParentRow","row_getParentRows","row_getUniqueValues","row_getValue","row_renderValue","table_getRowId","table_getRow"],"sources":["../../../src/core/rows/coreRowsFeature.ts"],"sourcesContent":["import { assignPrototypeAPIs, assignTableAPIs } from '../../utils'\nimport {\n  row_getAllCells,\n  row_getAllCellsByColumnId,\n  row_getLeafRows,\n  row_getParentRow,\n  row_getParentRows,\n  row_getUniqueValues,\n  row_getValue,\n  row_renderValue,\n  table_getRow,\n  table_getRowId,\n} from './coreRowsFeature.utils'\nimport type { RowData } from '../../types/type-utils'\nimport type { TableFeature, TableFeatures } from '../../types/TableFeatures'\n// import type {\n//   Row_Row,\n//   TableOptions_Rows,\n//   Table_Rows,\n// } from './coreRowsFeature.types'\n\nexport interface CoreRowsFeatureConstructors<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n> {\n  // Row: Row_Row<TFeatures, TData>\n  // TableOptions: TableOptions_Rows<TFeatures, TData>\n  // Table: Table_Rows<TFeatures, TData>\n}\n\n/**\n * Creates the stock core rows feature.\n *\n * The returned feature registers its state defaults, option defaults, and instance APIs so it can be included in a `tableFeatures({ ... })` call.\n */\nexport function constructCoreRowsFeature<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(): TableFeature<CoreRowsFeatureConstructors<TFeatures, TData>> {\n  return {\n    assignRowPrototype: (prototype, table) => {\n      assignPrototypeAPIs('coreRowsFeature', prototype, table, {\n        row_getAllCellsByColumnId: {\n          fn: (row) => row_getAllCellsByColumnId(row),\n          memoDeps: (row) => [row.getAllCells()],\n        },\n        row_getAllCells: {\n          fn: (row) => row_getAllCells(row),\n          memoDeps: (row) => [row.table.getAllLeafColumns()],\n        },\n        row_getLeafRows: {\n          fn: (row) => row_getLeafRows(row),\n        },\n        row_getParentRow: {\n          fn: (row) => row_getParentRow(row),\n        },\n        row_getParentRows: {\n          fn: (row) => row_getParentRows(row),\n        },\n        row_getUniqueValues: {\n          fn: (row, columnId) => row_getUniqueValues(row, columnId),\n        },\n        row_getValue: {\n          fn: (row, columnId) => row_getValue(row, columnId),\n        },\n        row_renderValue: {\n          fn: (row, columnId) => row_renderValue(row, columnId),\n        },\n      })\n    },\n    constructTableAPIs: (table) => {\n      assignTableAPIs('coreRowsFeature', table, {\n        table_getRowId: {\n          fn: (originalRow, index, parent) =>\n            table_getRowId(originalRow, table, index, parent),\n        },\n        table_getRow: {\n          fn: (id: string, searchAll?: boolean) =>\n            table_getRow(table, id, searchAll),\n        },\n      })\n    },\n  }\n}\n\n/**\n * The Core Rows feature provides the core row functionality.\n */\nexport const coreRowsFeature = constructCoreRowsFeature()\n"],"mappings":";;;;;;;;;AAmCA,SAAgB,2BAGiD;CAC/D,OAAO;EACL,qBAAqB,WAAW,UAAU;GACxC,kCAAoB,mBAAmB,WAAW,OAAO;IACvD,2BAA2B;KACzB,KAAK,QAAQA,wDAA0B,IAAI;KAC3C,WAAW,QAAQ,CAAC,IAAI,aAAa,CAAC;KACvC;IACD,iBAAiB;KACf,KAAK,QAAQC,8CAAgB,IAAI;KACjC,WAAW,QAAQ,CAAC,IAAI,MAAM,mBAAmB,CAAC;KACnD;IACD,iBAAiB,EACf,KAAK,QAAQC,8CAAgB,IAAI,EAClC;IACD,kBAAkB,EAChB,KAAK,QAAQC,+CAAiB,IAAI,EACnC;IACD,mBAAmB,EACjB,KAAK,QAAQC,gDAAkB,IAAI,EACpC;IACD,qBAAqB,EACnB,KAAK,KAAK,aAAaC,kDAAoB,KAAK,SAAS,EAC1D;IACD,cAAc,EACZ,KAAK,KAAK,aAAaC,2CAAa,KAAK,SAAS,EACnD;IACD,iBAAiB,EACf,KAAK,KAAK,aAAaC,8CAAgB,KAAK,SAAS,EACtD;IACF,CAAC;;EAEJ,qBAAqB,UAAU;GAC7B,8BAAgB,mBAAmB,OAAO;IACxC,gBAAgB,EACd,KAAK,aAAa,OAAO,WACvBC,6CAAe,aAAa,OAAO,OAAO,OAAO,EACpD;IACD,cAAc,EACZ,KAAK,IAAY,cACfC,2CAAa,OAAO,IAAI,UAAU,EACrC;IACF,CAAC;;EAEL;;;;;AAMH,MAAa,kBAAkB,0BAA0B"}
+{"version":3,"file":"coreRowsFeature.cjs","names":["row_getAllCellsByColumnId","row_getAllCells","row_getLeafRows","row_getParentRow","row_getParentRows","row_getUniqueValues","row_getValue","row_renderValue","table_getRowId","table_getRow"],"sources":["../../../src/core/rows/coreRowsFeature.ts"],"sourcesContent":["import { assignPrototypeAPIs, assignTableAPIs } from '../../utils'\nimport {\n  row_getAllCells,\n  row_getAllCellsByColumnId,\n  row_getLeafRows,\n  row_getParentRow,\n  row_getParentRows,\n  row_getUniqueValues,\n  row_getValue,\n  row_renderValue,\n  table_getRow,\n  table_getRowId,\n} from './coreRowsFeature.utils'\nimport type { RowData } from '../../types/type-utils'\nimport type { TableFeature, TableFeatures } from '../../types/TableFeatures'\n// import type {\n//   Row_Row,\n//   TableOptions_Rows,\n//   Table_Rows,\n// } from './coreRowsFeature.types'\n\nexport interface CoreRowsFeatureConstructors<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n> {\n  // Row: Row_Row<TFeatures, TData>\n  // TableOptions: TableOptions_Rows<TFeatures, TData>\n  // Table: Table_Rows<TFeatures, TData>\n}\n\n/**\n * Creates the stock core rows feature.\n *\n * The returned feature registers its state defaults, option defaults, and instance APIs so it can be included in a `tableFeatures({ ... })` call.\n */\nexport function constructCoreRowsFeature<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(): TableFeature<CoreRowsFeatureConstructors<TFeatures, TData>> {\n  return {\n    assignRowPrototype: (prototype, table) => {\n      assignPrototypeAPIs('coreRowsFeature', prototype, table, {\n        row_getAllCellsByColumnId: {\n          fn: (row) => row_getAllCellsByColumnId(row),\n          memoDeps: (row) => [row.getAllCells()],\n        },\n        row_getAllCells: {\n          fn: (row) => row_getAllCells(row),\n          memoDeps: (row) => [row.table.getAllLeafColumns()],\n        },\n        row_getLeafRows: {\n          fn: (row) => row_getLeafRows(row),\n        },\n        row_getParentRow: {\n          fn: (row) => row_getParentRow(row),\n        },\n        row_getParentRows: {\n          fn: (row) => row_getParentRows(row),\n        },\n        row_getUniqueValues: {\n          fn: (row, columnId) => row_getUniqueValues(row, columnId),\n        },\n        row_getValue: {\n          fn: (row, columnId) => row_getValue(row, columnId),\n        },\n        row_renderValue: {\n          fn: (row, columnId) => row_renderValue(row, columnId),\n        },\n      })\n    },\n    constructTableAPIs: (table) => {\n      assignTableAPIs('coreRowsFeature', table, {\n        table_getRowId: {\n          fn: (originalRow, index, parent) =>\n            table_getRowId(originalRow, table, index, parent),\n        },\n        table_getRow: {\n          fn: (id: string, searchAll?: boolean) =>\n            table_getRow(table, id, searchAll),\n        },\n      })\n    },\n  }\n}\n\n/**\n * The Core Rows feature provides the core row functionality.\n */\nexport const coreRowsFeature = constructCoreRowsFeature()\n"],"mappings":";;;;;;;;;AAmCA,SAAgB,2BAGiD;CAC/D,OAAO;EACL,qBAAqB,WAAW,UAAU;GACxC,kCAAoB,mBAAmB,WAAW,OAAO;IACvD,2BAA2B;KACzB,KAAK,QAAQA,wDAA0B,GAAG;KAC1C,WAAW,QAAQ,CAAC,IAAI,YAAY,CAAC;IACvC;IACA,iBAAiB;KACf,KAAK,QAAQC,8CAAgB,GAAG;KAChC,WAAW,QAAQ,CAAC,IAAI,MAAM,kBAAkB,CAAC;IACnD;IACA,iBAAiB,EACf,KAAK,QAAQC,8CAAgB,GAAG,EAClC;IACA,kBAAkB,EAChB,KAAK,QAAQC,+CAAiB,GAAG,EACnC;IACA,mBAAmB,EACjB,KAAK,QAAQC,gDAAkB,GAAG,EACpC;IACA,qBAAqB,EACnB,KAAK,KAAK,aAAaC,kDAAoB,KAAK,QAAQ,EAC1D;IACA,cAAc,EACZ,KAAK,KAAK,aAAaC,2CAAa,KAAK,QAAQ,EACnD;IACA,iBAAiB,EACf,KAAK,KAAK,aAAaC,8CAAgB,KAAK,QAAQ,EACtD;GACF,CAAC;EACH;EACA,qBAAqB,UAAU;GAC7B,8BAAgB,mBAAmB,OAAO;IACxC,gBAAgB,EACd,KAAK,aAAa,OAAO,WACvBC,6CAAe,aAAa,OAAO,OAAO,MAAM,EACpD;IACA,cAAc,EACZ,KAAK,IAAY,cACfC,2CAAa,OAAO,IAAI,SAAS,EACrC;GACF,CAAC;EACH;CACF;AACF;;;;AAKA,MAAa,kBAAkB,yBAAyB"}

package/dist/core/rows/coreRowsFeature.js.map

@@ -1 +1 @@
-{"version":3,"file":"coreRowsFeature.js","names":[],"sources":["../../../src/core/rows/coreRowsFeature.ts"],"sourcesContent":["import { assignPrototypeAPIs, assignTableAPIs } from '../../utils'\nimport {\n  row_getAllCells,\n  row_getAllCellsByColumnId,\n  row_getLeafRows,\n  row_getParentRow,\n  row_getParentRows,\n  row_getUniqueValues,\n  row_getValue,\n  row_renderValue,\n  table_getRow,\n  table_getRowId,\n} from './coreRowsFeature.utils'\nimport type { RowData } from '../../types/type-utils'\nimport type { TableFeature, TableFeatures } from '../../types/TableFeatures'\n// import type {\n//   Row_Row,\n//   TableOptions_Rows,\n//   Table_Rows,\n// } from './coreRowsFeature.types'\n\nexport interface CoreRowsFeatureConstructors<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n> {\n  // Row: Row_Row<TFeatures, TData>\n  // TableOptions: TableOptions_Rows<TFeatures, TData>\n  // Table: Table_Rows<TFeatures, TData>\n}\n\n/**\n * Creates the stock core rows feature.\n *\n * The returned feature registers its state defaults, option defaults, and instance APIs so it can be included in a `tableFeatures({ ... })` call.\n */\nexport function constructCoreRowsFeature<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(): TableFeature<CoreRowsFeatureConstructors<TFeatures, TData>> {\n  return {\n    assignRowPrototype: (prototype, table) => {\n      assignPrototypeAPIs('coreRowsFeature', prototype, table, {\n        row_getAllCellsByColumnId: {\n          fn: (row) => row_getAllCellsByColumnId(row),\n          memoDeps: (row) => [row.getAllCells()],\n        },\n        row_getAllCells: {\n          fn: (row) => row_getAllCells(row),\n          memoDeps: (row) => [row.table.getAllLeafColumns()],\n        },\n        row_getLeafRows: {\n          fn: (row) => row_getLeafRows(row),\n        },\n        row_getParentRow: {\n          fn: (row) => row_getParentRow(row),\n        },\n        row_getParentRows: {\n          fn: (row) => row_getParentRows(row),\n        },\n        row_getUniqueValues: {\n          fn: (row, columnId) => row_getUniqueValues(row, columnId),\n        },\n        row_getValue: {\n          fn: (row, columnId) => row_getValue(row, columnId),\n        },\n        row_renderValue: {\n          fn: (row, columnId) => row_renderValue(row, columnId),\n        },\n      })\n    },\n    constructTableAPIs: (table) => {\n      assignTableAPIs('coreRowsFeature', table, {\n        table_getRowId: {\n          fn: (originalRow, index, parent) =>\n            table_getRowId(originalRow, table, index, parent),\n        },\n        table_getRow: {\n          fn: (id: string, searchAll?: boolean) =>\n            table_getRow(table, id, searchAll),\n        },\n      })\n    },\n  }\n}\n\n/**\n * The Core Rows feature provides the core row functionality.\n */\nexport const coreRowsFeature = constructCoreRowsFeature()\n"],"mappings":";;;;;;;;;AAmCA,SAAgB,2BAGiD;CAC/D,OAAO;EACL,qBAAqB,WAAW,UAAU;GACxC,oBAAoB,mBAAmB,WAAW,OAAO;IACvD,2BAA2B;KACzB,KAAK,QAAQ,0BAA0B,IAAI;KAC3C,WAAW,QAAQ,CAAC,IAAI,aAAa,CAAC;KACvC;IACD,iBAAiB;KACf,KAAK,QAAQ,gBAAgB,IAAI;KACjC,WAAW,QAAQ,CAAC,IAAI,MAAM,mBAAmB,CAAC;KACnD;IACD,iBAAiB,EACf,KAAK,QAAQ,gBAAgB,IAAI,EAClC;IACD,kBAAkB,EAChB,KAAK,QAAQ,iBAAiB,IAAI,EACnC;IACD,mBAAmB,EACjB,KAAK,QAAQ,kBAAkB,IAAI,EACpC;IACD,qBAAqB,EACnB,KAAK,KAAK,aAAa,oBAAoB,KAAK,SAAS,EAC1D;IACD,cAAc,EACZ,KAAK,KAAK,aAAa,aAAa,KAAK,SAAS,EACnD;IACD,iBAAiB,EACf,KAAK,KAAK,aAAa,gBAAgB,KAAK,SAAS,EACtD;IACF,CAAC;;EAEJ,qBAAqB,UAAU;GAC7B,gBAAgB,mBAAmB,OAAO;IACxC,gBAAgB,EACd,KAAK,aAAa,OAAO,WACvB,eAAe,aAAa,OAAO,OAAO,OAAO,EACpD;IACD,cAAc,EACZ,KAAK,IAAY,cACf,aAAa,OAAO,IAAI,UAAU,EACrC;IACF,CAAC;;EAEL;;;;;AAMH,MAAa,kBAAkB,0BAA0B"}
+{"version":3,"file":"coreRowsFeature.js","names":[],"sources":["../../../src/core/rows/coreRowsFeature.ts"],"sourcesContent":["import { assignPrototypeAPIs, assignTableAPIs } from '../../utils'\nimport {\n  row_getAllCells,\n  row_getAllCellsByColumnId,\n  row_getLeafRows,\n  row_getParentRow,\n  row_getParentRows,\n  row_getUniqueValues,\n  row_getValue,\n  row_renderValue,\n  table_getRow,\n  table_getRowId,\n} from './coreRowsFeature.utils'\nimport type { RowData } from '../../types/type-utils'\nimport type { TableFeature, TableFeatures } from '../../types/TableFeatures'\n// import type {\n//   Row_Row,\n//   TableOptions_Rows,\n//   Table_Rows,\n// } from './coreRowsFeature.types'\n\nexport interface CoreRowsFeatureConstructors<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n> {\n  // Row: Row_Row<TFeatures, TData>\n  // TableOptions: TableOptions_Rows<TFeatures, TData>\n  // Table: Table_Rows<TFeatures, TData>\n}\n\n/**\n * Creates the stock core rows feature.\n *\n * The returned feature registers its state defaults, option defaults, and instance APIs so it can be included in a `tableFeatures({ ... })` call.\n */\nexport function constructCoreRowsFeature<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(): TableFeature<CoreRowsFeatureConstructors<TFeatures, TData>> {\n  return {\n    assignRowPrototype: (prototype, table) => {\n      assignPrototypeAPIs('coreRowsFeature', prototype, table, {\n        row_getAllCellsByColumnId: {\n          fn: (row) => row_getAllCellsByColumnId(row),\n          memoDeps: (row) => [row.getAllCells()],\n        },\n        row_getAllCells: {\n          fn: (row) => row_getAllCells(row),\n          memoDeps: (row) => [row.table.getAllLeafColumns()],\n        },\n        row_getLeafRows: {\n          fn: (row) => row_getLeafRows(row),\n        },\n        row_getParentRow: {\n          fn: (row) => row_getParentRow(row),\n        },\n        row_getParentRows: {\n          fn: (row) => row_getParentRows(row),\n        },\n        row_getUniqueValues: {\n          fn: (row, columnId) => row_getUniqueValues(row, columnId),\n        },\n        row_getValue: {\n          fn: (row, columnId) => row_getValue(row, columnId),\n        },\n        row_renderValue: {\n          fn: (row, columnId) => row_renderValue(row, columnId),\n        },\n      })\n    },\n    constructTableAPIs: (table) => {\n      assignTableAPIs('coreRowsFeature', table, {\n        table_getRowId: {\n          fn: (originalRow, index, parent) =>\n            table_getRowId(originalRow, table, index, parent),\n        },\n        table_getRow: {\n          fn: (id: string, searchAll?: boolean) =>\n            table_getRow(table, id, searchAll),\n        },\n      })\n    },\n  }\n}\n\n/**\n * The Core Rows feature provides the core row functionality.\n */\nexport const coreRowsFeature = constructCoreRowsFeature()\n"],"mappings":";;;;;;;;;AAmCA,SAAgB,2BAGiD;CAC/D,OAAO;EACL,qBAAqB,WAAW,UAAU;GACxC,oBAAoB,mBAAmB,WAAW,OAAO;IACvD,2BAA2B;KACzB,KAAK,QAAQ,0BAA0B,GAAG;KAC1C,WAAW,QAAQ,CAAC,IAAI,YAAY,CAAC;IACvC;IACA,iBAAiB;KACf,KAAK,QAAQ,gBAAgB,GAAG;KAChC,WAAW,QAAQ,CAAC,IAAI,MAAM,kBAAkB,CAAC;IACnD;IACA,iBAAiB,EACf,KAAK,QAAQ,gBAAgB,GAAG,EAClC;IACA,kBAAkB,EAChB,KAAK,QAAQ,iBAAiB,GAAG,EACnC;IACA,mBAAmB,EACjB,KAAK,QAAQ,kBAAkB,GAAG,EACpC;IACA,qBAAqB,EACnB,KAAK,KAAK,aAAa,oBAAoB,KAAK,QAAQ,EAC1D;IACA,cAAc,EACZ,KAAK,KAAK,aAAa,aAAa,KAAK,QAAQ,EACnD;IACA,iBAAiB,EACf,KAAK,KAAK,aAAa,gBAAgB,KAAK,QAAQ,EACtD;GACF,CAAC;EACH;EACA,qBAAqB,UAAU;GAC7B,gBAAgB,mBAAmB,OAAO;IACxC,gBAAgB,EACd,KAAK,aAAa,OAAO,WACvB,eAAe,aAAa,OAAO,OAAO,MAAM,EACpD;IACA,cAAc,EACZ,KAAK,IAAY,cACf,aAAa,OAAO,IAAI,SAAS,EACrC;GACF,CAAC;EACH;CACF;AACF;;;;AAKA,MAAa,kBAAkB,yBAAyB"}

package/dist/core/rows/coreRowsFeature.utils.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"coreRowsFeature.utils.cjs","names":["flattenBy","constructCell"],"sources":["../../../src/core/rows/coreRowsFeature.utils.ts"],"sourcesContent":["import { flattenBy } from '../../utils'\nimport { constructCell } from '../cells/constructCell'\nimport type { Table_Internal } from '../../types/Table'\nimport type { RowData } from '../../types/type-utils'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { Row } from '../../types/Row'\nimport type { Cell } from '../../types/Cell'\n\n/**\n * Reads and caches this row's value for a column.\n *\n * The value is produced by the column accessor. Missing columns or display\n * columns without an accessor return `undefined`.\n *\n * @example\n * ```ts\n * const firstName = row_getValue(row, 'firstName')\n * ```\n */\nexport function row_getValue<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>, columnId: string) {\n  if (row._valuesCache.hasOwnProperty(columnId)) {\n    return row._valuesCache[columnId]\n  }\n\n  const column = row.table.getColumn(columnId)\n\n  if (!column?.accessorFn) {\n    return undefined\n  }\n\n  row._valuesCache[columnId] = column.accessorFn(row.original, row.index)\n\n  return row._valuesCache[columnId]\n}\n\n/**\n * Reads and caches the values used by faceting/grouping for a column.\n *\n * If the column defines `getUniqueValues`, that result is used. Otherwise the\n * row's accessor value is wrapped in a single-item array.\n *\n * @example\n * ```ts\n * const values = row_getUniqueValues(row, 'tags')\n * ```\n */\nexport function row_getUniqueValues<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>, columnId: string) {\n  if (row._uniqueValuesCache.hasOwnProperty(columnId)) {\n    return row._uniqueValuesCache[columnId]\n  }\n\n  const column = row.table.getColumn(columnId)\n\n  if (!column?.accessorFn) {\n    return undefined\n  }\n\n  if (!column.columnDef.getUniqueValues) {\n    row._uniqueValuesCache[columnId] = [row.getValue(columnId)]\n    return row._uniqueValuesCache[columnId]\n  }\n\n  row._uniqueValuesCache[columnId] = column.columnDef.getUniqueValues(\n    row.original,\n    row.index,\n  )\n\n  return row._uniqueValuesCache[columnId]\n}\n\n/**\n * Returns a renderable row value for a column.\n *\n * If the accessor value is nullish, the table's `renderFallbackValue` is used\n * instead.\n *\n * @example\n * ```ts\n * const value = row_renderValue(row, 'firstName')\n * ```\n */\nexport function row_renderValue<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>, columnId: string) {\n  return row.getValue(columnId) ?? row.table.options.renderFallbackValue\n}\n\n/**\n * Flattens this row's descendant tree into leaf rows.\n *\n * The row itself is not included; only nested `subRows` are walked.\n *\n * @example\n * ```ts\n * const descendants = row_getLeafRows(row)\n * ```\n */\nexport function row_getLeafRows<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>): Array<Row<TFeatures, TData>> {\n  return flattenBy(row.subRows, (d) => d.subRows)\n}\n\n/**\n * Looks up this row's direct parent, if it has one.\n *\n * Parent lookup searches the pre-pagination row model so parent relationships\n * are available even when the parent is not on the current page.\n *\n * @example\n * ```ts\n * const parent = row_getParentRow(row)\n * ```\n */\nexport function row_getParentRow<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>) {\n  return row.parentId ? row.table.getRow(row.parentId, true) : undefined\n}\n\n/**\n * Collects this row's ancestor chain from root to direct parent.\n *\n * The current row is not included. Rows without a parent return an empty array.\n *\n * @example\n * ```ts\n * const ancestors = row_getParentRows(row)\n * ```\n */\nexport function row_getParentRows<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>) {\n  const parentRows: Array<Row<TFeatures, TData>> = []\n  let currentRow = row\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n  while (true) {\n    const parentRow = currentRow.getParentRow()\n    if (!parentRow) break\n    parentRows.push(parentRow)\n    currentRow = parentRow\n  }\n  return parentRows.reverse()\n}\n\n/**\n * Constructs one cell for each leaf column in this row.\n *\n * The result follows `table.getAllLeafColumns()` order and includes hidden\n * columns; visibility-specific APIs filter this list later.\n *\n * @example\n * ```ts\n * const cells = row_getAllCells(row)\n * ```\n */\nexport function row_getAllCells<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>): Array<Cell<TFeatures, TData, unknown>> {\n  const columns = row.table.getAllLeafColumns()\n  const cells: Array<Cell<TFeatures, TData, unknown>> = new Array(\n    columns.length,\n  )\n  for (let i = 0; i < columns.length; i++) {\n    cells[i] = constructCell(columns[i]!, row, row.table)\n  }\n  return cells\n}\n\n/**\n * Builds a lookup map of this row's cells keyed by column id.\n *\n * This is the static implementation behind `row.getAllCellsByColumnId()`.\n *\n * @example\n * ```ts\n * const cellsById = row_getAllCellsByColumnId(row)\n * ```\n */\nexport function row_getAllCellsByColumnId<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>) {\n  const result: Record<string, Cell<TFeatures, TData, unknown>> = {}\n  const cells = row.getAllCells()\n  for (let i = 0; i < cells.length; i++) {\n    const cell = cells[i]!\n    result[cell.column.id] = cell\n  }\n  return result\n}\n\n/**\n * Resolves the stable id for a row.\n *\n * `options.getRowId` wins when provided. Otherwise root rows use their index\n * and child rows append their index to the parent id, such as `0.2`.\n *\n * @example\n * ```ts\n * const id = table_getRowId(originalRow, table, index, parentRow)\n * ```\n */\nexport function table_getRowId<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  originalRow: TData,\n  table: Table_Internal<TFeatures, TData>,\n  index: number,\n  parent?: Row<TFeatures, TData>,\n) {\n  return (\n    table.options.getRowId?.(originalRow, index, parent) ??\n    `${parent ? [parent.id, index].join('.') : index}`\n  )\n}\n\n/**\n * Looks up a row by id from the current or full row model.\n *\n * By default this searches `table.getRowModel()`. Passing `searchAll` searches\n * the pre-pagination model first, then falls back to the core model.\n *\n * @example\n * ```ts\n * const row = table_getRow(table, rowId, true)\n * ```\n */\nexport function table_getRow<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  table: Table_Internal<TFeatures, TData>,\n  rowId: string,\n  searchAll?: boolean,\n): Row<TFeatures, TData> {\n  // TODO - simplify this across different row models\n  let row = (searchAll ? table.getPrePaginatedRowModel() : table.getRowModel())\n    .rowsById[rowId]\n\n  if (!row) {\n    row = table.getCoreRowModel().rowsById[rowId]\n    if (!row) {\n      if (process.env.NODE_ENV === 'development') {\n        throw new Error(`getRow could not find row with ID: ${rowId}`)\n      }\n      throw new Error()\n    }\n  }\n\n  return row\n}\n"],"mappings":";;;;;;;;;;;;;;;AAmBA,SAAgB,aAGd,KAA4B,UAAkB;CAC9C,IAAI,IAAI,aAAa,eAAe,SAAS,EAC3C,OAAO,IAAI,aAAa;CAG1B,MAAM,SAAS,IAAI,MAAM,UAAU,SAAS;CAE5C,IAAI,kDAAC,OAAQ,aACX;CAGF,IAAI,aAAa,YAAY,OAAO,WAAW,IAAI,UAAU,IAAI,MAAM;CAEvE,OAAO,IAAI,aAAa;;;;;;;;;;;;;AAc1B,SAAgB,oBAGd,KAA4B,UAAkB;CAC9C,IAAI,IAAI,mBAAmB,eAAe,SAAS,EACjD,OAAO,IAAI,mBAAmB;CAGhC,MAAM,SAAS,IAAI,MAAM,UAAU,SAAS;CAE5C,IAAI,kDAAC,OAAQ,aACX;CAGF,IAAI,CAAC,OAAO,UAAU,iBAAiB;EACrC,IAAI,mBAAmB,YAAY,CAAC,IAAI,SAAS,SAAS,CAAC;EAC3D,OAAO,IAAI,mBAAmB;;CAGhC,IAAI,mBAAmB,YAAY,OAAO,UAAU,gBAClD,IAAI,UACJ,IAAI,MACL;CAED,OAAO,IAAI,mBAAmB;;;;;;;;;;;;;AAchC,SAAgB,gBAGd,KAA4B,UAAkB;CAC9C,OAAO,IAAI,SAAS,SAAS,IAAI,IAAI,MAAM,QAAQ;;;;;;;;;;;;AAarD,SAAgB,gBAGd,KAA0D;CAC1D,OAAOA,wBAAU,IAAI,UAAU,MAAM,EAAE,QAAQ;;;;;;;;;;;;;AAcjD,SAAgB,iBAGd,KAA4B;CAC5B,OAAO,IAAI,WAAW,IAAI,MAAM,OAAO,IAAI,UAAU,KAAK,GAAG;;;;;;;;;;;;AAa/D,SAAgB,kBAGd,KAA4B;CAC5B,MAAM,aAA2C,EAAE;CACnD,IAAI,aAAa;CAEjB,OAAO,MAAM;EACX,MAAM,YAAY,WAAW,cAAc;EAC3C,IAAI,CAAC,WAAW;EAChB,WAAW,KAAK,UAAU;EAC1B,aAAa;;CAEf,OAAO,WAAW,SAAS;;;;;;;;;;;;;AAc7B,SAAgB,gBAGd,KAAoE;CACpE,MAAM,UAAU,IAAI,MAAM,mBAAmB;CAC7C,MAAM,QAAgD,IAAI,MACxD,QAAQ,OACT;CACD,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAClC,MAAM,KAAKC,oCAAc,QAAQ,IAAK,KAAK,IAAI,MAAM;CAEvD,OAAO;;;;;;;;;;;;AAaT,SAAgB,0BAGd,KAA4B;CAC5B,MAAM,SAA0D,EAAE;CAClE,MAAM,QAAQ,IAAI,aAAa;CAC/B,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;EACrC,MAAM,OAAO,MAAM;EACnB,OAAO,KAAK,OAAO,MAAM;;CAE3B,OAAO;;;;;;;;;;;;;AAcT,SAAgB,eAId,aACA,OACA,OACA,QACA;;CACA,mDACE,MAAM,SAAQ,6GAAW,aAAa,OAAO,OAAO,KACpD,GAAG,SAAS,CAAC,OAAO,IAAI,MAAM,CAAC,KAAK,IAAI,GAAG;;;;;;;;;;;;;AAe/C,SAAgB,aAId,OACA,OACA,WACuB;CAEvB,IAAI,OAAO,YAAY,MAAM,yBAAyB,GAAG,MAAM,aAAa,EACzE,SAAS;CAEZ,IAAI,CAAC,KAAK;EACR,MAAM,MAAM,iBAAiB,CAAC,SAAS;EACvC,IAAI,CAAC,KAAK;GACR,IAAI,QAAQ,IAAI,aAAa,eAC3B,MAAM,IAAI,MAAM,sCAAsC,QAAQ;GAEhE,MAAM,IAAI,OAAO;;;CAIrB,OAAO"}
+{"version":3,"file":"coreRowsFeature.utils.cjs","names":["flattenBy","constructCell"],"sources":["../../../src/core/rows/coreRowsFeature.utils.ts"],"sourcesContent":["import { flattenBy } from '../../utils'\nimport { constructCell } from '../cells/constructCell'\nimport type { Table_Internal } from '../../types/Table'\nimport type { RowData } from '../../types/type-utils'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { Row } from '../../types/Row'\nimport type { Cell } from '../../types/Cell'\n\n/**\n * Reads and caches this row's value for a column.\n *\n * The value is produced by the column accessor. Missing columns or display\n * columns without an accessor return `undefined`.\n *\n * @example\n * ```ts\n * const firstName = row_getValue(row, 'firstName')\n * ```\n */\nexport function row_getValue<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>, columnId: string) {\n  if (row._valuesCache.hasOwnProperty(columnId)) {\n    return row._valuesCache[columnId]\n  }\n\n  const column = row.table.getColumn(columnId)\n\n  if (!column?.accessorFn) {\n    return undefined\n  }\n\n  row._valuesCache[columnId] = column.accessorFn(row.original, row.index)\n\n  return row._valuesCache[columnId]\n}\n\n/**\n * Reads and caches the values used by faceting/grouping for a column.\n *\n * If the column defines `getUniqueValues`, that result is used. Otherwise the\n * row's accessor value is wrapped in a single-item array.\n *\n * @example\n * ```ts\n * const values = row_getUniqueValues(row, 'tags')\n * ```\n */\nexport function row_getUniqueValues<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>, columnId: string) {\n  if (row._uniqueValuesCache.hasOwnProperty(columnId)) {\n    return row._uniqueValuesCache[columnId]\n  }\n\n  const column = row.table.getColumn(columnId)\n\n  if (!column?.accessorFn) {\n    return undefined\n  }\n\n  if (!column.columnDef.getUniqueValues) {\n    row._uniqueValuesCache[columnId] = [row.getValue(columnId)]\n    return row._uniqueValuesCache[columnId]\n  }\n\n  row._uniqueValuesCache[columnId] = column.columnDef.getUniqueValues(\n    row.original,\n    row.index,\n  )\n\n  return row._uniqueValuesCache[columnId]\n}\n\n/**\n * Returns a renderable row value for a column.\n *\n * If the accessor value is nullish, the table's `renderFallbackValue` is used\n * instead.\n *\n * @example\n * ```ts\n * const value = row_renderValue(row, 'firstName')\n * ```\n */\nexport function row_renderValue<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>, columnId: string) {\n  return row.getValue(columnId) ?? row.table.options.renderFallbackValue\n}\n\n/**\n * Flattens this row's descendant tree into leaf rows.\n *\n * The row itself is not included; only nested `subRows` are walked.\n *\n * @example\n * ```ts\n * const descendants = row_getLeafRows(row)\n * ```\n */\nexport function row_getLeafRows<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>): Array<Row<TFeatures, TData>> {\n  return flattenBy(row.subRows, (d) => d.subRows)\n}\n\n/**\n * Looks up this row's direct parent, if it has one.\n *\n * Parent lookup searches the pre-pagination row model so parent relationships\n * are available even when the parent is not on the current page.\n *\n * @example\n * ```ts\n * const parent = row_getParentRow(row)\n * ```\n */\nexport function row_getParentRow<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>) {\n  return row.parentId ? row.table.getRow(row.parentId, true) : undefined\n}\n\n/**\n * Collects this row's ancestor chain from root to direct parent.\n *\n * The current row is not included. Rows without a parent return an empty array.\n *\n * @example\n * ```ts\n * const ancestors = row_getParentRows(row)\n * ```\n */\nexport function row_getParentRows<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>) {\n  const parentRows: Array<Row<TFeatures, TData>> = []\n  let currentRow = row\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n  while (true) {\n    const parentRow = currentRow.getParentRow()\n    if (!parentRow) break\n    parentRows.push(parentRow)\n    currentRow = parentRow\n  }\n  return parentRows.reverse()\n}\n\n/**\n * Constructs one cell for each leaf column in this row.\n *\n * The result follows `table.getAllLeafColumns()` order and includes hidden\n * columns; visibility-specific APIs filter this list later.\n *\n * @example\n * ```ts\n * const cells = row_getAllCells(row)\n * ```\n */\nexport function row_getAllCells<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>): Array<Cell<TFeatures, TData, unknown>> {\n  const columns = row.table.getAllLeafColumns()\n  const cells: Array<Cell<TFeatures, TData, unknown>> = new Array(\n    columns.length,\n  )\n  for (let i = 0; i < columns.length; i++) {\n    cells[i] = constructCell(columns[i]!, row, row.table)\n  }\n  return cells\n}\n\n/**\n * Builds a lookup map of this row's cells keyed by column id.\n *\n * This is the static implementation behind `row.getAllCellsByColumnId()`.\n *\n * @example\n * ```ts\n * const cellsById = row_getAllCellsByColumnId(row)\n * ```\n */\nexport function row_getAllCellsByColumnId<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>) {\n  const result: Record<string, Cell<TFeatures, TData, unknown>> = {}\n  const cells = row.getAllCells()\n  for (let i = 0; i < cells.length; i++) {\n    const cell = cells[i]!\n    result[cell.column.id] = cell\n  }\n  return result\n}\n\n/**\n * Resolves the stable id for a row.\n *\n * `options.getRowId` wins when provided. Otherwise root rows use their index\n * and child rows append their index to the parent id, such as `0.2`.\n *\n * @example\n * ```ts\n * const id = table_getRowId(originalRow, table, index, parentRow)\n * ```\n */\nexport function table_getRowId<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  originalRow: TData,\n  table: Table_Internal<TFeatures, TData>,\n  index: number,\n  parent?: Row<TFeatures, TData>,\n) {\n  return (\n    table.options.getRowId?.(originalRow, index, parent) ??\n    `${parent ? [parent.id, index].join('.') : index}`\n  )\n}\n\n/**\n * Looks up a row by id from the current or full row model.\n *\n * By default this searches `table.getRowModel()`. Passing `searchAll` searches\n * the pre-pagination model first, then falls back to the core model.\n *\n * @example\n * ```ts\n * const row = table_getRow(table, rowId, true)\n * ```\n */\nexport function table_getRow<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  table: Table_Internal<TFeatures, TData>,\n  rowId: string,\n  searchAll?: boolean,\n): Row<TFeatures, TData> {\n  // TODO - simplify this across different row models\n  let row = (searchAll ? table.getPrePaginatedRowModel() : table.getRowModel())\n    .rowsById[rowId]\n\n  if (!row) {\n    row = table.getCoreRowModel().rowsById[rowId]\n    if (!row) {\n      if (process.env.NODE_ENV === 'development') {\n        throw new Error(`getRow could not find row with ID: ${rowId}`)\n      }\n      throw new Error()\n    }\n  }\n\n  return row\n}\n"],"mappings":";;;;;;;;;;;;;;;AAmBA,SAAgB,aAGd,KAA4B,UAAkB;CAC9C,IAAI,IAAI,aAAa,eAAe,QAAQ,GAC1C,OAAO,IAAI,aAAa;CAG1B,MAAM,SAAS,IAAI,MAAM,UAAU,QAAQ;CAE3C,IAAI,kDAAC,OAAQ,aACX;CAGF,IAAI,aAAa,YAAY,OAAO,WAAW,IAAI,UAAU,IAAI,KAAK;CAEtE,OAAO,IAAI,aAAa;AAC1B;;;;;;;;;;;;AAaA,SAAgB,oBAGd,KAA4B,UAAkB;CAC9C,IAAI,IAAI,mBAAmB,eAAe,QAAQ,GAChD,OAAO,IAAI,mBAAmB;CAGhC,MAAM,SAAS,IAAI,MAAM,UAAU,QAAQ;CAE3C,IAAI,kDAAC,OAAQ,aACX;CAGF,IAAI,CAAC,OAAO,UAAU,iBAAiB;EACrC,IAAI,mBAAmB,YAAY,CAAC,IAAI,SAAS,QAAQ,CAAC;EAC1D,OAAO,IAAI,mBAAmB;CAChC;CAEA,IAAI,mBAAmB,YAAY,OAAO,UAAU,gBAClD,IAAI,UACJ,IAAI,KACN;CAEA,OAAO,IAAI,mBAAmB;AAChC;;;;;;;;;;;;AAaA,SAAgB,gBAGd,KAA4B,UAAkB;CAC9C,OAAO,IAAI,SAAS,QAAQ,KAAK,IAAI,MAAM,QAAQ;AACrD;;;;;;;;;;;AAYA,SAAgB,gBAGd,KAA0D;CAC1D,OAAOA,wBAAU,IAAI,UAAU,MAAM,EAAE,OAAO;AAChD;;;;;;;;;;;;AAaA,SAAgB,iBAGd,KAA4B;CAC5B,OAAO,IAAI,WAAW,IAAI,MAAM,OAAO,IAAI,UAAU,IAAI,IAAI;AAC/D;;;;;;;;;;;AAYA,SAAgB,kBAGd,KAA4B;CAC5B,MAAM,aAA2C,CAAC;CAClD,IAAI,aAAa;CAEjB,OAAO,MAAM;EACX,MAAM,YAAY,WAAW,aAAa;EAC1C,IAAI,CAAC,WAAW;EAChB,WAAW,KAAK,SAAS;EACzB,aAAa;CACf;CACA,OAAO,WAAW,QAAQ;AAC5B;;;;;;;;;;;;AAaA,SAAgB,gBAGd,KAAoE;CACpE,MAAM,UAAU,IAAI,MAAM,kBAAkB;CAC5C,MAAM,QAAgD,IAAI,MACxD,QAAQ,MACV;CACA,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAClC,MAAM,KAAKC,oCAAc,QAAQ,IAAK,KAAK,IAAI,KAAK;CAEtD,OAAO;AACT;;;;;;;;;;;AAYA,SAAgB,0BAGd,KAA4B;CAC5B,MAAM,SAA0D,CAAC;CACjE,MAAM,QAAQ,IAAI,YAAY;CAC9B,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;EACrC,MAAM,OAAO,MAAM;EACnB,OAAO,KAAK,OAAO,MAAM;CAC3B;CACA,OAAO;AACT;;;;;;;;;;;;AAaA,SAAgB,eAId,aACA,OACA,OACA,QACA;;CACA,mDACE,MAAM,SAAQ,6GAAW,aAAa,OAAO,MAAM,MACnD,GAAG,SAAS,CAAC,OAAO,IAAI,KAAK,EAAE,KAAK,GAAG,IAAI;AAE/C;;;;;;;;;;;;AAaA,SAAgB,aAId,OACA,OACA,WACuB;CAEvB,IAAI,OAAO,YAAY,MAAM,wBAAwB,IAAI,MAAM,YAAY,GACxE,SAAS;CAEZ,IAAI,CAAC,KAAK;EACR,MAAM,MAAM,gBAAgB,EAAE,SAAS;EACvC,IAAI,CAAC,KAAK;GACR,IAAI,QAAQ,IAAI,aAAa,eAC3B,MAAM,IAAI,MAAM,sCAAsC,OAAO;GAE/D,MAAM,IAAI,MAAM;EAClB;CACF;CAEA,OAAO;AACT"}

package/dist/core/rows/coreRowsFeature.utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"coreRowsFeature.utils.js","names":[],"sources":["../../../src/core/rows/coreRowsFeature.utils.ts"],"sourcesContent":["import { flattenBy } from '../../utils'\nimport { constructCell } from '../cells/constructCell'\nimport type { Table_Internal } from '../../types/Table'\nimport type { RowData } from '../../types/type-utils'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { Row } from '../../types/Row'\nimport type { Cell } from '../../types/Cell'\n\n/**\n * Reads and caches this row's value for a column.\n *\n * The value is produced by the column accessor. Missing columns or display\n * columns without an accessor return `undefined`.\n *\n * @example\n * ```ts\n * const firstName = row_getValue(row, 'firstName')\n * ```\n */\nexport function row_getValue<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>, columnId: string) {\n  if (row._valuesCache.hasOwnProperty(columnId)) {\n    return row._valuesCache[columnId]\n  }\n\n  const column = row.table.getColumn(columnId)\n\n  if (!column?.accessorFn) {\n    return undefined\n  }\n\n  row._valuesCache[columnId] = column.accessorFn(row.original, row.index)\n\n  return row._valuesCache[columnId]\n}\n\n/**\n * Reads and caches the values used by faceting/grouping for a column.\n *\n * If the column defines `getUniqueValues`, that result is used. Otherwise the\n * row's accessor value is wrapped in a single-item array.\n *\n * @example\n * ```ts\n * const values = row_getUniqueValues(row, 'tags')\n * ```\n */\nexport function row_getUniqueValues<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>, columnId: string) {\n  if (row._uniqueValuesCache.hasOwnProperty(columnId)) {\n    return row._uniqueValuesCache[columnId]\n  }\n\n  const column = row.table.getColumn(columnId)\n\n  if (!column?.accessorFn) {\n    return undefined\n  }\n\n  if (!column.columnDef.getUniqueValues) {\n    row._uniqueValuesCache[columnId] = [row.getValue(columnId)]\n    return row._uniqueValuesCache[columnId]\n  }\n\n  row._uniqueValuesCache[columnId] = column.columnDef.getUniqueValues(\n    row.original,\n    row.index,\n  )\n\n  return row._uniqueValuesCache[columnId]\n}\n\n/**\n * Returns a renderable row value for a column.\n *\n * If the accessor value is nullish, the table's `renderFallbackValue` is used\n * instead.\n *\n * @example\n * ```ts\n * const value = row_renderValue(row, 'firstName')\n * ```\n */\nexport function row_renderValue<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>, columnId: string) {\n  return row.getValue(columnId) ?? row.table.options.renderFallbackValue\n}\n\n/**\n * Flattens this row's descendant tree into leaf rows.\n *\n * The row itself is not included; only nested `subRows` are walked.\n *\n * @example\n * ```ts\n * const descendants = row_getLeafRows(row)\n * ```\n */\nexport function row_getLeafRows<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>): Array<Row<TFeatures, TData>> {\n  return flattenBy(row.subRows, (d) => d.subRows)\n}\n\n/**\n * Looks up this row's direct parent, if it has one.\n *\n * Parent lookup searches the pre-pagination row model so parent relationships\n * are available even when the parent is not on the current page.\n *\n * @example\n * ```ts\n * const parent = row_getParentRow(row)\n * ```\n */\nexport function row_getParentRow<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>) {\n  return row.parentId ? row.table.getRow(row.parentId, true) : undefined\n}\n\n/**\n * Collects this row's ancestor chain from root to direct parent.\n *\n * The current row is not included. Rows without a parent return an empty array.\n *\n * @example\n * ```ts\n * const ancestors = row_getParentRows(row)\n * ```\n */\nexport function row_getParentRows<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>) {\n  const parentRows: Array<Row<TFeatures, TData>> = []\n  let currentRow = row\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n  while (true) {\n    const parentRow = currentRow.getParentRow()\n    if (!parentRow) break\n    parentRows.push(parentRow)\n    currentRow = parentRow\n  }\n  return parentRows.reverse()\n}\n\n/**\n * Constructs one cell for each leaf column in this row.\n *\n * The result follows `table.getAllLeafColumns()` order and includes hidden\n * columns; visibility-specific APIs filter this list later.\n *\n * @example\n * ```ts\n * const cells = row_getAllCells(row)\n * ```\n */\nexport function row_getAllCells<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>): Array<Cell<TFeatures, TData, unknown>> {\n  const columns = row.table.getAllLeafColumns()\n  const cells: Array<Cell<TFeatures, TData, unknown>> = new Array(\n    columns.length,\n  )\n  for (let i = 0; i < columns.length; i++) {\n    cells[i] = constructCell(columns[i]!, row, row.table)\n  }\n  return cells\n}\n\n/**\n * Builds a lookup map of this row's cells keyed by column id.\n *\n * This is the static implementation behind `row.getAllCellsByColumnId()`.\n *\n * @example\n * ```ts\n * const cellsById = row_getAllCellsByColumnId(row)\n * ```\n */\nexport function row_getAllCellsByColumnId<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>) {\n  const result: Record<string, Cell<TFeatures, TData, unknown>> = {}\n  const cells = row.getAllCells()\n  for (let i = 0; i < cells.length; i++) {\n    const cell = cells[i]!\n    result[cell.column.id] = cell\n  }\n  return result\n}\n\n/**\n * Resolves the stable id for a row.\n *\n * `options.getRowId` wins when provided. Otherwise root rows use their index\n * and child rows append their index to the parent id, such as `0.2`.\n *\n * @example\n * ```ts\n * const id = table_getRowId(originalRow, table, index, parentRow)\n * ```\n */\nexport function table_getRowId<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  originalRow: TData,\n  table: Table_Internal<TFeatures, TData>,\n  index: number,\n  parent?: Row<TFeatures, TData>,\n) {\n  return (\n    table.options.getRowId?.(originalRow, index, parent) ??\n    `${parent ? [parent.id, index].join('.') : index}`\n  )\n}\n\n/**\n * Looks up a row by id from the current or full row model.\n *\n * By default this searches `table.getRowModel()`. Passing `searchAll` searches\n * the pre-pagination model first, then falls back to the core model.\n *\n * @example\n * ```ts\n * const row = table_getRow(table, rowId, true)\n * ```\n */\nexport function table_getRow<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  table: Table_Internal<TFeatures, TData>,\n  rowId: string,\n  searchAll?: boolean,\n): Row<TFeatures, TData> {\n  // TODO - simplify this across different row models\n  let row = (searchAll ? table.getPrePaginatedRowModel() : table.getRowModel())\n    .rowsById[rowId]\n\n  if (!row) {\n    row = table.getCoreRowModel().rowsById[rowId]\n    if (!row) {\n      if (process.env.NODE_ENV === 'development') {\n        throw new Error(`getRow could not find row with ID: ${rowId}`)\n      }\n      throw new Error()\n    }\n  }\n\n  return row\n}\n"],"mappings":";;;;;;;;;;;;;;;AAmBA,SAAgB,aAGd,KAA4B,UAAkB;CAC9C,IAAI,IAAI,aAAa,eAAe,SAAS,EAC3C,OAAO,IAAI,aAAa;CAG1B,MAAM,SAAS,IAAI,MAAM,UAAU,SAAS;CAE5C,IAAI,kDAAC,OAAQ,aACX;CAGF,IAAI,aAAa,YAAY,OAAO,WAAW,IAAI,UAAU,IAAI,MAAM;CAEvE,OAAO,IAAI,aAAa;;;;;;;;;;;;;AAc1B,SAAgB,oBAGd,KAA4B,UAAkB;CAC9C,IAAI,IAAI,mBAAmB,eAAe,SAAS,EACjD,OAAO,IAAI,mBAAmB;CAGhC,MAAM,SAAS,IAAI,MAAM,UAAU,SAAS;CAE5C,IAAI,kDAAC,OAAQ,aACX;CAGF,IAAI,CAAC,OAAO,UAAU,iBAAiB;EACrC,IAAI,mBAAmB,YAAY,CAAC,IAAI,SAAS,SAAS,CAAC;EAC3D,OAAO,IAAI,mBAAmB;;CAGhC,IAAI,mBAAmB,YAAY,OAAO,UAAU,gBAClD,IAAI,UACJ,IAAI,MACL;CAED,OAAO,IAAI,mBAAmB;;;;;;;;;;;;;AAchC,SAAgB,gBAGd,KAA4B,UAAkB;CAC9C,OAAO,IAAI,SAAS,SAAS,IAAI,IAAI,MAAM,QAAQ;;;;;;;;;;;;AAarD,SAAgB,gBAGd,KAA0D;CAC1D,OAAO,UAAU,IAAI,UAAU,MAAM,EAAE,QAAQ;;;;;;;;;;;;;AAcjD,SAAgB,iBAGd,KAA4B;CAC5B,OAAO,IAAI,WAAW,IAAI,MAAM,OAAO,IAAI,UAAU,KAAK,GAAG;;;;;;;;;;;;AAa/D,SAAgB,kBAGd,KAA4B;CAC5B,MAAM,aAA2C,EAAE;CACnD,IAAI,aAAa;CAEjB,OAAO,MAAM;EACX,MAAM,YAAY,WAAW,cAAc;EAC3C,IAAI,CAAC,WAAW;EAChB,WAAW,KAAK,UAAU;EAC1B,aAAa;;CAEf,OAAO,WAAW,SAAS;;;;;;;;;;;;;AAc7B,SAAgB,gBAGd,KAAoE;CACpE,MAAM,UAAU,IAAI,MAAM,mBAAmB;CAC7C,MAAM,QAAgD,IAAI,MACxD,QAAQ,OACT;CACD,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAClC,MAAM,KAAK,cAAc,QAAQ,IAAK,KAAK,IAAI,MAAM;CAEvD,OAAO;;;;;;;;;;;;AAaT,SAAgB,0BAGd,KAA4B;CAC5B,MAAM,SAA0D,EAAE;CAClE,MAAM,QAAQ,IAAI,aAAa;CAC/B,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;EACrC,MAAM,OAAO,MAAM;EACnB,OAAO,KAAK,OAAO,MAAM;;CAE3B,OAAO;;;;;;;;;;;;;AAcT,SAAgB,eAId,aACA,OACA,OACA,QACA;;CACA,mDACE,MAAM,SAAQ,6GAAW,aAAa,OAAO,OAAO,KACpD,GAAG,SAAS,CAAC,OAAO,IAAI,MAAM,CAAC,KAAK,IAAI,GAAG;;;;;;;;;;;;;AAe/C,SAAgB,aAId,OACA,OACA,WACuB;CAEvB,IAAI,OAAO,YAAY,MAAM,yBAAyB,GAAG,MAAM,aAAa,EACzE,SAAS;CAEZ,IAAI,CAAC,KAAK;EACR,MAAM,MAAM,iBAAiB,CAAC,SAAS;EACvC,IAAI,CAAC,KAAK;GACR,IAAI,QAAQ,IAAI,aAAa,eAC3B,MAAM,IAAI,MAAM,sCAAsC,QAAQ;GAEhE,MAAM,IAAI,OAAO;;;CAIrB,OAAO"}
+{"version":3,"file":"coreRowsFeature.utils.js","names":[],"sources":["../../../src/core/rows/coreRowsFeature.utils.ts"],"sourcesContent":["import { flattenBy } from '../../utils'\nimport { constructCell } from '../cells/constructCell'\nimport type { Table_Internal } from '../../types/Table'\nimport type { RowData } from '../../types/type-utils'\nimport type { TableFeatures } from '../../types/TableFeatures'\nimport type { Row } from '../../types/Row'\nimport type { Cell } from '../../types/Cell'\n\n/**\n * Reads and caches this row's value for a column.\n *\n * The value is produced by the column accessor. Missing columns or display\n * columns without an accessor return `undefined`.\n *\n * @example\n * ```ts\n * const firstName = row_getValue(row, 'firstName')\n * ```\n */\nexport function row_getValue<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>, columnId: string) {\n  if (row._valuesCache.hasOwnProperty(columnId)) {\n    return row._valuesCache[columnId]\n  }\n\n  const column = row.table.getColumn(columnId)\n\n  if (!column?.accessorFn) {\n    return undefined\n  }\n\n  row._valuesCache[columnId] = column.accessorFn(row.original, row.index)\n\n  return row._valuesCache[columnId]\n}\n\n/**\n * Reads and caches the values used by faceting/grouping for a column.\n *\n * If the column defines `getUniqueValues`, that result is used. Otherwise the\n * row's accessor value is wrapped in a single-item array.\n *\n * @example\n * ```ts\n * const values = row_getUniqueValues(row, 'tags')\n * ```\n */\nexport function row_getUniqueValues<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>, columnId: string) {\n  if (row._uniqueValuesCache.hasOwnProperty(columnId)) {\n    return row._uniqueValuesCache[columnId]\n  }\n\n  const column = row.table.getColumn(columnId)\n\n  if (!column?.accessorFn) {\n    return undefined\n  }\n\n  if (!column.columnDef.getUniqueValues) {\n    row._uniqueValuesCache[columnId] = [row.getValue(columnId)]\n    return row._uniqueValuesCache[columnId]\n  }\n\n  row._uniqueValuesCache[columnId] = column.columnDef.getUniqueValues(\n    row.original,\n    row.index,\n  )\n\n  return row._uniqueValuesCache[columnId]\n}\n\n/**\n * Returns a renderable row value for a column.\n *\n * If the accessor value is nullish, the table's `renderFallbackValue` is used\n * instead.\n *\n * @example\n * ```ts\n * const value = row_renderValue(row, 'firstName')\n * ```\n */\nexport function row_renderValue<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>, columnId: string) {\n  return row.getValue(columnId) ?? row.table.options.renderFallbackValue\n}\n\n/**\n * Flattens this row's descendant tree into leaf rows.\n *\n * The row itself is not included; only nested `subRows` are walked.\n *\n * @example\n * ```ts\n * const descendants = row_getLeafRows(row)\n * ```\n */\nexport function row_getLeafRows<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>): Array<Row<TFeatures, TData>> {\n  return flattenBy(row.subRows, (d) => d.subRows)\n}\n\n/**\n * Looks up this row's direct parent, if it has one.\n *\n * Parent lookup searches the pre-pagination row model so parent relationships\n * are available even when the parent is not on the current page.\n *\n * @example\n * ```ts\n * const parent = row_getParentRow(row)\n * ```\n */\nexport function row_getParentRow<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>) {\n  return row.parentId ? row.table.getRow(row.parentId, true) : undefined\n}\n\n/**\n * Collects this row's ancestor chain from root to direct parent.\n *\n * The current row is not included. Rows without a parent return an empty array.\n *\n * @example\n * ```ts\n * const ancestors = row_getParentRows(row)\n * ```\n */\nexport function row_getParentRows<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>) {\n  const parentRows: Array<Row<TFeatures, TData>> = []\n  let currentRow = row\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition\n  while (true) {\n    const parentRow = currentRow.getParentRow()\n    if (!parentRow) break\n    parentRows.push(parentRow)\n    currentRow = parentRow\n  }\n  return parentRows.reverse()\n}\n\n/**\n * Constructs one cell for each leaf column in this row.\n *\n * The result follows `table.getAllLeafColumns()` order and includes hidden\n * columns; visibility-specific APIs filter this list later.\n *\n * @example\n * ```ts\n * const cells = row_getAllCells(row)\n * ```\n */\nexport function row_getAllCells<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>): Array<Cell<TFeatures, TData, unknown>> {\n  const columns = row.table.getAllLeafColumns()\n  const cells: Array<Cell<TFeatures, TData, unknown>> = new Array(\n    columns.length,\n  )\n  for (let i = 0; i < columns.length; i++) {\n    cells[i] = constructCell(columns[i]!, row, row.table)\n  }\n  return cells\n}\n\n/**\n * Builds a lookup map of this row's cells keyed by column id.\n *\n * This is the static implementation behind `row.getAllCellsByColumnId()`.\n *\n * @example\n * ```ts\n * const cellsById = row_getAllCellsByColumnId(row)\n * ```\n */\nexport function row_getAllCellsByColumnId<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(row: Row<TFeatures, TData>) {\n  const result: Record<string, Cell<TFeatures, TData, unknown>> = {}\n  const cells = row.getAllCells()\n  for (let i = 0; i < cells.length; i++) {\n    const cell = cells[i]!\n    result[cell.column.id] = cell\n  }\n  return result\n}\n\n/**\n * Resolves the stable id for a row.\n *\n * `options.getRowId` wins when provided. Otherwise root rows use their index\n * and child rows append their index to the parent id, such as `0.2`.\n *\n * @example\n * ```ts\n * const id = table_getRowId(originalRow, table, index, parentRow)\n * ```\n */\nexport function table_getRowId<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  originalRow: TData,\n  table: Table_Internal<TFeatures, TData>,\n  index: number,\n  parent?: Row<TFeatures, TData>,\n) {\n  return (\n    table.options.getRowId?.(originalRow, index, parent) ??\n    `${parent ? [parent.id, index].join('.') : index}`\n  )\n}\n\n/**\n * Looks up a row by id from the current or full row model.\n *\n * By default this searches `table.getRowModel()`. Passing `searchAll` searches\n * the pre-pagination model first, then falls back to the core model.\n *\n * @example\n * ```ts\n * const row = table_getRow(table, rowId, true)\n * ```\n */\nexport function table_getRow<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(\n  table: Table_Internal<TFeatures, TData>,\n  rowId: string,\n  searchAll?: boolean,\n): Row<TFeatures, TData> {\n  // TODO - simplify this across different row models\n  let row = (searchAll ? table.getPrePaginatedRowModel() : table.getRowModel())\n    .rowsById[rowId]\n\n  if (!row) {\n    row = table.getCoreRowModel().rowsById[rowId]\n    if (!row) {\n      if (process.env.NODE_ENV === 'development') {\n        throw new Error(`getRow could not find row with ID: ${rowId}`)\n      }\n      throw new Error()\n    }\n  }\n\n  return row\n}\n"],"mappings":";;;;;;;;;;;;;;;AAmBA,SAAgB,aAGd,KAA4B,UAAkB;CAC9C,IAAI,IAAI,aAAa,eAAe,QAAQ,GAC1C,OAAO,IAAI,aAAa;CAG1B,MAAM,SAAS,IAAI,MAAM,UAAU,QAAQ;CAE3C,IAAI,kDAAC,OAAQ,aACX;CAGF,IAAI,aAAa,YAAY,OAAO,WAAW,IAAI,UAAU,IAAI,KAAK;CAEtE,OAAO,IAAI,aAAa;AAC1B;;;;;;;;;;;;AAaA,SAAgB,oBAGd,KAA4B,UAAkB;CAC9C,IAAI,IAAI,mBAAmB,eAAe,QAAQ,GAChD,OAAO,IAAI,mBAAmB;CAGhC,MAAM,SAAS,IAAI,MAAM,UAAU,QAAQ;CAE3C,IAAI,kDAAC,OAAQ,aACX;CAGF,IAAI,CAAC,OAAO,UAAU,iBAAiB;EACrC,IAAI,mBAAmB,YAAY,CAAC,IAAI,SAAS,QAAQ,CAAC;EAC1D,OAAO,IAAI,mBAAmB;CAChC;CAEA,IAAI,mBAAmB,YAAY,OAAO,UAAU,gBAClD,IAAI,UACJ,IAAI,KACN;CAEA,OAAO,IAAI,mBAAmB;AAChC;;;;;;;;;;;;AAaA,SAAgB,gBAGd,KAA4B,UAAkB;CAC9C,OAAO,IAAI,SAAS,QAAQ,KAAK,IAAI,MAAM,QAAQ;AACrD;;;;;;;;;;;AAYA,SAAgB,gBAGd,KAA0D;CAC1D,OAAO,UAAU,IAAI,UAAU,MAAM,EAAE,OAAO;AAChD;;;;;;;;;;;;AAaA,SAAgB,iBAGd,KAA4B;CAC5B,OAAO,IAAI,WAAW,IAAI,MAAM,OAAO,IAAI,UAAU,IAAI,IAAI;AAC/D;;;;;;;;;;;AAYA,SAAgB,kBAGd,KAA4B;CAC5B,MAAM,aAA2C,CAAC;CAClD,IAAI,aAAa;CAEjB,OAAO,MAAM;EACX,MAAM,YAAY,WAAW,aAAa;EAC1C,IAAI,CAAC,WAAW;EAChB,WAAW,KAAK,SAAS;EACzB,aAAa;CACf;CACA,OAAO,WAAW,QAAQ;AAC5B;;;;;;;;;;;;AAaA,SAAgB,gBAGd,KAAoE;CACpE,MAAM,UAAU,IAAI,MAAM,kBAAkB;CAC5C,MAAM,QAAgD,IAAI,MACxD,QAAQ,MACV;CACA,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,QAAQ,KAClC,MAAM,KAAK,cAAc,QAAQ,IAAK,KAAK,IAAI,KAAK;CAEtD,OAAO;AACT;;;;;;;;;;;AAYA,SAAgB,0BAGd,KAA4B;CAC5B,MAAM,SAA0D,CAAC;CACjE,MAAM,QAAQ,IAAI,YAAY;CAC9B,KAAK,IAAI,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;EACrC,MAAM,OAAO,MAAM;EACnB,OAAO,KAAK,OAAO,MAAM;CAC3B;CACA,OAAO;AACT;;;;;;;;;;;;AAaA,SAAgB,eAId,aACA,OACA,OACA,QACA;;CACA,mDACE,MAAM,SAAQ,6GAAW,aAAa,OAAO,MAAM,MACnD,GAAG,SAAS,CAAC,OAAO,IAAI,KAAK,EAAE,KAAK,GAAG,IAAI;AAE/C;;;;;;;;;;;;AAaA,SAAgB,aAId,OACA,OACA,WACuB;CAEvB,IAAI,OAAO,YAAY,MAAM,wBAAwB,IAAI,MAAM,YAAY,GACxE,SAAS;CAEZ,IAAI,CAAC,KAAK;EACR,MAAM,MAAM,gBAAgB,EAAE,SAAS;EACvC,IAAI,CAAC,KAAK;GACR,IAAI,QAAQ,IAAI,aAAa,eAC3B,MAAM,IAAI,MAAM,sCAAsC,OAAO;GAE/D,MAAM,IAAI,MAAM;EAClB;CACF;CAEA,OAAO;AACT"}

package/dist/core/table/constructTable.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"constructTable.cjs","names":["cloneState","coreFeatures","atomToStore"],"sources":["../../../src/core/table/constructTable.ts"],"sourcesContent":["import { coreFeatures } from '../coreFeatures'\nimport { cloneState } from '../../utils'\nimport { atomToStore } from '../reactivity/coreReactivityFeature.utils'\nimport { table_syncExternalStateToBaseAtoms } from './coreTablesFeature.utils'\nimport type { RowData } from '../../types/type-utils'\nimport type { TableFeature, TableFeatures } from '../../types/TableFeatures'\nimport type { Table, Table_Internal } from '../../types/Table'\nimport type { TableOptions } from '../../types/TableOptions'\nimport type { TableState } from '../../types/TableState'\n\n/**\n * Builds the initial table state from registered features and user initial state.\n *\n * Each feature contributes its default state before user-provided `initialState` values are merged in.\n */\nexport function getInitialTableState<TFeatures extends TableFeatures>(\n  features: TFeatures,\n  initialState: Partial<TableState<TFeatures>> | undefined = {},\n): TableState<TFeatures> {\n  Object.values(features).forEach((feature) => {\n    initialState = feature.getInitialState?.(initialState) ?? initialState\n  })\n  return cloneState(initialState) as TableState<TFeatures>\n}\n\n/**\n * Constructs a table instance from normalized table internals.\n *\n * This wires core properties, feature prototype APIs, and instance data used by table rendering and row-model operations.\n */\nexport function constructTable<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(tableOptions: TableOptions<TFeatures, TData>): Table<TFeatures, TData> {\n  const _reactivity = tableOptions._features.coreReativityFeature!\n\n  const table = {\n    _reactivity,\n    _features: { ...coreFeatures, ...tableOptions._features },\n    _rowModels: {},\n    _rowModelFns: {},\n    baseAtoms: {},\n    atoms: {},\n  } as Table_Internal<TFeatures, TData>\n\n  const featuresList: Array<TableFeature<{}>> = Object.values(table._features)\n\n  const defaultOptions = featuresList.reduce((obj, feature) => {\n    return Object.assign(obj, feature.getDefaultTableOptions?.(table))\n  }, {}) as TableOptions<TFeatures, TData>\n\n  const mergedOptions = { ...defaultOptions, ...tableOptions }\n\n  if (_reactivity.createOptionsStore) {\n    // @ts-ignore - direct set\n    table.optionsStore = _reactivity.createWritableAtom<\n      TableOptions<TFeatures, TData>\n    >(mergedOptions, { debugName: 'table/optionsStore' })\n    Object.defineProperty(table, 'options', {\n      configurable: true,\n      enumerable: true,\n      get() {\n        return table.optionsStore!.get()\n      },\n      set(value) {\n        table.optionsStore!.set(() => value) // or your real update shape\n      },\n    })\n  } else {\n    table.options = mergedOptions\n  }\n\n  table.initialState = getInitialTableState(\n    table._features,\n    table.options.initialState,\n  )\n\n  const stateKeys = Object.keys(table.initialState) as Array<\n    string & keyof TableState<TFeatures>\n  >\n\n  for (let i = 0; i < stateKeys.length; i++) {\n    const key = stateKeys[i]!\n    // create writable base atom\n    table.baseAtoms[key] = _reactivity.createWritableAtom(\n      table.initialState[key],\n      {\n        debugName: `table/baseAtoms/${key}`,\n      },\n    ) as any\n\n    // create readonly derived atom: on each get(), read either external atom or base atom\n    ;(table.atoms as any)[key] = _reactivity.createReadonlyAtom(\n      () => {\n        const externalAtom = table.options.atoms?.[key]\n        if (externalAtom) {\n          return externalAtom.get()\n        }\n        return table.baseAtoms[key].get()\n      },\n      { debugName: `table/atoms/${key}` },\n    )\n  }\n\n  table_syncExternalStateToBaseAtoms(table)\n\n  table.store = atomToStore(\n    _reactivity.createReadonlyAtom(\n      () => {\n        const snapshot = {} as TableState<TFeatures>\n        for (let i = 0; i < stateKeys.length; i++) {\n          const key = stateKeys[i]!\n          snapshot[key] = table.atoms[key].get()\n        }\n        return snapshot\n      },\n      { debugName: 'table/store' },\n    ),\n  )\n\n  if (\n    process.env.NODE_ENV === 'development' &&\n    (tableOptions.debugAll || tableOptions.debugTable)\n  ) {\n    const features = Object.keys(table._features)\n    const rowModels = Object.keys(table.options._rowModels || {})\n    const states = Object.keys(table.initialState)\n\n    console.log(\n      `Constructing Table Instance\n\n  Features:   ${features.join('\\n              ')}\n\n  Row Models: ${rowModels.length ? rowModels.join('\\n              ') : '(none)'}\n\n  States:     ${states.join('\\n              ')}\\n`,\n      { table },\n    )\n  }\n\n  for (let i = 0; i < featuresList.length; i++) {\n    featuresList[i]!.constructTableAPIs?.(table)\n  }\n\n  return table\n}\n"],"mappings":";;;;;;;;;;;AAeA,SAAgB,qBACd,UACA,eAA2D,EAAE,EACtC;CACvB,OAAO,OAAO,SAAS,CAAC,SAAS,YAAY;;EAC3C,yCAAe,QAAQ,6GAAkB,aAAa,KAAI;GAC1D;CACF,OAAOA,yBAAW,aAAa;;;;;;;AAQjC,SAAgB,eAGd,cAAuE;CACvE,MAAM,cAAc,aAAa,UAAU;CAE3C,MAAM,QAAQ;EACZ;EACA,WAAW;GAAE,GAAGC;GAAc,GAAG,aAAa;GAAW;EACzD,YAAY,EAAE;EACd,cAAc,EAAE;EAChB,WAAW,EAAE;EACb,OAAO,EAAE;EACV;CAED,MAAM,eAAwC,OAAO,OAAO,MAAM,UAAU;CAM5E,MAAM,gBAAgB;EAAE,GAJD,aAAa,QAAQ,KAAK,YAAY;;GAC3D,OAAO,OAAO,OAAO,8BAAK,QAAQ,oHAAyB,MAAM,CAAC;KACjE,EAAE,CAEoC;EAAE,GAAG;EAAc;CAE5D,IAAI,YAAY,oBAAoB;EAElC,MAAM,eAAe,YAAY,mBAE/B,eAAe,EAAE,WAAW,sBAAsB,CAAC;EACrD,OAAO,eAAe,OAAO,WAAW;GACtC,cAAc;GACd,YAAY;GACZ,MAAM;IACJ,OAAO,MAAM,aAAc,KAAK;;GAElC,IAAI,OAAO;IACT,MAAM,aAAc,UAAU,MAAM;;GAEvC,CAAC;QAEF,MAAM,UAAU;CAGlB,MAAM,eAAe,qBACnB,MAAM,WACN,MAAM,QAAQ,aACf;CAED,MAAM,YAAY,OAAO,KAAK,MAAM,aAAa;CAIjD,KAAK,IAAI,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;EACzC,MAAM,MAAM,UAAU;EAEtB,MAAM,UAAU,OAAO,YAAY,mBACjC,MAAM,aAAa,MACnB,EACE,WAAW,mBAAmB,OAC/B,CACF;EAGA,AAAC,MAAM,MAAc,OAAO,YAAY,yBACjC;;GACJ,MAAM,uCAAe,MAAM,QAAQ,mFAAQ;GAC3C,IAAI,cACF,OAAO,aAAa,KAAK;GAE3B,OAAO,MAAM,UAAU,KAAK,KAAK;KAEnC,EAAE,WAAW,eAAe,OAAO,CACpC;;CAGH,mEAAmC,MAAM;CAEzC,MAAM,QAAQC,gDACZ,YAAY,yBACJ;EACJ,MAAM,WAAW,EAAE;EACnB,KAAK,IAAI,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;GACzC,MAAM,MAAM,UAAU;GACtB,SAAS,OAAO,MAAM,MAAM,KAAK,KAAK;;EAExC,OAAO;IAET,EAAE,WAAW,eAAe,CAC7B,CACF;CAED,IACE,QAAQ,IAAI,aAAa,kBACxB,aAAa,YAAY,aAAa,aACvC;EACA,MAAM,WAAW,OAAO,KAAK,MAAM,UAAU;EAC7C,MAAM,YAAY,OAAO,KAAK,MAAM,QAAQ,cAAc,EAAE,CAAC;EAC7D,MAAM,SAAS,OAAO,KAAK,MAAM,aAAa;EAE9C,QAAQ,IACN;;gBAEU,SAAS,KAAK,mBAAmB,CAAC;;gBAElC,UAAU,SAAS,UAAU,KAAK,mBAAmB,GAAG,SAAS;;gBAEjE,OAAO,KAAK,mBAAmB,CAAC,KAC1C,EAAE,OAAO,CACV;;CAGH,KAAK,IAAI,IAAI,GAAG,IAAI,aAAa,QAAQ,KAAK;;EAC5C,4CAAa,IAAI,iGAAqB,MAAM;;CAG9C,OAAO"}
+{"version":3,"file":"constructTable.cjs","names":["cloneState","coreFeatures","atomToStore"],"sources":["../../../src/core/table/constructTable.ts"],"sourcesContent":["import { coreFeatures } from '../coreFeatures'\nimport { cloneState } from '../../utils'\nimport { atomToStore } from '../reactivity/coreReactivityFeature.utils'\nimport { table_syncExternalStateToBaseAtoms } from './coreTablesFeature.utils'\nimport type { RowData } from '../../types/type-utils'\nimport type { TableFeature, TableFeatures } from '../../types/TableFeatures'\nimport type { Table, Table_Internal } from '../../types/Table'\nimport type { TableOptions } from '../../types/TableOptions'\nimport type { TableState } from '../../types/TableState'\n\n/**\n * Builds the initial table state from registered features and user initial state.\n *\n * Each feature contributes its default state before user-provided `initialState` values are merged in.\n */\nexport function getInitialTableState<TFeatures extends TableFeatures>(\n  features: TFeatures,\n  initialState: Partial<TableState<TFeatures>> | undefined = {},\n): TableState<TFeatures> {\n  Object.values(features).forEach((feature) => {\n    initialState = feature.getInitialState?.(initialState) ?? initialState\n  })\n  return cloneState(initialState) as TableState<TFeatures>\n}\n\n/**\n * Constructs a table instance from normalized table internals.\n *\n * This wires core properties, feature prototype APIs, and instance data used by table rendering and row-model operations.\n */\nexport function constructTable<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(tableOptions: TableOptions<TFeatures, TData>): Table<TFeatures, TData> {\n  const _reactivity = tableOptions._features.coreReativityFeature!\n\n  const table = {\n    _reactivity,\n    _features: { ...coreFeatures, ...tableOptions._features },\n    _rowModels: {},\n    _rowModelFns: {},\n    baseAtoms: {},\n    atoms: {},\n  } as Table_Internal<TFeatures, TData>\n\n  const featuresList: Array<TableFeature<{}>> = Object.values(table._features)\n\n  const defaultOptions = featuresList.reduce((obj, feature) => {\n    return Object.assign(obj, feature.getDefaultTableOptions?.(table))\n  }, {}) as TableOptions<TFeatures, TData>\n\n  const mergedOptions = { ...defaultOptions, ...tableOptions }\n\n  if (_reactivity.createOptionsStore) {\n    // @ts-ignore - direct set\n    table.optionsStore = _reactivity.createWritableAtom<\n      TableOptions<TFeatures, TData>\n    >(mergedOptions, { debugName: 'table/optionsStore' })\n    Object.defineProperty(table, 'options', {\n      configurable: true,\n      enumerable: true,\n      get() {\n        return table.optionsStore!.get()\n      },\n      set(value) {\n        table.optionsStore!.set(() => value) // or your real update shape\n      },\n    })\n  } else {\n    table.options = mergedOptions\n  }\n\n  table.initialState = getInitialTableState(\n    table._features,\n    table.options.initialState,\n  )\n\n  const stateKeys = Object.keys(table.initialState) as Array<\n    string & keyof TableState<TFeatures>\n  >\n\n  for (let i = 0; i < stateKeys.length; i++) {\n    const key = stateKeys[i]!\n    // create writable base atom\n    table.baseAtoms[key] = _reactivity.createWritableAtom(\n      table.initialState[key],\n      {\n        debugName: `table/baseAtoms/${key}`,\n      },\n    ) as any\n\n    // create readonly derived atom: on each get(), read either external atom or base atom\n    ;(table.atoms as any)[key] = _reactivity.createReadonlyAtom(\n      () => {\n        const externalAtom = table.options.atoms?.[key]\n        if (externalAtom) {\n          return externalAtom.get()\n        }\n        return table.baseAtoms[key].get()\n      },\n      { debugName: `table/atoms/${key}` },\n    )\n  }\n\n  table_syncExternalStateToBaseAtoms(table)\n\n  table.store = atomToStore(\n    _reactivity.createReadonlyAtom(\n      () => {\n        const snapshot = {} as TableState<TFeatures>\n        for (let i = 0; i < stateKeys.length; i++) {\n          const key = stateKeys[i]!\n          snapshot[key] = table.atoms[key].get()\n        }\n        return snapshot\n      },\n      { debugName: 'table/store' },\n    ),\n  )\n\n  if (\n    process.env.NODE_ENV === 'development' &&\n    (tableOptions.debugAll || tableOptions.debugTable)\n  ) {\n    const features = Object.keys(table._features)\n    const rowModels = Object.keys(table.options._rowModels || {})\n    const states = Object.keys(table.initialState)\n\n    console.log(\n      `Constructing Table Instance\n\n  Features:   ${features.join('\\n              ')}\n\n  Row Models: ${rowModels.length ? rowModels.join('\\n              ') : '(none)'}\n\n  States:     ${states.join('\\n              ')}\\n`,\n      { table },\n    )\n  }\n\n  for (let i = 0; i < featuresList.length; i++) {\n    featuresList[i]!.constructTableAPIs?.(table)\n  }\n\n  return table\n}\n"],"mappings":";;;;;;;;;;;AAeA,SAAgB,qBACd,UACA,eAA2D,CAAC,GACrC;CACvB,OAAO,OAAO,QAAQ,EAAE,SAAS,YAAY;;EAC3C,yCAAe,QAAQ,6GAAkB,YAAY,MAAK;CAC5D,CAAC;CACD,OAAOA,yBAAW,YAAY;AAChC;;;;;;AAOA,SAAgB,eAGd,cAAuE;CACvE,MAAM,cAAc,aAAa,UAAU;CAE3C,MAAM,QAAQ;EACZ;EACA,WAAW;GAAE,GAAGC;GAAc,GAAG,aAAa;EAAU;EACxD,YAAY,CAAC;EACb,cAAc,CAAC;EACf,WAAW,CAAC;EACZ,OAAO,CAAC;CACV;CAEA,MAAM,eAAwC,OAAO,OAAO,MAAM,SAAS;CAM3E,MAAM,gBAAgB;EAAE,GAJD,aAAa,QAAQ,KAAK,YAAY;;GAC3D,OAAO,OAAO,OAAO,8BAAK,QAAQ,oHAAyB,KAAK,CAAC;EACnE,GAAG,CAAC,CAEoC;EAAG,GAAG;CAAa;CAE3D,IAAI,YAAY,oBAAoB;EAElC,MAAM,eAAe,YAAY,mBAE/B,eAAe,EAAE,WAAW,qBAAqB,CAAC;EACpD,OAAO,eAAe,OAAO,WAAW;GACtC,cAAc;GACd,YAAY;GACZ,MAAM;IACJ,OAAO,MAAM,aAAc,IAAI;GACjC;GACA,IAAI,OAAO;IACT,MAAM,aAAc,UAAU,KAAK;GACrC;EACF,CAAC;CACH,OACE,MAAM,UAAU;CAGlB,MAAM,eAAe,qBACnB,MAAM,WACN,MAAM,QAAQ,YAChB;CAEA,MAAM,YAAY,OAAO,KAAK,MAAM,YAAY;CAIhD,KAAK,IAAI,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;EACzC,MAAM,MAAM,UAAU;EAEtB,MAAM,UAAU,OAAO,YAAY,mBACjC,MAAM,aAAa,MACnB,EACE,WAAW,mBAAmB,MAChC,CACF;EAGC,AAAC,MAAM,MAAc,OAAO,YAAY,yBACjC;;GACJ,MAAM,uCAAe,MAAM,QAAQ,mFAAQ;GAC3C,IAAI,cACF,OAAO,aAAa,IAAI;GAE1B,OAAO,MAAM,UAAU,KAAK,IAAI;EAClC,GACA,EAAE,WAAW,eAAe,MAAM,CACpC;CACF;CAEA,mEAAmC,KAAK;CAExC,MAAM,QAAQC,gDACZ,YAAY,yBACJ;EACJ,MAAM,WAAW,CAAC;EAClB,KAAK,IAAI,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;GACzC,MAAM,MAAM,UAAU;GACtB,SAAS,OAAO,MAAM,MAAM,KAAK,IAAI;EACvC;EACA,OAAO;CACT,GACA,EAAE,WAAW,cAAc,CAC7B,CACF;CAEA,IACE,QAAQ,IAAI,aAAa,kBACxB,aAAa,YAAY,aAAa,aACvC;EACA,MAAM,WAAW,OAAO,KAAK,MAAM,SAAS;EAC5C,MAAM,YAAY,OAAO,KAAK,MAAM,QAAQ,cAAc,CAAC,CAAC;EAC5D,MAAM,SAAS,OAAO,KAAK,MAAM,YAAY;EAE7C,QAAQ,IACN;;gBAEU,SAAS,KAAK,kBAAkB,EAAE;;gBAElC,UAAU,SAAS,UAAU,KAAK,kBAAkB,IAAI,SAAS;;gBAEjE,OAAO,KAAK,kBAAkB,EAAE,KAC1C,EAAE,MAAM,CACV;CACF;CAEA,KAAK,IAAI,IAAI,GAAG,IAAI,aAAa,QAAQ,KAAK;;EAC5C,4CAAa,IAAI,iGAAqB,KAAK;CAC7C;CAEA,OAAO;AACT"}

package/dist/core/table/constructTable.js.map

@@ -1 +1 @@
-{"version":3,"file":"constructTable.js","names":[],"sources":["../../../src/core/table/constructTable.ts"],"sourcesContent":["import { coreFeatures } from '../coreFeatures'\nimport { cloneState } from '../../utils'\nimport { atomToStore } from '../reactivity/coreReactivityFeature.utils'\nimport { table_syncExternalStateToBaseAtoms } from './coreTablesFeature.utils'\nimport type { RowData } from '../../types/type-utils'\nimport type { TableFeature, TableFeatures } from '../../types/TableFeatures'\nimport type { Table, Table_Internal } from '../../types/Table'\nimport type { TableOptions } from '../../types/TableOptions'\nimport type { TableState } from '../../types/TableState'\n\n/**\n * Builds the initial table state from registered features and user initial state.\n *\n * Each feature contributes its default state before user-provided `initialState` values are merged in.\n */\nexport function getInitialTableState<TFeatures extends TableFeatures>(\n  features: TFeatures,\n  initialState: Partial<TableState<TFeatures>> | undefined = {},\n): TableState<TFeatures> {\n  Object.values(features).forEach((feature) => {\n    initialState = feature.getInitialState?.(initialState) ?? initialState\n  })\n  return cloneState(initialState) as TableState<TFeatures>\n}\n\n/**\n * Constructs a table instance from normalized table internals.\n *\n * This wires core properties, feature prototype APIs, and instance data used by table rendering and row-model operations.\n */\nexport function constructTable<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(tableOptions: TableOptions<TFeatures, TData>): Table<TFeatures, TData> {\n  const _reactivity = tableOptions._features.coreReativityFeature!\n\n  const table = {\n    _reactivity,\n    _features: { ...coreFeatures, ...tableOptions._features },\n    _rowModels: {},\n    _rowModelFns: {},\n    baseAtoms: {},\n    atoms: {},\n  } as Table_Internal<TFeatures, TData>\n\n  const featuresList: Array<TableFeature<{}>> = Object.values(table._features)\n\n  const defaultOptions = featuresList.reduce((obj, feature) => {\n    return Object.assign(obj, feature.getDefaultTableOptions?.(table))\n  }, {}) as TableOptions<TFeatures, TData>\n\n  const mergedOptions = { ...defaultOptions, ...tableOptions }\n\n  if (_reactivity.createOptionsStore) {\n    // @ts-ignore - direct set\n    table.optionsStore = _reactivity.createWritableAtom<\n      TableOptions<TFeatures, TData>\n    >(mergedOptions, { debugName: 'table/optionsStore' })\n    Object.defineProperty(table, 'options', {\n      configurable: true,\n      enumerable: true,\n      get() {\n        return table.optionsStore!.get()\n      },\n      set(value) {\n        table.optionsStore!.set(() => value) // or your real update shape\n      },\n    })\n  } else {\n    table.options = mergedOptions\n  }\n\n  table.initialState = getInitialTableState(\n    table._features,\n    table.options.initialState,\n  )\n\n  const stateKeys = Object.keys(table.initialState) as Array<\n    string & keyof TableState<TFeatures>\n  >\n\n  for (let i = 0; i < stateKeys.length; i++) {\n    const key = stateKeys[i]!\n    // create writable base atom\n    table.baseAtoms[key] = _reactivity.createWritableAtom(\n      table.initialState[key],\n      {\n        debugName: `table/baseAtoms/${key}`,\n      },\n    ) as any\n\n    // create readonly derived atom: on each get(), read either external atom or base atom\n    ;(table.atoms as any)[key] = _reactivity.createReadonlyAtom(\n      () => {\n        const externalAtom = table.options.atoms?.[key]\n        if (externalAtom) {\n          return externalAtom.get()\n        }\n        return table.baseAtoms[key].get()\n      },\n      { debugName: `table/atoms/${key}` },\n    )\n  }\n\n  table_syncExternalStateToBaseAtoms(table)\n\n  table.store = atomToStore(\n    _reactivity.createReadonlyAtom(\n      () => {\n        const snapshot = {} as TableState<TFeatures>\n        for (let i = 0; i < stateKeys.length; i++) {\n          const key = stateKeys[i]!\n          snapshot[key] = table.atoms[key].get()\n        }\n        return snapshot\n      },\n      { debugName: 'table/store' },\n    ),\n  )\n\n  if (\n    process.env.NODE_ENV === 'development' &&\n    (tableOptions.debugAll || tableOptions.debugTable)\n  ) {\n    const features = Object.keys(table._features)\n    const rowModels = Object.keys(table.options._rowModels || {})\n    const states = Object.keys(table.initialState)\n\n    console.log(\n      `Constructing Table Instance\n\n  Features:   ${features.join('\\n              ')}\n\n  Row Models: ${rowModels.length ? rowModels.join('\\n              ') : '(none)'}\n\n  States:     ${states.join('\\n              ')}\\n`,\n      { table },\n    )\n  }\n\n  for (let i = 0; i < featuresList.length; i++) {\n    featuresList[i]!.constructTableAPIs?.(table)\n  }\n\n  return table\n}\n"],"mappings":";;;;;;;;;;;AAeA,SAAgB,qBACd,UACA,eAA2D,EAAE,EACtC;CACvB,OAAO,OAAO,SAAS,CAAC,SAAS,YAAY;;EAC3C,yCAAe,QAAQ,6GAAkB,aAAa,KAAI;GAC1D;CACF,OAAO,WAAW,aAAa;;;;;;;AAQjC,SAAgB,eAGd,cAAuE;CACvE,MAAM,cAAc,aAAa,UAAU;CAE3C,MAAM,QAAQ;EACZ;EACA,WAAW;GAAE,GAAG;GAAc,GAAG,aAAa;GAAW;EACzD,YAAY,EAAE;EACd,cAAc,EAAE;EAChB,WAAW,EAAE;EACb,OAAO,EAAE;EACV;CAED,MAAM,eAAwC,OAAO,OAAO,MAAM,UAAU;CAM5E,MAAM,gBAAgB;EAAE,GAJD,aAAa,QAAQ,KAAK,YAAY;;GAC3D,OAAO,OAAO,OAAO,8BAAK,QAAQ,oHAAyB,MAAM,CAAC;KACjE,EAAE,CAEoC;EAAE,GAAG;EAAc;CAE5D,IAAI,YAAY,oBAAoB;EAElC,MAAM,eAAe,YAAY,mBAE/B,eAAe,EAAE,WAAW,sBAAsB,CAAC;EACrD,OAAO,eAAe,OAAO,WAAW;GACtC,cAAc;GACd,YAAY;GACZ,MAAM;IACJ,OAAO,MAAM,aAAc,KAAK;;GAElC,IAAI,OAAO;IACT,MAAM,aAAc,UAAU,MAAM;;GAEvC,CAAC;QAEF,MAAM,UAAU;CAGlB,MAAM,eAAe,qBACnB,MAAM,WACN,MAAM,QAAQ,aACf;CAED,MAAM,YAAY,OAAO,KAAK,MAAM,aAAa;CAIjD,KAAK,IAAI,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;EACzC,MAAM,MAAM,UAAU;EAEtB,MAAM,UAAU,OAAO,YAAY,mBACjC,MAAM,aAAa,MACnB,EACE,WAAW,mBAAmB,OAC/B,CACF;EAGA,AAAC,MAAM,MAAc,OAAO,YAAY,yBACjC;;GACJ,MAAM,uCAAe,MAAM,QAAQ,mFAAQ;GAC3C,IAAI,cACF,OAAO,aAAa,KAAK;GAE3B,OAAO,MAAM,UAAU,KAAK,KAAK;KAEnC,EAAE,WAAW,eAAe,OAAO,CACpC;;CAGH,mCAAmC,MAAM;CAEzC,MAAM,QAAQ,YACZ,YAAY,yBACJ;EACJ,MAAM,WAAW,EAAE;EACnB,KAAK,IAAI,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;GACzC,MAAM,MAAM,UAAU;GACtB,SAAS,OAAO,MAAM,MAAM,KAAK,KAAK;;EAExC,OAAO;IAET,EAAE,WAAW,eAAe,CAC7B,CACF;CAED,IACE,QAAQ,IAAI,aAAa,kBACxB,aAAa,YAAY,aAAa,aACvC;EACA,MAAM,WAAW,OAAO,KAAK,MAAM,UAAU;EAC7C,MAAM,YAAY,OAAO,KAAK,MAAM,QAAQ,cAAc,EAAE,CAAC;EAC7D,MAAM,SAAS,OAAO,KAAK,MAAM,aAAa;EAE9C,QAAQ,IACN;;gBAEU,SAAS,KAAK,mBAAmB,CAAC;;gBAElC,UAAU,SAAS,UAAU,KAAK,mBAAmB,GAAG,SAAS;;gBAEjE,OAAO,KAAK,mBAAmB,CAAC,KAC1C,EAAE,OAAO,CACV;;CAGH,KAAK,IAAI,IAAI,GAAG,IAAI,aAAa,QAAQ,KAAK;;EAC5C,4CAAa,IAAI,iGAAqB,MAAM;;CAG9C,OAAO"}
+{"version":3,"file":"constructTable.js","names":[],"sources":["../../../src/core/table/constructTable.ts"],"sourcesContent":["import { coreFeatures } from '../coreFeatures'\nimport { cloneState } from '../../utils'\nimport { atomToStore } from '../reactivity/coreReactivityFeature.utils'\nimport { table_syncExternalStateToBaseAtoms } from './coreTablesFeature.utils'\nimport type { RowData } from '../../types/type-utils'\nimport type { TableFeature, TableFeatures } from '../../types/TableFeatures'\nimport type { Table, Table_Internal } from '../../types/Table'\nimport type { TableOptions } from '../../types/TableOptions'\nimport type { TableState } from '../../types/TableState'\n\n/**\n * Builds the initial table state from registered features and user initial state.\n *\n * Each feature contributes its default state before user-provided `initialState` values are merged in.\n */\nexport function getInitialTableState<TFeatures extends TableFeatures>(\n  features: TFeatures,\n  initialState: Partial<TableState<TFeatures>> | undefined = {},\n): TableState<TFeatures> {\n  Object.values(features).forEach((feature) => {\n    initialState = feature.getInitialState?.(initialState) ?? initialState\n  })\n  return cloneState(initialState) as TableState<TFeatures>\n}\n\n/**\n * Constructs a table instance from normalized table internals.\n *\n * This wires core properties, feature prototype APIs, and instance data used by table rendering and row-model operations.\n */\nexport function constructTable<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(tableOptions: TableOptions<TFeatures, TData>): Table<TFeatures, TData> {\n  const _reactivity = tableOptions._features.coreReativityFeature!\n\n  const table = {\n    _reactivity,\n    _features: { ...coreFeatures, ...tableOptions._features },\n    _rowModels: {},\n    _rowModelFns: {},\n    baseAtoms: {},\n    atoms: {},\n  } as Table_Internal<TFeatures, TData>\n\n  const featuresList: Array<TableFeature<{}>> = Object.values(table._features)\n\n  const defaultOptions = featuresList.reduce((obj, feature) => {\n    return Object.assign(obj, feature.getDefaultTableOptions?.(table))\n  }, {}) as TableOptions<TFeatures, TData>\n\n  const mergedOptions = { ...defaultOptions, ...tableOptions }\n\n  if (_reactivity.createOptionsStore) {\n    // @ts-ignore - direct set\n    table.optionsStore = _reactivity.createWritableAtom<\n      TableOptions<TFeatures, TData>\n    >(mergedOptions, { debugName: 'table/optionsStore' })\n    Object.defineProperty(table, 'options', {\n      configurable: true,\n      enumerable: true,\n      get() {\n        return table.optionsStore!.get()\n      },\n      set(value) {\n        table.optionsStore!.set(() => value) // or your real update shape\n      },\n    })\n  } else {\n    table.options = mergedOptions\n  }\n\n  table.initialState = getInitialTableState(\n    table._features,\n    table.options.initialState,\n  )\n\n  const stateKeys = Object.keys(table.initialState) as Array<\n    string & keyof TableState<TFeatures>\n  >\n\n  for (let i = 0; i < stateKeys.length; i++) {\n    const key = stateKeys[i]!\n    // create writable base atom\n    table.baseAtoms[key] = _reactivity.createWritableAtom(\n      table.initialState[key],\n      {\n        debugName: `table/baseAtoms/${key}`,\n      },\n    ) as any\n\n    // create readonly derived atom: on each get(), read either external atom or base atom\n    ;(table.atoms as any)[key] = _reactivity.createReadonlyAtom(\n      () => {\n        const externalAtom = table.options.atoms?.[key]\n        if (externalAtom) {\n          return externalAtom.get()\n        }\n        return table.baseAtoms[key].get()\n      },\n      { debugName: `table/atoms/${key}` },\n    )\n  }\n\n  table_syncExternalStateToBaseAtoms(table)\n\n  table.store = atomToStore(\n    _reactivity.createReadonlyAtom(\n      () => {\n        const snapshot = {} as TableState<TFeatures>\n        for (let i = 0; i < stateKeys.length; i++) {\n          const key = stateKeys[i]!\n          snapshot[key] = table.atoms[key].get()\n        }\n        return snapshot\n      },\n      { debugName: 'table/store' },\n    ),\n  )\n\n  if (\n    process.env.NODE_ENV === 'development' &&\n    (tableOptions.debugAll || tableOptions.debugTable)\n  ) {\n    const features = Object.keys(table._features)\n    const rowModels = Object.keys(table.options._rowModels || {})\n    const states = Object.keys(table.initialState)\n\n    console.log(\n      `Constructing Table Instance\n\n  Features:   ${features.join('\\n              ')}\n\n  Row Models: ${rowModels.length ? rowModels.join('\\n              ') : '(none)'}\n\n  States:     ${states.join('\\n              ')}\\n`,\n      { table },\n    )\n  }\n\n  for (let i = 0; i < featuresList.length; i++) {\n    featuresList[i]!.constructTableAPIs?.(table)\n  }\n\n  return table\n}\n"],"mappings":";;;;;;;;;;;AAeA,SAAgB,qBACd,UACA,eAA2D,CAAC,GACrC;CACvB,OAAO,OAAO,QAAQ,EAAE,SAAS,YAAY;;EAC3C,yCAAe,QAAQ,6GAAkB,YAAY,MAAK;CAC5D,CAAC;CACD,OAAO,WAAW,YAAY;AAChC;;;;;;AAOA,SAAgB,eAGd,cAAuE;CACvE,MAAM,cAAc,aAAa,UAAU;CAE3C,MAAM,QAAQ;EACZ;EACA,WAAW;GAAE,GAAG;GAAc,GAAG,aAAa;EAAU;EACxD,YAAY,CAAC;EACb,cAAc,CAAC;EACf,WAAW,CAAC;EACZ,OAAO,CAAC;CACV;CAEA,MAAM,eAAwC,OAAO,OAAO,MAAM,SAAS;CAM3E,MAAM,gBAAgB;EAAE,GAJD,aAAa,QAAQ,KAAK,YAAY;;GAC3D,OAAO,OAAO,OAAO,8BAAK,QAAQ,oHAAyB,KAAK,CAAC;EACnE,GAAG,CAAC,CAEoC;EAAG,GAAG;CAAa;CAE3D,IAAI,YAAY,oBAAoB;EAElC,MAAM,eAAe,YAAY,mBAE/B,eAAe,EAAE,WAAW,qBAAqB,CAAC;EACpD,OAAO,eAAe,OAAO,WAAW;GACtC,cAAc;GACd,YAAY;GACZ,MAAM;IACJ,OAAO,MAAM,aAAc,IAAI;GACjC;GACA,IAAI,OAAO;IACT,MAAM,aAAc,UAAU,KAAK;GACrC;EACF,CAAC;CACH,OACE,MAAM,UAAU;CAGlB,MAAM,eAAe,qBACnB,MAAM,WACN,MAAM,QAAQ,YAChB;CAEA,MAAM,YAAY,OAAO,KAAK,MAAM,YAAY;CAIhD,KAAK,IAAI,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;EACzC,MAAM,MAAM,UAAU;EAEtB,MAAM,UAAU,OAAO,YAAY,mBACjC,MAAM,aAAa,MACnB,EACE,WAAW,mBAAmB,MAChC,CACF;EAGC,AAAC,MAAM,MAAc,OAAO,YAAY,yBACjC;;GACJ,MAAM,uCAAe,MAAM,QAAQ,mFAAQ;GAC3C,IAAI,cACF,OAAO,aAAa,IAAI;GAE1B,OAAO,MAAM,UAAU,KAAK,IAAI;EAClC,GACA,EAAE,WAAW,eAAe,MAAM,CACpC;CACF;CAEA,mCAAmC,KAAK;CAExC,MAAM,QAAQ,YACZ,YAAY,yBACJ;EACJ,MAAM,WAAW,CAAC;EAClB,KAAK,IAAI,IAAI,GAAG,IAAI,UAAU,QAAQ,KAAK;GACzC,MAAM,MAAM,UAAU;GACtB,SAAS,OAAO,MAAM,MAAM,KAAK,IAAI;EACvC;EACA,OAAO;CACT,GACA,EAAE,WAAW,cAAc,CAC7B,CACF;CAEA,IACE,QAAQ,IAAI,aAAa,kBACxB,aAAa,YAAY,aAAa,aACvC;EACA,MAAM,WAAW,OAAO,KAAK,MAAM,SAAS;EAC5C,MAAM,YAAY,OAAO,KAAK,MAAM,QAAQ,cAAc,CAAC,CAAC;EAC5D,MAAM,SAAS,OAAO,KAAK,MAAM,YAAY;EAE7C,QAAQ,IACN;;gBAEU,SAAS,KAAK,kBAAkB,EAAE;;gBAElC,UAAU,SAAS,UAAU,KAAK,kBAAkB,IAAI,SAAS;;gBAEjE,OAAO,KAAK,kBAAkB,EAAE,KAC1C,EAAE,MAAM,CACV;CACF;CAEA,KAAK,IAAI,IAAI,GAAG,IAAI,aAAa,QAAQ,KAAK;;EAC5C,4CAAa,IAAI,iGAAqB,KAAK;CAC7C;CAEA,OAAO;AACT"}

package/dist/core/table/coreTablesFeature.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"coreTablesFeature.cjs","names":["table_reset","table_setOptions"],"sources":["../../../src/core/table/coreTablesFeature.ts"],"sourcesContent":["import { assignTableAPIs } from '../../utils'\nimport { table_reset, table_setOptions } from './coreTablesFeature.utils'\nimport type { RowData } from '../../types/type-utils'\nimport type { TableFeature, TableFeatures } from '../../types/TableFeatures'\n// import type { TableOptions_Table, Table_Table } from './coreTablesFeature.types'\n\nexport interface CoreTablesFeatureConstructors<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n> {\n  // Table: Table_Table<TFeatures, TData>\n  // TableOptions: TableOptions_Table<TFeatures, TData>\n}\n\n/**\n * Creates the stock core tables feature.\n *\n * The returned feature registers its state defaults, option defaults, and instance APIs so it can be included in a `tableFeatures({ ... })` call.\n */\nexport function constructCoreTablesFeature<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(): TableFeature<CoreTablesFeatureConstructors<TFeatures, TData>> {\n  return {\n    constructTableAPIs: (table) => {\n      assignTableAPIs('coreTablesFeature', table, {\n        table_reset: {\n          fn: () => table_reset(table),\n        },\n        table_setOptions: {\n          fn: (updater) => table_setOptions(table, updater),\n        },\n      })\n    },\n  }\n}\n\n/**\n * The Core Tables feature provides the core table functionality for handling state and options.\n */\nexport const coreTablesFeature = constructCoreTablesFeature()\n"],"mappings":";;;;;;;;;AAmBA,SAAgB,6BAGmD;CACjE,OAAO,EACL,qBAAqB,UAAU;EAC7B,8BAAgB,qBAAqB,OAAO;GAC1C,aAAa,EACX,UAAUA,4CAAY,MAAM,EAC7B;GACD,kBAAkB,EAChB,KAAK,YAAYC,iDAAiB,OAAO,QAAQ,EAClD;GACF,CAAC;IAEL;;;;;AAMH,MAAa,oBAAoB,4BAA4B"}
+{"version":3,"file":"coreTablesFeature.cjs","names":["table_reset","table_setOptions"],"sources":["../../../src/core/table/coreTablesFeature.ts"],"sourcesContent":["import { assignTableAPIs } from '../../utils'\nimport { table_reset, table_setOptions } from './coreTablesFeature.utils'\nimport type { RowData } from '../../types/type-utils'\nimport type { TableFeature, TableFeatures } from '../../types/TableFeatures'\n// import type { TableOptions_Table, Table_Table } from './coreTablesFeature.types'\n\nexport interface CoreTablesFeatureConstructors<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n> {\n  // Table: Table_Table<TFeatures, TData>\n  // TableOptions: TableOptions_Table<TFeatures, TData>\n}\n\n/**\n * Creates the stock core tables feature.\n *\n * The returned feature registers its state defaults, option defaults, and instance APIs so it can be included in a `tableFeatures({ ... })` call.\n */\nexport function constructCoreTablesFeature<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(): TableFeature<CoreTablesFeatureConstructors<TFeatures, TData>> {\n  return {\n    constructTableAPIs: (table) => {\n      assignTableAPIs('coreTablesFeature', table, {\n        table_reset: {\n          fn: () => table_reset(table),\n        },\n        table_setOptions: {\n          fn: (updater) => table_setOptions(table, updater),\n        },\n      })\n    },\n  }\n}\n\n/**\n * The Core Tables feature provides the core table functionality for handling state and options.\n */\nexport const coreTablesFeature = constructCoreTablesFeature()\n"],"mappings":";;;;;;;;;AAmBA,SAAgB,6BAGmD;CACjE,OAAO,EACL,qBAAqB,UAAU;EAC7B,8BAAgB,qBAAqB,OAAO;GAC1C,aAAa,EACX,UAAUA,4CAAY,KAAK,EAC7B;GACA,kBAAkB,EAChB,KAAK,YAAYC,iDAAiB,OAAO,OAAO,EAClD;EACF,CAAC;CACH,EACF;AACF;;;;AAKA,MAAa,oBAAoB,2BAA2B"}

package/dist/core/table/coreTablesFeature.js.map

@@ -1 +1 @@
-{"version":3,"file":"coreTablesFeature.js","names":[],"sources":["../../../src/core/table/coreTablesFeature.ts"],"sourcesContent":["import { assignTableAPIs } from '../../utils'\nimport { table_reset, table_setOptions } from './coreTablesFeature.utils'\nimport type { RowData } from '../../types/type-utils'\nimport type { TableFeature, TableFeatures } from '../../types/TableFeatures'\n// import type { TableOptions_Table, Table_Table } from './coreTablesFeature.types'\n\nexport interface CoreTablesFeatureConstructors<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n> {\n  // Table: Table_Table<TFeatures, TData>\n  // TableOptions: TableOptions_Table<TFeatures, TData>\n}\n\n/**\n * Creates the stock core tables feature.\n *\n * The returned feature registers its state defaults, option defaults, and instance APIs so it can be included in a `tableFeatures({ ... })` call.\n */\nexport function constructCoreTablesFeature<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(): TableFeature<CoreTablesFeatureConstructors<TFeatures, TData>> {\n  return {\n    constructTableAPIs: (table) => {\n      assignTableAPIs('coreTablesFeature', table, {\n        table_reset: {\n          fn: () => table_reset(table),\n        },\n        table_setOptions: {\n          fn: (updater) => table_setOptions(table, updater),\n        },\n      })\n    },\n  }\n}\n\n/**\n * The Core Tables feature provides the core table functionality for handling state and options.\n */\nexport const coreTablesFeature = constructCoreTablesFeature()\n"],"mappings":";;;;;;;;;AAmBA,SAAgB,6BAGmD;CACjE,OAAO,EACL,qBAAqB,UAAU;EAC7B,gBAAgB,qBAAqB,OAAO;GAC1C,aAAa,EACX,UAAU,YAAY,MAAM,EAC7B;GACD,kBAAkB,EAChB,KAAK,YAAY,iBAAiB,OAAO,QAAQ,EAClD;GACF,CAAC;IAEL;;;;;AAMH,MAAa,oBAAoB,4BAA4B"}
+{"version":3,"file":"coreTablesFeature.js","names":[],"sources":["../../../src/core/table/coreTablesFeature.ts"],"sourcesContent":["import { assignTableAPIs } from '../../utils'\nimport { table_reset, table_setOptions } from './coreTablesFeature.utils'\nimport type { RowData } from '../../types/type-utils'\nimport type { TableFeature, TableFeatures } from '../../types/TableFeatures'\n// import type { TableOptions_Table, Table_Table } from './coreTablesFeature.types'\n\nexport interface CoreTablesFeatureConstructors<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n> {\n  // Table: Table_Table<TFeatures, TData>\n  // TableOptions: TableOptions_Table<TFeatures, TData>\n}\n\n/**\n * Creates the stock core tables feature.\n *\n * The returned feature registers its state defaults, option defaults, and instance APIs so it can be included in a `tableFeatures({ ... })` call.\n */\nexport function constructCoreTablesFeature<\n  TFeatures extends TableFeatures,\n  TData extends RowData,\n>(): TableFeature<CoreTablesFeatureConstructors<TFeatures, TData>> {\n  return {\n    constructTableAPIs: (table) => {\n      assignTableAPIs('coreTablesFeature', table, {\n        table_reset: {\n          fn: () => table_reset(table),\n        },\n        table_setOptions: {\n          fn: (updater) => table_setOptions(table, updater),\n        },\n      })\n    },\n  }\n}\n\n/**\n * The Core Tables feature provides the core table functionality for handling state and options.\n */\nexport const coreTablesFeature = constructCoreTablesFeature()\n"],"mappings":";;;;;;;;;AAmBA,SAAgB,6BAGmD;CACjE,OAAO,EACL,qBAAqB,UAAU;EAC7B,gBAAgB,qBAAqB,OAAO;GAC1C,aAAa,EACX,UAAU,YAAY,KAAK,EAC7B;GACA,kBAAkB,EAChB,KAAK,YAAY,iBAAiB,OAAO,OAAO,EAClD;EACF,CAAC;CACH,EACF;AACF;;;;AAKA,MAAa,oBAAoB,2BAA2B"}