@tamagui/create-theme 1.31.3 → 1.32.0

package/src/createTheme.tsx

@@ -0,0 +1,72 @@
+import { isMinusZero } from './isMinusZero'
+import { setThemeInfo } from './themeInfo'
+import { CreateThemeOptions, CreateThemePalette, GenericTheme, ThemeMask } from './types'
+
+const identityCache = new Map()
+
+export function createTheme<
+  Definition extends ThemeMask,
+  Extras extends GenericTheme = {}
+>(
+  palette: CreateThemePalette,
+  definition: Definition,
+  options?: CreateThemeOptions
+): {
+  [key in keyof Definition | keyof Extras]: string
+} {
+  const cacheKey = JSON.stringify([palette, definition, options])
+  if (identityCache.has(cacheKey)) {
+    return identityCache.get(cacheKey)
+  }
+
+  const theme = {
+    ...(Object.fromEntries(
+      Object.entries(definition).map(([key, offset]) => {
+        return [key, getValue(palette, offset)]
+      })
+    ) as any),
+    ...options?.nonInheritedValues,
+  }
+
+  setThemeInfo(theme, { palette, definition, options })
+  identityCache.set(cacheKey, theme)
+
+  return theme
+}
+
+const getValue = (palette: CreateThemePalette, value: string | number) => {
+  if (typeof value === 'string') return value
+  const max = palette.length - 1
+  const isPositive = value === 0 ? !isMinusZero(value) : value >= 0
+  const next = isPositive ? value : max + value
+  const index = Math.min(Math.max(0, next), max)
+  return palette[index]
+}
+
+type SubThemeKeys<ParentKeys, ChildKeys> = `${ParentKeys extends string
+  ? ParentKeys
+  : never}_${ChildKeys extends string ? ChildKeys : never}`
+
+type ChildGetter<Name extends string | number | symbol, Theme extends GenericTheme> = (
+  name: Name,
+  theme: Theme
+) => { [key: string]: Theme }
+
+export function addChildren<
+  Themes extends { [key: string]: GenericTheme },
+  GetChildren extends ChildGetter<keyof Themes, Themes[keyof Themes]>
+>(
+  themes: Themes,
+  getChildren: GetChildren
+): Themes & {
+  [key in SubThemeKeys<keyof Themes, keyof ReturnType<GetChildren>>]: Themes[keyof Themes]
+} {
+  const out = { ...themes }
+  for (const key in themes) {
+    const subThemes = getChildren(key, themes[key])
+    for (const sKey in subThemes) {
+      out[`${key}_${sKey}`] = subThemes[sKey] as any
+    }
+  }
+  return out as any
+}

package/src/helpers.tsx

@@ -0,0 +1,44 @@
+type ObjectType = Record<PropertyKey, unknown>
+
+type PickByValue<OBJ_T, VALUE_T> = // From https://stackoverflow.com/a/55153000
+  Pick<OBJ_T, { [K in keyof OBJ_T]: OBJ_T[K] extends VALUE_T ? K : never }[keyof OBJ_T]>
+
+type ObjectEntries<OBJ_T> = // From https://stackoverflow.com/a/60142095
+  { [K in keyof OBJ_T]: [keyof PickByValue<OBJ_T, OBJ_T[K]>, OBJ_T[K]] }[keyof OBJ_T][]
+
+export const objectKeys = <O extends Object>(obj: O) => Object.keys(obj) as Array<keyof O>
+
+export function objectEntries<OBJ_T extends ObjectType>(
+  obj: OBJ_T
+): ObjectEntries<OBJ_T> {
+  return Object.entries(obj) as ObjectEntries<OBJ_T>
+}
+
+type EntriesType =
+  | [PropertyKey, unknown][]
+  | ReadonlyArray<readonly [PropertyKey, unknown]>
+
+// Existing Utils
+type DeepWritable<OBJ_T> = { -readonly [P in keyof OBJ_T]: DeepWritable<OBJ_T[P]> }
+type UnionToIntersection<UNION_T> = // From https://stackoverflow.com/a/50375286
+  (UNION_T extends any ? (k: UNION_T) => void : never) extends (k: infer I) => void
+    ? I
+    : never
+
+// New Utils
+type UnionObjectFromArrayOfPairs<ARR_T extends EntriesType> =
+  DeepWritable<ARR_T> extends (infer R)[]
+    ? R extends [infer key, infer val]
+      ? { [prop in key & PropertyKey]: val }
+      : never
+    : never
+type MergeIntersectingObjects<ObjT> = { [key in keyof ObjT]: ObjT[key] }
+type EntriesToObject<ARR_T extends EntriesType> = MergeIntersectingObjects<
+  UnionToIntersection<UnionObjectFromArrayOfPairs<ARR_T>>
+>
+
+export function objectFromEntries<ARR_T extends EntriesType>(
+  arr: ARR_T
+): EntriesToObject<ARR_T> {
+  return Object.fromEntries(arr) as EntriesToObject<ARR_T>
+}

