@tanstack/table-core 9.0.0-alpha.8 → 9.0.0-beta.2

package/src/types/RowModelFns.ts

@@ -0,0 +1,47 @@
+import type { RowModelFns_RowSorting } from '../features/row-sorting/rowSortingFeature.types'
+import type { RowModelFns_ColumnGrouping } from '../features/column-grouping/columnGroupingFeature.types'
+import type { RowData } from './type-utils'
+import type { RowModelFns_ColumnFiltering } from '../features/column-filtering/columnFilteringFeature.types'
+import type {
+  ExtractFeatureMapTypes,
+  ExtractFeatureTypes,
+  TableFeatures,
+} from './TableFeatures'
+
+/**
+ * Use this interface as a target for declaration merging to add your own plugin properties.
+ * Note: This will affect the types of all tables in your project.
+ */
+export interface RowModelFns_Plugins<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> {}
+
+export interface RowModelFns_Core {}
+
+export interface RowModelFns_FeatureMap<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> {
+  columnFilteringFeature: RowModelFns_ColumnFiltering<TFeatures, TData>
+  columnGroupingFeature: RowModelFns_ColumnGrouping<TFeatures, TData>
+  rowSortingFeature: RowModelFns_RowSorting<TFeatures, TData>
+}
+
+export type RowModelFns<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> = Partial<
+  ExtractFeatureMapTypes<TFeatures, RowModelFns_FeatureMap<TFeatures, TData>> &
+    ExtractFeatureTypes<'RowModelFns', TFeatures> &
+    RowModelFns_Plugins<TFeatures, TData>
+>
+
+export type RowModelFns_All<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> = Partial<
+  RowModelFns_ColumnFiltering<TFeatures, TData> &
+    RowModelFns_ColumnGrouping<TFeatures, TData> &
+    RowModelFns_RowSorting<TFeatures, TData>
+>

package/src/types/Table.ts