package/src/index.tsx

@@ -1,174 +1,4 @@
-import type { Variable } from '@tamagui/web'
-
-export type ThemeMask = Record<string, string | number>
-export type Palette = (string | Variable)[]
-
-export type MaskOptions = {
-  palette?: Palette
-  override?: Partial<ThemeMask>
-  skip?: Partial<ThemeMask>
-  strength?: number
-  max?: number
-  min?: number
-}
-
-type GenericTheme = { [key: string]: string | Variable }
-
-export type CreateMask = <A extends ThemeMask>(template: A, options: MaskOptions) => A
-
-const THEME_INFO = new WeakMap<
-  any,
-  { palette: Palette; definition: ThemeMask; cache: Map<any, any> }
->()
-
-export function createTheme<
-  Definition extends ThemeMask,
-  Extras extends Record<string, string> = {}
->(
-  palette: Palette,
-  definition: Definition,
-  options?: {
-    nonInheritedValues?: Extras
-  }
-): {
-  [key in keyof Definition | keyof Extras]: string
-} {
-  const theme = {
-    ...(Object.fromEntries(
-      Object.entries(definition).map(([key, offset]) => {
-        return [key, getValue(palette, offset)]
-      })
-    ) as any),
-    ...options?.nonInheritedValues,
-  }
-  THEME_INFO.set(theme, { palette, definition, cache: new Map() })
-  return theme
-}
-
-const getValue = (palette: Palette, value: string | number) => {
-  if (typeof value === 'string') return value
-  const max = palette.length - 1
-  const isPositive = value === 0 ? !isMinusZero(value) : value >= 0
-  const next = isPositive ? value : max + value
-  const index = Math.min(Math.max(0, next), max)
-  return palette[index]
-}
-
-type SubThemeKeys<ParentKeys, ChildKeys> = `${ParentKeys extends string
-  ? ParentKeys
-  : never}_${ChildKeys extends string ? ChildKeys : never}`
-
-type ChildGetter<Name extends string | number | symbol, Theme extends GenericTheme> = (
-  name: Name,
-  theme: Theme
-) => { [key: string]: Theme }
-
-export function addChildren<
-  Themes extends { [key: string]: GenericTheme },
-  GetChildren extends ChildGetter<keyof Themes, Themes[keyof Themes]>
->(
-  themes: Themes,
-  getChildren: GetChildren
-): Themes & {
-  [key in SubThemeKeys<keyof Themes, keyof ReturnType<GetChildren>>]: Themes[keyof Themes]
-} {
-  const out = { ...themes }
-  for (const key in themes) {
-    const subThemes = getChildren(key, themes[key])
-    for (const sKey in subThemes) {
-      out[`${key}_${sKey}`] = subThemes[sKey] as any
-    }
-  }
-  return out as any
-}
-
-export const skipMask: CreateMask = (template, { skip }) => {
-  if (!skip) return template
-  return Object.fromEntries(
-    Object.entries(template).filter(([k]) => !(k in skip))
-  ) as typeof template
-}
-
-export const createShiftMask = ({ inverse }: { inverse?: boolean } = {}) => {
-  return ((template, opts) => {
-    const { override, max: maxIn, palette, min = 0, strength = 1 } = opts
-    const values = Object.entries(template)
-    const max = maxIn ?? (palette ? Object.values(palette).length - 1 : Infinity)
-    const out = {}
-    for (const [key, value] of values) {
-      if (typeof value === 'string') continue
-      if (typeof override?.[key] === 'number') {
-        const overrideShift = override[key] as number
-        out[key] = value + overrideShift
-        continue
-      }
-      const isPositive = value === 0 ? !isMinusZero(value) : value >= 0
-      const direction = isPositive ? 1 : -1
-      const invert = inverse ? -1 : 1
-      const next = value + strength * direction * invert
-      const clamped = isPositive
-        ? Math.max(min, Math.min(max, next))
-        : Math.min(-min, Math.max(-max, next))
-
-      out[key] = clamped
-    }
-
-    return skipMask(out, opts) as typeof template
-  }) as CreateMask
-}
-
-export const createWeakenMask = () => createShiftMask()
-export const createStrengthenMask = () => createShiftMask({ inverse: true })
-
-function isMinusZero(value) {
-  return 1 / value === -Infinity
-}
-
-export function applyMask<Theme extends GenericTheme>(
-  theme: Theme,
-  mask: CreateMask,
-  options: MaskOptions = {}
-): Theme {
-  const info = THEME_INFO.get(theme)
-  if (!info) {
-    throw new Error(
-      process.env.NODE_ENV !== 'production'
-        ? `No info found for theme, you must pass the theme created by createThemeFromPalette directly to extendTheme`
-        : `❌ Err2`
-    )
-  }
-
-  const template = mask(info.definition, {
-    palette: info.palette,
-    ...options,
-  })
-  const next = createTheme(info.palette, template) as Theme
-
-  return next
-}
-
-// --- tests ---
-
-if (process.env.NODE_ENV === 'development') {
-  const palette = ['0', '1', '2', '3', '-3', '-2', '-1', '-0']
-  const template = { bg: 1, fg: -1 }
-
-  const stongerMask = createStrengthenMask()
-  const weakerMask = createWeakenMask()
-
-  const theme = createTheme(palette, template)
-  if (theme.bg !== '1') throw `❌`
-  if (theme.fg !== '-1') throw `❌`
-
-  const str = applyMask(theme, stongerMask)
-  if (str.bg !== '0') throw `❌`
-  if (str.fg !== '-0') throw `❌`
-
-  const weak = applyMask(theme, weakerMask)
-  if (weak.bg !== '2') throw `❌`
-  if (weak.fg !== '-2') throw `❌`
-
-  const weak2 = applyMask(theme, weakerMask, { strength: 2 })
-  if (weak2.bg !== '3') throw `❌`
-  if (weak2.fg !== '-3') throw `❌`
-}
+export * from './createTheme'
+export * from './masks'
+export * from './types'
+export * from './ThemeBuilder'

package/src/isMinusZero.tsx

@@ -0,0 +1,3 @@
+export function isMinusZero(value) {
+  return 1 / value === -Infinity
+}

package/src/masks.tsx

@@ -0,0 +1,155 @@
+import { createTheme } from './createTheme'
+import { objectEntries, objectFromEntries } from './helpers'
+import { isMinusZero } from './isMinusZero'
+import { getThemeInfo, setThemeInfo } from './themeInfo'
+import { CreateMask, GenericTheme, MaskFunction, MaskOptions, ThemeMask } from './types'
+
+export const createMask = <C extends CreateMask | MaskFunction>(
+  createMask: C
+): CreateMask =>
+  typeof createMask === 'function'
+    ? { name: createMask.name || 'unnamed', mask: createMask }
+    : createMask
+
+export const combineMasks = (...masks: CreateMask[]) => {
+  const mask: CreateMask = {
+    name: 'combine-mask',
+    mask: (template, opts) => {
+      let current = template
+      for (const mask of masks) {
+        current = applyMask(current, mask, opts)
+      }
+      return current
+    },
+  }
+  return mask
+}
+
+export const skipMask: CreateMask = {
+  name: 'skip-mask',
+  mask: (template, { skip }) => {
+    if (!skip) return template
+    return Object.fromEntries(
+      Object.entries(template).filter(([k]) => !(k in skip))
+    ) as typeof template
+  },
+}
+
+export const createIdentityMask = (): CreateMask => ({
+  name: 'identity-mask',
+  mask: (template) => template,
+})
+
+export const createInverseMask = () => {
+  const mask: CreateMask = {
+    name: 'inverse-mask',
+    mask: (template, opts) => {
+      const inversed = objectFromEntries(
+        objectEntries(template).map(([k, v]) => [k, -v])
+      ) as any
+      return skipMask.mask(inversed, opts)
+    },
+  }
+  return mask
+}
+
+type ShiftMaskOptions = { inverse?: boolean }
+
+export const createShiftMask = (
+  { inverse }: ShiftMaskOptions = {},
+  defaultOptions?: MaskOptions
+) => {
+  const mask: CreateMask = {
+    name: 'shift-mask',
+    mask: (template, opts) => {
+      const {
+        override,
+        max: maxIn,
+        palette,
+        min = 0,
+        strength = 1,
+      } = { ...defaultOptions, ...opts }
+      const values = Object.entries(template)
+      const max = maxIn ?? (palette ? Object.values(palette).length - 1 : Infinity)
+      const out = {}
+      for (const [key, value] of values) {
+        if (typeof value === 'string') continue
+        if (typeof override?.[key] === 'number') {
+          const overrideShift = override[key] as number
+          out[key] = value + overrideShift
+          continue
+        } else if (typeof override?.[key] === 'string') {
+          out[key] = override[key]
+          continue
+        }
+        const isPositive = value === 0 ? !isMinusZero(value) : value >= 0
+        const direction = isPositive ? 1 : -1
+        const invert = inverse ? -1 : 1
+        const next = value + strength * direction * invert
+        const clamped = isPositive
+          ? Math.max(min, Math.min(max, next))
+          : Math.min(-min, Math.max(-max, next))
+
+        out[key] = clamped
+      }
+
+      return skipMask.mask(out, opts) as typeof template
+    },
+  }
+  return mask
+}
+
+export const createWeakenMask = (defaultOptions?: MaskOptions): CreateMask => ({
+  name: 'soften-mask',
+  mask: createShiftMask({}, defaultOptions).mask,
+})
+
+export const createSoftenMask = createWeakenMask
+
+export const createStrengthenMask = (defaultOptions?: MaskOptions): CreateMask => ({
+  name: 'strengthen-mask',
+  mask: createShiftMask({ inverse: true }, defaultOptions).mask,
+})
+
+export function applyMask<Theme extends GenericTheme | ThemeMask>(
+  theme: Theme,
+  mask: CreateMask,
+  options: MaskOptions = {}
+): Theme {
+  const info = getThemeInfo(theme)
+
+  if (!info) {
+    throw new Error(
+      process.env.NODE_ENV !== 'production'
+        ? `No info found for theme, you must pass the theme created by createThemeFromPalette directly to extendTheme`
+        : `❌ Err2`
+    )
+  }
+
+  const skip = {
+    ...options.skip,
+  }
+
+  // skip nonInheritedValues from parent theme
+  if (info.options?.nonInheritedValues) {
+    for (const key in info.options.nonInheritedValues) {
+      skip[key] = 1
+    }
+  }
+
+  // convert theme back to template first
+  const template = mask.mask(info.definition, {
+    palette: info.palette,
+    ...options,
+    skip,
+  })
+
+  const next = createTheme(info.palette, template) as Theme
+
+  setThemeInfo(next, {
+    definition: template,
+    palette: info.palette,
+  })
+
+  return next
+}