@@ -0,0 +1,106 @@
+import type { ReadonlyStore } from '@tanstack/store'
+import type { Table_ColumnFaceting } from '../features/column-faceting/columnFacetingFeature.types'
+import type { Table_ColumnResizing } from '../features/column-resizing/columnResizingFeature.types'
+import type { Table_ColumnFiltering } from '../features/column-filtering/columnFilteringFeature.types'
+import type { Table_ColumnGrouping } from '../features/column-grouping/columnGroupingFeature.types'
+import type { Table_ColumnPinning } from '../features/column-pinning/columnPinningFeature.types'
+import type { Table_ColumnOrdering } from '../features/column-ordering/columnOrderingFeature.types'
+import type { Table_ColumnVisibility } from '../features/column-visibility/columnVisibilityFeature.types'
+import type { Table_ColumnSizing } from '../features/column-sizing/columnSizingFeature.types'
+import type { Table_RowPinning } from '../features/row-pinning/rowPinningFeature.types'
+import type { Table_GlobalFiltering } from '../features/global-filtering/globalFilteringFeature.types'
+import type { Table_RowExpanding } from '../features/row-expanding/rowExpandingFeature.types'
+import type { Table_RowPagination } from '../features/row-pagination/rowPaginationFeature.types'
+import type { Table_RowSelection } from '../features/row-selection/rowSelectionFeature.types'
+import type { Table_RowSorting } from '../features/row-sorting/rowSortingFeature.types'
+import type { Table_RowModels } from '../core/row-models/coreRowModelsFeature.types'
+import type { CachedRowModel_All, CreateRowModels_All } from './RowModel'
+import type { RowModelFns_All } from './RowModelFns'
+import type { TableState_All } from './TableState'
+import type { RowData } from './type-utils'
+import type {
+  ExtractFeatureMapTypes,
+  ExtractFeatureTypes,
+  TableFeatures,
+} from './TableFeatures'
+import type { Table_Columns } from '../core/columns/coreColumnsFeature.types'
+import type { Table_Headers } from '../core/headers/coreHeadersFeature.types'
+import type { Table_Rows } from '../core/rows/coreRowsFeature.types'
+import type {
+  Atoms_All,
+  BaseAtoms_All,
+  ExternalAtoms_All,
+  Table_Table,
+} from '../core/table/coreTablesFeature.types'
+import type { TableOptions_All } from './TableOptions'
+
+/**
+ * Use this interface as a target for declaration merging to add your own plugin properties.
+ * Note: This will affect the types of all tables in your project.
+ */
+export interface Table_Plugins<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> {}
+
+/**
+ * The core table object that only includes the core table functionality such as column, header, row, and table APIS.
+ * No features are included.
+ */
+export type Table_Core<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> = Table_Table<TFeatures, TData> &
+  Table_Columns<TFeatures, TData> &
+  Table_Rows<TFeatures, TData> &
+  Table_RowModels<TFeatures, TData> &
+  Table_Headers<TFeatures, TData>
+
+export interface Table_FeatureMap<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> {
+  columnFilteringFeature: Table_ColumnFiltering
+  columnGroupingFeature: Table_ColumnGrouping<TFeatures, TData>
+  columnOrderingFeature: Table_ColumnOrdering<TFeatures, TData>
+  columnPinningFeature: Table_ColumnPinning<TFeatures, TData>
+  columnResizingFeature: Table_ColumnResizing
+  columnSizingFeature: Table_ColumnSizing
+  columnVisibilityFeature: Table_ColumnVisibility<TFeatures, TData>
+  columnFacetingFeature: Table_ColumnFaceting<TFeatures, TData>
+  globalFilteringFeature: Table_GlobalFiltering<TFeatures, TData>
+  rowExpandingFeature: Table_RowExpanding<TFeatures, TData>
+  rowPaginationFeature: Table_RowPagination<TFeatures, TData>
+  rowPinningFeature: Table_RowPinning<TFeatures, TData>
+  rowSelectionFeature: Table_RowSelection<TFeatures, TData>
+  rowSortingFeature: Table_RowSorting<TFeatures, TData>
+}
+
+/**
+ * The table object that includes both the core table functionality and the features that are enabled via the `features` table option.
+ */
+export type Table<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> = Table_Core<TFeatures, TData> &
+  ExtractFeatureMapTypes<TFeatures, Table_FeatureMap<TFeatures, TData>> &
+  ExtractFeatureTypes<'Table', TFeatures> &
+  Table_Plugins<TFeatures, TData>
+
+export type Table_Internal<
+  TFeatures extends TableFeatures,
+  TData extends RowData = any,
+> = Table<TFeatures, TData> & {
+  _rowModels: CachedRowModel_All<TFeatures, TData>
+  _rowModelFns: RowModelFns_All<TFeatures, TData>
+  options: TableOptions_All<TFeatures, TData> & {
+    rowModels?: CreateRowModels_All<TFeatures, TData>
+    state?: TableState_All
+    initialState?: TableState_All
+    atoms?: ExternalAtoms_All
+  }
+  initialState: TableState_All
+  baseAtoms: BaseAtoms_All
+  atoms: Atoms_All
+  store: ReadonlyStore<TableState_All>
+}

package/src/types/TableFeatures.ts