package/src/tests.tsx

@@ -0,0 +1,27 @@
+import { createTheme } from './createTheme'
+import { applyMask, createStrengthenMask, createWeakenMask } from './masks'
+
+// --- tests ---
+if (process.env.NODE_ENV === 'development') {
+  const palette = ['0', '1', '2', '3', '-3', '-2', '-1', '-0']
+  const template = { bg: 1, fg: -1 }
+
+  const stongerMask = createStrengthenMask()
+  const weakerMask = createWeakenMask()
+
+  const theme = createTheme(palette, template)
+  if (theme.bg !== '1') throw `❌`
+  if (theme.fg !== '-1') throw `❌`
+
+  const str = applyMask(theme, stongerMask)
+  if (str.bg !== '0') throw `❌`
+  if (str.fg !== '-0') throw `❌`
+
+  const weak = applyMask(theme, weakerMask)
+  if (weak.bg !== '2') throw `❌`
+  if (weak.fg !== '-2') throw `❌`
+
+  const weak2 = applyMask(theme, weakerMask, { strength: 2 })
+  if (weak2.bg !== '3') throw `❌`
+  if (weak2.fg !== '-3') throw `❌`
+}

package/src/themeInfo.tsx

@@ -0,0 +1,26 @@
+import { CreateThemeOptions, CreateThemePalette, GenericTheme, ThemeMask } from './types'
+
+export type ThemeInfo = {
+  palette: CreateThemePalette
+  definition: ThemeMask
+  options?: CreateThemeOptions
+  cache: Map<any, any>
+}
+
+const THEME_INFO = new Map<string, ThemeInfo>()
+
+export const getThemeInfo = (theme: GenericTheme | ThemeMask): ThemeInfo | undefined => {
+  return THEME_INFO.get(JSON.stringify(theme))
+}
+
+export const setThemeInfo = (
+  theme: GenericTheme | ThemeMask,
+  info: Pick<ThemeInfo, 'palette' | 'definition' | 'options'>
+) => {
+  const next = {
+    ...info,
+    cache: new Map(),
+  }
+  THEME_INFO.set(JSON.stringify(theme), next)
+  THEME_INFO.set(JSON.stringify(info.definition), next)
+}

package/src/types.tsx

@@ -0,0 +1,27 @@
+import type { Variable } from '@tamagui/web'
+
+export type CreateThemePalette = (string | Variable)[]
+
+export type ThemeMask = Record<string, string | number>
+
+export type MaskOptions = {
+  palette?: CreateThemePalette
+  override?: Partial<ThemeMask>
+  skip?: Partial<ThemeMask>
+  strength?: number
+  max?: number
+  min?: number
+}
+
+export type GenericTheme = { [key: string]: string | Variable }
+
+export type MaskFunction = <A extends ThemeMask>(template: A, options: MaskOptions) => A
+
+export type CreateMask = {
+  name: string
+  mask: MaskFunction
+}
+
+export type CreateThemeOptions = {
+  nonInheritedValues?: GenericTheme
+}

package/types/ThemeBuilder.d.ts

@@ -0,0 +1,86 @@
+import { Narrow } from '@tamagui/web';
+import { CreateMask, CreateThemeOptions, MaskOptions } from './types';
+export type Palette = string[];
+type GenericTheme = {
+    [key: string]: string;
+};
+export type Template = {
+    [key: string]: number;
+};
+type ThemeUsingMask<Masks = string> = MaskOptions & {
+    mask: Masks;
+};
+type ThemeUsingTemplate = CreateThemeOptions & {
+    palette: string;
+    template: string;
+};
+type ThemePreDefined = {
+    theme: GenericTheme;
+};
+export type Theme<Masks = string> = ThemePreDefined | ThemeUsingTemplate | ThemeUsingMask<Masks>;
+type ThemeWithParent<Masks = string> = Theme<Masks> & {
+    parent: string;
+};
+type PaletteDefinitions = {
+    [key: string]: Palette;
+};
+type ThemeDefinition<Masks extends string = string> = Theme<Masks> | ThemeWithParent<Masks>[];
+type UnionableString = string & {};
+type ThemeDefinitions<Masks extends string = string> = {
+    [key: string]: ThemeDefinition<Masks | UnionableString>;
+};
+type TemplateDefinitions = {
+    [key: string]: Template;
+};
+type MaskDefinitions = {
+    [key: string]: CreateMask | CreateMask['mask'];
+};
+type ThemeBuilderState = {
+    palettes?: PaletteDefinitions;
+    templates?: TemplateDefinitions;
+    themes?: ThemeDefinitions;
+    masks?: MaskDefinitions;
+};
+type ObjectStringKeys<A extends Object | undefined> = A extends Object ? Exclude<keyof A, symbol | number> : never;
+type GetGeneratedThemeFromTemplate<Template> = {
+    [key in keyof Template]: string;
+};
+type GetParentTheme<P, Themes extends ThemeDefinitions | undefined> = P extends string ? P extends keyof Themes ? Themes[P] : GetParentName<P> extends keyof Themes ? Themes[GetParentName<P>] : GetParentName<GetParentName<P>> extends keyof Themes ? Themes[GetParentName<GetParentName<P>>] : GetParentName<GetParentName<GetParentName<P>>> extends keyof Themes ? Themes[GetParentName<GetParentName<GetParentName<P>>>] : never : never;
+type GetGeneratedTheme<TD extends any, S extends ThemeBuilderState> = TD extends {
+    theme: infer T;
+} ? T : TD extends {
+    parent: infer P;
+} ? GetGeneratedTheme<GetParentTheme<P, S['themes']>, S> : TD extends {
+    template: infer T;
+} ? T extends keyof S['templates'] ? GetGeneratedThemeFromTemplate<S['templates'][T]> : TD : TD;
+type GetGeneratedThemes<S extends ThemeBuilderState> = {
+    [Key in keyof S['themes']]: GetGeneratedTheme<S['themes'][Key], S>;
+};
+type GetParentName<N extends string> = N extends `${infer A}_${infer B}_${infer C}_${infer D}_${string}` ? `${A}_${B}_${C}_${D}` : N extends `${infer A}_${infer B}_${infer C}_${string}` ? `${A}_${B}_${C}` : N extends `${infer A}_${infer B}_${string}` ? `${A}_${B}` : N extends `${infer A}_${string}` ? `${A}` : never;
+declare class ThemeBuilder<State extends ThemeBuilderState> {
+    state: State;
+    constructor(state: State);
+    addPalettes<const P extends PaletteDefinitions>(palettes: P): ThemeBuilder<State & {
+        readonly palettes: P;
+    }>;
+    addTemplates<const T extends TemplateDefinitions>(templates: T): ThemeBuilder<State & {
+        templates: T;
+    }>;
+    addMasks<const T extends MaskDefinitions>(masks: T): ThemeBuilder<State & {
+        masks: T;
+    }>;
+    addThemes<const T extends ThemeDefinitions<ObjectStringKeys<State['masks']>>>(themes: T): ThemeBuilder<State & {
+        themes: T;
+    }>;
+    addChildThemes<CTD extends Narrow<ThemeDefinitions<ObjectStringKeys<State['masks']>>>, const AvoidNestingWithin extends string[] = []>(childThemeDefinition: CTD, options?: {
+        avoidNestingWithin?: AvoidNestingWithin;
+    }): ThemeBuilder<State & {
+        themes: { [key in `${Exclude<keyof NonNullable<State["themes"]>, number | symbol>}_${Exclude<keyof CTD, number | symbol>}`]: CTD & {
+            parent: GetParentName<key>;
+        }; };
+    }>;
+    build(): GetGeneratedThemes<State>;
+}
+export declare function createThemeBuilder(): ThemeBuilder<{}>;
+export {};
+//# sourceMappingURL=ThemeBuilder.d.ts.map