@@ -0,0 +1,162 @@
+import type { CoreFeatures } from '../core/coreFeatures'
+import type { CellData, RowData, UnionToIntersection } from './type-utils'
+import type { ColumnDefBase_All } from './ColumnDef'
+import type { Row } from './Row'
+import type { Table_Internal } from './Table'
+import type { TableOptions_All } from './TableOptions'
+import type { TableState_All } from './TableState'
+import type { StockFeatures } from '../features/stockFeatures'
+
+export type ExtractFeatureTypes<
+  TKey extends keyof FeatureConstructors,
+  TFeatures extends TableFeatures,
+> = UnionToIntersection<
+  {
+    [K in keyof TFeatures]: K extends 'coreReativityFeature'
+      ? never
+      : TFeatures[K] extends TableFeature<infer FeatureConstructorOptions>
+        ? TKey extends keyof FeatureConstructorOptions
+          ? FeatureConstructorOptions[TKey]
+          : never
+        : any
+  }[keyof TFeatures]
+>
+
+type IsAny<T> = 0 extends 1 & T ? true : false
+
+export type ExtractFeatureMapTypes<
+  TFeatures extends TableFeatures,
+  TFeatureMap extends object,
+> =
+  IsAny<TFeatures> extends true
+    ? UnionToIntersection<TFeatureMap[keyof TFeatureMap]>
+    : UnionToIntersection<
+        TFeatureMap[Extract<keyof TFeatures, keyof TFeatureMap>]
+      >
+
+export interface FeatureConstructors {
+  CachedRowModel?: any
+  Cell?: any
+  Column?: any
+  ColumnDef?: any
+  CreateRowModels?: any
+  Header?: any
+  HeaderGroup?: any
+  Row?: any
+  RowModelFns?: any
+  Table?: any
+  TableOptions?: any
+  TableState?: any
+}
+
+export interface Plugins {}
+
+export interface TableFeatures
+  extends Partial<CoreFeatures>, Partial<StockFeatures>, Partial<Plugins> {}
+
+export type ConstructTableAPIs<TConstructors extends FeatureConstructors> = <
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(
+  table: Table_Internal<TFeatures, TData> &
+    Partial<TConstructors['Table']> & {
+      options: Partial<TConstructors['TableOptions']>
+    },
+) => void
+
+export type GetDefaultColumnDef<TConstructors extends FeatureConstructors> = <
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+  TValue extends CellData = CellData,
+>() => ColumnDefBase_All<TFeatures, TData, TValue> &
+  Partial<TConstructors['ColumnDef']>
+
+export type GetDefaultTableOptions<TConstructors extends FeatureConstructors> =
+  <TFeatures extends TableFeatures, TData extends RowData>(
+    table: Table_Internal<TFeatures, TData> & Partial<TConstructors['Table']>,
+  ) => Partial<TableOptions_All<TFeatures, TData>> &
+    Partial<TConstructors['TableOptions']>
+
+export type GetInitialState<TConstructors extends FeatureConstructors> = (
+  initialState: Partial<TableState_All> & Partial<TConstructors['TableState']>,
+) => TableState_All & Partial<TConstructors['TableState']>
+
+export type GetDefaultStateSelector<TConstructors extends FeatureConstructors> =
+  (
+    state: TableState_All,
+  ) => Partial<TableState_All> & Partial<TConstructors['TableState']>
+
+export type AssignCellPrototype<TConstructors extends FeatureConstructors> = <
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(
+  prototype: Record<string, any>,
+  table: Table_Internal<TFeatures, TData>,
+) => void
+
+export type AssignColumnPrototype<TConstructors extends FeatureConstructors> = <
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(
+  prototype: Record<string, any>,
+  table: Table_Internal<TFeatures, TData>,
+) => void
+
+export type AssignHeaderPrototype<TConstructors extends FeatureConstructors> = <
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(
+  prototype: Record<string, any>,
+  table: Table_Internal<TFeatures, TData>,
+) => void
+
+export type AssignRowPrototype<TConstructors extends FeatureConstructors> = <
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(
+  prototype: Record<string, any>,
+  table: Table_Internal<TFeatures, TData>,
+) => void
+
+export type InitRowInstanceData<TConstructors extends FeatureConstructors> = <
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>(
+  row: Row<TFeatures, TData> & Partial<TConstructors['Row']>,
+) => void
+
+export interface TableFeature<TConstructors extends FeatureConstructors> {
+  /**
+   * Assigns Cell APIs to the cell prototype for memory-efficient method sharing.
+   * This is called once per table to build a shared prototype for all cells.
+   */
+  assignCellPrototype?: AssignCellPrototype<TConstructors>
+  /**
+   * Assigns Column APIs to the column prototype for memory-efficient method sharing.
+   * This is called once per table to build a shared prototype for all columns.
+   */
+  assignColumnPrototype?: AssignColumnPrototype<TConstructors>
+  /**
+   * Assigns Header APIs to the header prototype for memory-efficient method sharing.
+   * This is called once per table to build a shared prototype for all headers.
+   */
+  assignHeaderPrototype?: AssignHeaderPrototype<TConstructors>
+  /**
+   * Assigns Row APIs to the row prototype for memory-efficient method sharing.
+   * This is called once per table to build a shared prototype for all rows.
+   */
+  assignRowPrototype?: AssignRowPrototype<TConstructors>
+  /**
+   * Assigns Table APIs to the table instance.
+   * Unlike row/cell/column/header, the table is a singleton so methods are assigned directly.
+   */
+  constructTableAPIs?: ConstructTableAPIs<TConstructors>
+  getDefaultColumnDef?: GetDefaultColumnDef<TConstructors>
+  getDefaultTableOptions?: GetDefaultTableOptions<TConstructors>
+  getInitialState?: GetInitialState<TConstructors>
+  /**
+   * Initializes instance-specific data on each row (e.g., caches).
+   * Methods should be assigned via assignRowPrototype instead.
+   */
+  initRowInstanceData?: InitRowInstanceData<TConstructors>
+}