package/types/createTheme.d.ts

@@ -0,0 +1,15 @@
+import { CreateThemeOptions, CreateThemePalette, GenericTheme, ThemeMask } from './types';
+export declare function createTheme<Definition extends ThemeMask, Extras extends GenericTheme = {}>(palette: CreateThemePalette, definition: Definition, options?: CreateThemeOptions): {
+    [key in keyof Definition | keyof Extras]: string;
+};
+type SubThemeKeys<ParentKeys, ChildKeys> = `${ParentKeys extends string ? ParentKeys : never}_${ChildKeys extends string ? ChildKeys : never}`;
+type ChildGetter<Name extends string | number | symbol, Theme extends GenericTheme> = (name: Name, theme: Theme) => {
+    [key: string]: Theme;
+};
+export declare function addChildren<Themes extends {
+    [key: string]: GenericTheme;
+}, GetChildren extends ChildGetter<keyof Themes, Themes[keyof Themes]>>(themes: Themes, getChildren: GetChildren): Themes & {
+    [key in SubThemeKeys<keyof Themes, keyof ReturnType<GetChildren>>]: Themes[keyof Themes];
+};
+export {};
+//# sourceMappingURL=createTheme.d.ts.map

package/types/helpers.d.ts

@@ -0,0 +1,24 @@
+type ObjectType = Record<PropertyKey, unknown>;
+type PickByValue<OBJ_T, VALUE_T> = Pick<OBJ_T, {
+    [K in keyof OBJ_T]: OBJ_T[K] extends VALUE_T ? K : never;
+}[keyof OBJ_T]>;
+type ObjectEntries<OBJ_T> = {
+    [K in keyof OBJ_T]: [keyof PickByValue<OBJ_T, OBJ_T[K]>, OBJ_T[K]];
+}[keyof OBJ_T][];
+export declare const objectKeys: <O extends Object>(obj: O) => (keyof O)[];
+export declare function objectEntries<OBJ_T extends ObjectType>(obj: OBJ_T): ObjectEntries<OBJ_T>;
+type EntriesType = [PropertyKey, unknown][] | ReadonlyArray<readonly [PropertyKey, unknown]>;
+type DeepWritable<OBJ_T> = {
+    -readonly [P in keyof OBJ_T]: DeepWritable<OBJ_T[P]>;
+};
+type UnionToIntersection<UNION_T> = (UNION_T extends any ? (k: UNION_T) => void : never) extends (k: infer I) => void ? I : never;
+type UnionObjectFromArrayOfPairs<ARR_T extends EntriesType> = DeepWritable<ARR_T> extends (infer R)[] ? R extends [infer key, infer val] ? {
+    [prop in key & PropertyKey]: val;
+} : never : never;
+type MergeIntersectingObjects<ObjT> = {
+    [key in keyof ObjT]: ObjT[key];
+};
+type EntriesToObject<ARR_T extends EntriesType> = MergeIntersectingObjects<UnionToIntersection<UnionObjectFromArrayOfPairs<ARR_T>>>;
+export declare function objectFromEntries<ARR_T extends EntriesType>(arr: ARR_T): EntriesToObject<ARR_T>;
+export {};
+//# sourceMappingURL=helpers.d.ts.map