package/src/types/TableOptions.ts

@@ -0,0 +1,112 @@
+import type { CoreFeatures } from '../core/coreFeatures'
+import type { TableOptions_Cell } from '../core/cells/coreCellsFeature.types'
+import type { TableOptions_Columns } from '../core/columns/coreColumnsFeature.types'
+import type { TableOptions_Rows } from '../core/rows/coreRowsFeature.types'
+import type { TableOptions_Table } from '../core/table/coreTablesFeature.types'
+import type { TableOptions_ColumnFiltering } from '../features/column-filtering/columnFilteringFeature.types'
+import type { TableOptions_ColumnGrouping } from '../features/column-grouping/columnGroupingFeature.types'
+import type { TableOptions_ColumnOrdering } from '../features/column-ordering/columnOrderingFeature.types'
+import type { TableOptions_ColumnPinning } from '../features/column-pinning/columnPinningFeature.types'
+import type { TableOptions_ColumnResizing } from '../features/column-resizing/columnResizingFeature.types'
+import type { TableOptions_ColumnSizing } from '../features/column-sizing/columnSizingFeature.types'
+import type { TableOptions_ColumnVisibility } from '../features/column-visibility/columnVisibilityFeature.types'
+import type { TableOptions_GlobalFiltering } from '../features/global-filtering/globalFilteringFeature.types'
+import type { TableOptions_RowExpanding } from '../features/row-expanding/rowExpandingFeature.types'
+import type { TableOptions_RowPagination } from '../features/row-pagination/rowPaginationFeature.types'
+import type { TableOptions_RowPinning } from '../features/row-pinning/rowPinningFeature.types'
+import type { TableOptions_RowSelection } from '../features/row-selection/rowSelectionFeature.types'
+import type { TableOptions_RowSorting } from '../features/row-sorting/rowSortingFeature.types'
+import type { RowData, UnionToIntersection } from './type-utils'
+import type {
+  ExtractFeatureMapTypes,
+  ExtractFeatureTypes,
+  TableFeatures,
+} from './TableFeatures'
+
+export interface TableOptions_Plugins<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> {}
+
+/**
+ * Core options that are always available on a table, before optional feature
+ * options are mixed in.
+ */
+export interface TableOptions_Core<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+>
+  extends
+    TableOptions_Table<TFeatures, TData>,
+    TableOptions_Cell,
+    TableOptions_Columns<TFeatures, TData>,
+    TableOptions_Rows<TFeatures, TData> {}
+
+type DebugKeysFor<TFeatures extends TableFeatures> = {
+  [K in keyof TFeatures & string as `debug${Capitalize<K>}`]?: boolean
+}
+
+export type DebugOptions<TFeatures extends TableFeatures> = {
+  debugAll?: boolean
+  debugCache?: boolean
+  debugCells?: boolean
+  debugColumns?: boolean
+  debugHeaders?: boolean
+  debugRows?: boolean
+  debugTable?: boolean
+} & DebugKeysFor<CoreFeatures & TFeatures>
+
+export interface TableOptions_FeatureMap<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> {
+  columnFilteringFeature: TableOptions_ColumnFiltering<TFeatures, TData>
+  columnGroupingFeature: TableOptions_ColumnGrouping
+  columnOrderingFeature: TableOptions_ColumnOrdering
+  columnPinningFeature: TableOptions_ColumnPinning
+  columnResizingFeature: TableOptions_ColumnResizing
+  columnSizingFeature: TableOptions_ColumnSizing
+  columnVisibilityFeature: TableOptions_ColumnVisibility
+  globalFilteringFeature: TableOptions_GlobalFiltering<TFeatures, TData>
+  rowExpandingFeature: TableOptions_RowExpanding<TFeatures, TData>
+  rowPaginationFeature: TableOptions_RowPagination
+  rowPinningFeature: TableOptions_RowPinning<TFeatures, TData>
+  rowSelectionFeature: TableOptions_RowSelection<TFeatures, TData>
+  rowSortingFeature: TableOptions_RowSorting
+}
+
+export type TableOptions_FeatureMap_All<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> = UnionToIntersection<
+  TableOptions_FeatureMap<TFeatures, TData>[keyof TableOptions_FeatureMap<
+    TFeatures,
+    TData
+  >]
+>
+
+/**
+ * Complete table options for a specific feature set.
+ *
+ * Feature options are included only when their feature is present in
+ * `TFeatures`, then custom feature/plugin options and debug options are mixed
+ * in.
+ */
+export type TableOptions<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> = TableOptions_Core<TFeatures, TData> &
+  ExtractFeatureMapTypes<TFeatures, TableOptions_FeatureMap<TFeatures, TData>> &
+  ExtractFeatureTypes<'TableOptions', TFeatures> &
+  TableOptions_Plugins<TFeatures, TData> &
+  DebugOptions<TFeatures>
+
+/**
+ * Internal broad option shape used where feature code may need to read options
+ * from features that are not present in the current generic feature set.
+ */
+export type TableOptions_All<
+  TFeatures extends TableFeatures,
+  TData extends RowData,
+> = TableOptions_Core<TFeatures, TData> &
+  Partial<TableOptions_FeatureMap_All<TFeatures, TData>>

package/src/types/TableState.ts

@@ -0,0 +1,73 @@
+import type { TableState_ColumnFiltering } from '../features/column-filtering/columnFilteringFeature.types'
+import type { TableState_ColumnGrouping } from '../features/column-grouping/columnGroupingFeature.types'
+import type { TableState_ColumnOrdering } from '../features/column-ordering/columnOrderingFeature.types'
+import type { TableState_ColumnPinning } from '../features/column-pinning/columnPinningFeature.types'
+import type { TableState_ColumnResizing } from '../features/column-resizing/columnResizingFeature.types'
+import type { TableState_ColumnSizing } from '../features/column-sizing/columnSizingFeature.types'
+import type { TableState_ColumnVisibility } from '../features/column-visibility/columnVisibilityFeature.types'
+import type { TableState_GlobalFiltering } from '../features/global-filtering/globalFilteringFeature.types'
+import type { TableState_RowExpanding } from '../features/row-expanding/rowExpandingFeature.types'
+import type { TableState_RowPagination } from '../features/row-pagination/rowPaginationFeature.types'
+import type { TableState_RowPinning } from '../features/row-pinning/rowPinningFeature.types'
+import type { TableState_RowSelection } from '../features/row-selection/rowSelectionFeature.types'
+import type { TableState_RowSorting } from '../features/row-sorting/rowSortingFeature.types'
+import type {
+  ExtractFeatureMapTypes,
+  ExtractFeatureTypes,
+  TableFeatures,
+} from './TableFeatures'
+
+/**
+ * Use this interface as a target for declaration merging to add your own state properties.
+ * Note: This will affect the types of all tables in your project.
+ */
+export interface TableState_Plugins<TFeatures extends TableFeatures> {}
+
+export interface TableState_FeatureMap {
+  columnFilteringFeature: TableState_ColumnFiltering
+  columnGroupingFeature: TableState_ColumnGrouping
+  columnOrderingFeature: TableState_ColumnOrdering
+  columnPinningFeature: TableState_ColumnPinning
+  columnResizingFeature: TableState_ColumnResizing
+  columnSizingFeature: TableState_ColumnSizing
+  columnVisibilityFeature: TableState_ColumnVisibility
+  globalFilteringFeature: TableState_GlobalFiltering
+  rowExpandingFeature: TableState_RowExpanding
+  rowPaginationFeature: TableState_RowPagination
+  rowPinningFeature: TableState_RowPinning
+  rowSelectionFeature: TableState_RowSelection
+  rowSortingFeature: TableState_RowSorting
+}
+
+/**
+ * Complete table state for a specific feature set.
+ *
+ * State slices are included only when their feature is present in `TFeatures`,
+ * then custom feature/plugin state is mixed in.
+ */
+export type TableState<TFeatures extends TableFeatures> =
+  ExtractFeatureMapTypes<TFeatures, TableState_FeatureMap> &
+    ExtractFeatureTypes<'TableState', TFeatures> &
+    TableState_Plugins<TFeatures>
+
+/**
+ * Internal broad state shape containing every stock feature state slice.
+ *
+ * Feature internals use this when they may need to inspect optional slices owned
+ * by other features.
+ */
+export type TableState_All = Partial<
+  TableState_ColumnFiltering &
+    TableState_ColumnGrouping &
+    TableState_ColumnOrdering &
+    TableState_ColumnPinning &
+    TableState_ColumnResizing &
+    TableState_ColumnSizing &
+    TableState_ColumnVisibility &
+    TableState_GlobalFiltering &
+    TableState_RowExpanding &
+    TableState_RowPagination &
+    TableState_RowPinning &
+    TableState_RowSelection &
+    TableState_RowSorting
+>

package/src/types/type-utils.ts

@@ -0,0 +1,84 @@
+export type Updater<T> = T | ((old: T) => T)
+
+export type OnChangeFn<T> = (updaterOrValue: Updater<T>) => void
+
+export type RowData = Record<string, any> | Array<any>
+
+export type CellData = unknown
+
+export type PartialKeys<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>
+
+export type RequiredKeys<T, K extends keyof T> = Omit<T, K> &
+  Required<Pick<T, K>>
+
+export type UnionToIntersection<T> = (
+  T extends any ? (x: T) => any : never
+) extends (x: infer R) => any
+  ? R
+  : never
+
+type ComputeRange<
+  N extends number,
+  Result extends Array<unknown> = [],
+> = Result['length'] extends N
+  ? Result
+  : ComputeRange<N, [...Result, Result['length']]>
+
+type Index40 = ComputeRange<40>[number]
+
+// Is this type a tuple?
+type IsTuple<T> = T extends ReadonlyArray<any> & { length: infer Length }
+  ? Length extends Index40
+    ? T
+    : never
+  : never
+
+// If this type is a tuple, what indices are allowed?
+type AllowedIndexes<
+  Tuple extends ReadonlyArray<any>,
+  Keys extends number = never,
+> = Tuple extends readonly []
+  ? Keys
+  : Tuple extends readonly [infer _, ...infer Tail]
+    ? AllowedIndexes<Tail, Keys | Tail['length']>
+    : Keys
+
+export type DeepKeys<
+  T,
+  TDepth extends Array<any> = [],
+> = TDepth['length'] extends 5
+  ? never
+  : unknown extends T
+    ? string
+    : T extends ReadonlyArray<any> & IsTuple<T>
+      ? AllowedIndexes<T> | DeepKeysPrefix<T, AllowedIndexes<T>, TDepth>
+      : T extends Array<any>
+        ? DeepKeys<T[number], [...TDepth, any]>
+        : T extends Date
+          ? never
+          : T extends object
+            ? (keyof T & string) | DeepKeysPrefix<T, keyof T, TDepth>
+            : never
+
+type DeepKeysPrefix<
+  T,
+  TPrefix,
+  TDepth extends Array<any>,
+> = TPrefix extends keyof T & (number | string)
+  ? `${TPrefix}.${DeepKeys<T[TPrefix], [...TDepth, any]> & string}`
+  : never
+
+export type DeepValue<T, TProp> =
+  T extends Record<string | number, any>
+    ? TProp extends `${infer TBranch}.${infer TDeepProp}`
+      ? DeepValue<T[TBranch], TDeepProp>
+      : T[TProp & string]
+    : never
+
+export type NoInfer<T> = [T][T extends any ? 0 : never]
+
+export type Getter<TValue> = <TTValue = TValue>() => NoInfer<TTValue>
+
+export type Prettify<T> = {
+  [K in keyof T]: T[K]
+} & unknown