@hanzogui/create-theme 2.0.0

package/src/applyMask.tsx

@@ -0,0 +1,69 @@
+import { createTheme } from './createTheme'
+import type { CreateMask, GenericTheme, MaskOptions, ThemeMask } from './createThemeTypes'
+import type { ThemeInfo } from './themeInfo'
+import { getThemeInfo, setThemeInfo } from './themeInfo'
+
+export function applyMask<Theme extends GenericTheme | ThemeMask>(
+  theme: Theme,
+  mask: CreateMask,
+  options: MaskOptions = {},
+  parentName?: string,
+  nextName?: string
+): Theme {
+  const info = getThemeInfo(theme, parentName)
+  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 next = applyMaskStateless(info, mask, options, parentName)
+
+  setThemeInfo(next.theme, {
+    definition: next.definition,
+    palette: info.palette,
+    name: nextName,
+  })
+
+  return next.theme as Theme
+}
+
+export function applyMaskStateless<Theme extends GenericTheme | ThemeMask>(
+  info: ThemeInfo,
+  mask: CreateMask,
+  options: MaskOptions = {},
+  parentName?: string
+): ThemeInfo & {
+  theme: Theme
+} {
+  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 maskOptions = {
+    parentName,
+    palette: info.palette,
+    ...options,
+    skip,
+  }
+
+  const template = mask.mask(info.definition, maskOptions)
+  const theme = createTheme(info.palette, template) as Theme
+
+  return {
+    ...info,
+    cache: new Map(),
+    definition: template,
+    theme,
+  }
+}

package/src/combineMasks.tsx

@@ -0,0 +1,29 @@
+import { applyMaskStateless } from './applyMask'
+import type { CreateMask } from './createThemeTypes'
+import { getThemeInfo } from './themeInfo'
+
+export const combineMasks = (...masks: CreateMask[]): CreateMask => {
+  const mask: CreateMask = {
+    name: 'combine-mask',
+    mask: (template, opts) => {
+      let current = getThemeInfo(template, opts.parentName)
+      let theme: any
+      for (const mask of masks) {
+        if (!current) {
+          throw new Error(
+            `Nothing returned from mask: ${current}, for template: ${template} and mask: ${mask.toString()}, given opts ${JSON.stringify(
+              opts,
+              null,
+              2
+            )}`
+          )
+        }
+        const next = applyMaskStateless(current, mask, opts)
+        current = next
+        theme = next.theme
+      }
+      return theme
+    },
+  }
+  return mask
+}

package/src/createTheme.tsx

@@ -0,0 +1,127 @@
+import type {
+  CreateThemeOptions,
+  CreateThemePalette,
+  GenericTheme,
+  ThemeMask,
+} from './createThemeTypes'
+import { isMinusZero } from './isMinusZero'
+import { setThemeInfo } from './themeInfo'
+
+const identityCache = new Map()
+
+export function createThemeWithPalettes<
+  Definition extends ThemeMask,
+  Extras extends GenericTheme = {},
+>(
+  palettes: Record<string, CreateThemePalette>,
+  defaultPalette: string,
+  definition: Definition,
+  options?: CreateThemeOptions,
+  name?: string,
+  skipCache = false
+): {
+  [key in keyof Definition | keyof Extras]: string
+} {
+  if (!palettes[defaultPalette]) {
+    throw new Error(`No palette: ${defaultPalette}`)
+  }
+  const newDef = { ...definition }
+  for (const key in definition) {
+    let val = definition[key]
+    if (typeof val === 'string' && val[0] === '$') {
+      const [altPaletteName$, altPaletteIndex] = val.split('.')
+      const altPaletteName = altPaletteName$.slice(1)
+      const parentName = defaultPalette.split('_')[0]
+      const altPalette =
+        palettes[altPaletteName] || palettes[`${parentName}_${altPaletteName}`]
+
+      if (altPalette) {
+        const next = getValue(altPalette, +altPaletteIndex)
+        if (typeof next !== 'undefined') {
+          newDef[key] = next as any
+        }
+      }
+    }
+  }
+
+  return createTheme(palettes[defaultPalette], newDef, options, name, skipCache)
+}
+
+export function createTheme<
+  Definition extends ThemeMask,
+  Extras extends GenericTheme = {},
+>(
+  palette: CreateThemePalette,
+  definition: Definition,
+  options?: CreateThemeOptions,
+  name?: string,
+  skipCache = false
+): {
+  [key in keyof Definition | keyof Extras]: string
+} {
+  const cacheKey = skipCache ? '' : JSON.stringify([name, palette, definition, options])
+  if (!skipCache) {
+    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, name })
+
+  if (cacheKey) {
+    identityCache.set(cacheKey, theme)
+  }
+
+  return theme
+}
+
+const getValue = (palette: CreateThemePalette, value: string | number) => {
+  if (!palette) {
+    throw new Error(`No palette!`)
+  }
+  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/createThemeTypes.tsx

@@ -0,0 +1,85 @@
+import type { Variable } from '@hanzogui/web'
+
+export type CreateThemePalette = (string | Variable)[]
+
+export type ThemeMask = Record<string, string | number>
+
+export type MaskOptions = {
+  palette?: CreateThemePalette
+  override?: Partial<ThemeMask>
+  overrideStrategy?: 'shift' | 'swap'
+  overrideSwap?: Partial<ThemeMask>
+  overrideShift?: Partial<ThemeMask>
+  skip?: Partial<ThemeMask>
+  strength?: number
+  max?: number
+  min?: number
+  parentName?: string
+}
+
+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
+}
+
+export type Palette = string[]
+
+export type Template = {
+  [key: string]: number | string
+}
+
+export type ThemeUsingMask<Masks = string> = MaskOptions & {
+  mask: Masks
+  avoidNestingWithin?: string[]
+  childOptions?: MaskOptions & {
+    mask?: Masks
+  }
+}
+
+export type ThemeUsingTemplate = CreateThemeOptions & {
+  palette?: string
+  template: string
+}
+
+type ThemePreDefined = {
+  theme: { [key: string]: string }
+}
+
+export type Theme<Masks = string> =
+  | ThemePreDefined
+  | ThemeUsingTemplate
+  | ThemeUsingMask<Masks>
+
+export type ThemeWithParent<Masks = string> = Theme<Masks> & {
+  parent: string
+}
+
+export type PaletteDefinitions = {
+  [key: string]: Palette
+}
+
+export type ThemeDefinition<Masks extends string = string> =
+  | Theme<Masks>
+  | ThemeWithParent<Masks>[]
+
+type UnionableString = string & {}
+
+export type ThemeDefinitions<Masks extends string = string> = {
+  [key: string]: ThemeDefinition<Masks | UnionableString>
+}
+
+export type TemplateDefinitions = {
+  [key: string]: Template
+}
+
+export type MaskDefinitions = {
+  [key: string]: CreateMask | CreateMask['mask']
+}

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

@@ -0,0 +1,6 @@
+export * from './createTheme'
+export * from './masks'
+export * from './combineMasks'
+export * from './applyMask'
+export * from './createThemeTypes'
+export * from './helpers'

package/src/isMinusZero.tsx

@@ -0,0 +1,3 @@
+export function isMinusZero(value: number): boolean {
+  return 1 / value === Number.NEGATIVE_INFINITY
+}

package/src/masks.tsx

@@ -0,0 +1,137 @@
+import type { CreateMask, MaskFunction, MaskOptions } from './createThemeTypes'
+import { objectEntries, objectFromEntries } from './helpers'
+import { isMinusZero } from './isMinusZero'
+
+export const createMask = <C extends CreateMask | MaskFunction>(
+  createMask: C
+): CreateMask =>
+  typeof createMask === 'function'
+    ? { name: createMask.name || 'unnamed', mask: createMask }
+    : createMask
+
+export const skipMask: CreateMask = {
+  name: 'skip-mask',
+  mask: (template, opts) => {
+    const { skip } = opts
+    const result = Object.fromEntries(
+      Object.entries(template)
+        .filter(([k]) => !skip || !(k in skip))
+        .map(([k, v]) => [k, applyOverrides(k, v, opts)])
+    ) as typeof template
+
+    return result
+  },
+}
+
+function applyOverrides(key: string, value: number | string, opts: MaskOptions) {
+  let override: string | number | undefined
+  let strategy = opts.overrideStrategy
+
+  const overrideSwap = opts.overrideSwap?.[key]
+  if (typeof overrideSwap !== 'undefined') {
+    override = overrideSwap
+    strategy = 'swap'
+  } else {
+    const overrideShift = opts.overrideShift?.[key]
+    if (typeof overrideShift !== 'undefined') {
+      override = overrideShift
+      strategy = 'shift'
+    } else {
+      const overrideDefault = opts.override?.[key]
+      if (typeof overrideDefault !== 'undefined') {
+        override = overrideDefault
+        strategy = opts.overrideStrategy
+      }
+    }
+  }
+
+  if (typeof override === 'undefined') return value
+  if (typeof override === 'string') return value
+
+  if (strategy === 'swap') {
+    return override
+  }
+
+  return value
+}
+
+export const createIdentityMask = (): CreateMask => ({
+  name: 'identity-mask',
+  mask: (template, opts) => skipMask.mask(template, opts),
+})
+
+export const createInverseMask = (): CreateMask => {
+  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
+): CreateMask => {
+  const mask: CreateMask = {
+    name: 'shift-mask',
+    mask: (template, opts) => {
+      const {
+        override,
+        overrideStrategy = 'shift',
+        max: maxIn,
+        palette,
+        min = 0,
+        strength = 1,
+      } = { ...defaultOptions, ...opts }
+      const values = Object.entries(template)
+      const max =
+        maxIn ?? (palette ? Object.values(palette).length - 1 : Number.POSITIVE_INFINITY)
+      const out = {}
+      for (const [key, value] of values) {
+        if (typeof value === 'string') continue
+        if (typeof override?.[key] === 'number') {
+          const overrideVal = override[key] as number
+          out[key] = overrideStrategy === 'shift' ? value + overrideVal : overrideVal
+          continue
+        }
+        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
+      }
+
+      const skipped = skipMask.mask(out, opts) as typeof template
+      return skipped
+    },
+  }
+  return mask
+}
+
+export const createWeakenMask = (defaultOptions?: MaskOptions): CreateMask => ({
+  name: 'soften-mask',
+  mask: createShiftMask({}, defaultOptions).mask,
+})
+
+export const createSoftenMask: (defaultOptions?: MaskOptions) => CreateMask =
+  createWeakenMask
+
+export const createStrengthenMask = (defaultOptions?: MaskOptions): CreateMask => ({
+  name: 'strengthen-mask',
+  mask: createShiftMask({ inverse: true }, defaultOptions).mask,
+})

package/src/tests.tsx

@@ -0,0 +1,28 @@
+import { applyMask } from './applyMask'
+import { createTheme } from './createTheme'
+import { 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,36 @@
+import type {
+  CreateThemeOptions,
+  CreateThemePalette,
+  GenericTheme,
+  ThemeMask,
+} from './createThemeTypes'
+
+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,
+  name?: string
+): ThemeInfo | undefined => {
+  return THEME_INFO.get(name || JSON.stringify(theme))
+}
+
+export const setThemeInfo = (
+  theme: GenericTheme | ThemeMask,
+  info: Pick<ThemeInfo, 'palette' | 'definition' | 'options'> & {
+    name?: string
+  }
+): void => {
+  const next = {
+    ...info,
+    cache: new Map(),
+  }
+  THEME_INFO.set(info.name || JSON.stringify(theme), next)
+  THEME_INFO.set(JSON.stringify(info.definition), next)
+}

package/types/applyMask.d.ts

@@ -0,0 +1,8 @@
+import type { CreateMask, GenericTheme, MaskOptions, ThemeMask } from "./createThemeTypes";
+import type { ThemeInfo } from "./themeInfo";
+export declare function applyMask<Theme extends GenericTheme | ThemeMask>(theme: Theme, mask: CreateMask, options?: MaskOptions, parentName?: string, nextName?: string): Theme;
+export declare function applyMaskStateless<Theme extends GenericTheme | ThemeMask>(info: ThemeInfo, mask: CreateMask, options?: MaskOptions, parentName?: string): ThemeInfo & {
+	theme: Theme;
+};
+
+//# sourceMappingURL=applyMask.d.ts.map

package/types/applyMask.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": "AACA,cAAc,YAAY,cAAc,aAAa,iBAAiB;AACtE,cAAc,iBAAiB;AAG/B,OAAO,iBAAS,UAAU,cAAc,eAAe,WACrD,OAAO,OACP,MAAM,YACN,UAAS,aACT,qBACA,oBACC;AAqBH,OAAO,iBAAS,mBAAmB,cAAc,eAAe,WAC9D,MAAM,WACN,MAAM,YACN,UAAS,aACT,sBACC,YAAY;CACb,OAAO",
+  "names": [],
+  "sources": [
+    "src/applyMask.tsx"
+  ],
+  "version": 3,
+  "sourcesContent": [
+    "import { createTheme } from './createTheme'\nimport type { CreateMask, GenericTheme, MaskOptions, ThemeMask } from './createThemeTypes'\nimport type { ThemeInfo } from './themeInfo'\nimport { getThemeInfo, setThemeInfo } from './themeInfo'\n\nexport function applyMask<Theme extends GenericTheme | ThemeMask>(\n  theme: Theme,\n  mask: CreateMask,\n  options: MaskOptions = {},\n  parentName?: string,\n  nextName?: string\n): Theme {\n  const info = getThemeInfo(theme, parentName)\n  if (!info) {\n    throw new Error(\n      process.env.NODE_ENV !== 'production'\n        ? `No info found for theme, you must pass the theme created by createThemeFromPalette directly to extendTheme`\n        : `❌ Err2`\n    )\n  }\n\n  const next = applyMaskStateless(info, mask, options, parentName)\n\n  setThemeInfo(next.theme, {\n    definition: next.definition,\n    palette: info.palette,\n    name: nextName,\n  })\n\n  return next.theme as Theme\n}\n\nexport function applyMaskStateless<Theme extends GenericTheme | ThemeMask>(\n  info: ThemeInfo,\n  mask: CreateMask,\n  options: MaskOptions = {},\n  parentName?: string\n): ThemeInfo & {\n  theme: Theme\n} {\n  const skip = {\n    ...options.skip,\n  }\n\n  // skip nonInheritedValues from parent theme\n  if (info.options?.nonInheritedValues) {\n    for (const key in info.options.nonInheritedValues) {\n      skip[key] = 1\n    }\n  }\n\n  // convert theme back to template first\n  const maskOptions = {\n    parentName,\n    palette: info.palette,\n    ...options,\n    skip,\n  }\n\n  const template = mask.mask(info.definition, maskOptions)\n  const theme = createTheme(info.palette, template) as Theme\n\n  return {\n    ...info,\n    cache: new Map(),\n    definition: template,\n    theme,\n  }\n}\n"
+  ]
+}

package/types/combineMasks.d.ts

@@ -0,0 +1,4 @@
+import type { CreateMask } from "./createThemeTypes";
+export declare const combineMasks: (...masks: CreateMask[]) => CreateMask;
+
+//# sourceMappingURL=combineMasks.d.ts.map

package/types/combineMasks.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": "AACA,cAAc,kBAAkB;AAGhC,OAAO,cAAM,eAAgB,GAAG,OAAO,iBAAe",
+  "names": [],
+  "sources": [
+    "src/combineMasks.tsx"
+  ],
+  "version": 3,
+  "sourcesContent": [
+    "import { applyMaskStateless } from './applyMask'\nimport type { CreateMask } from './createThemeTypes'\nimport { getThemeInfo } from './themeInfo'\n\nexport const combineMasks = (...masks: CreateMask[]): CreateMask => {\n  const mask: CreateMask = {\n    name: 'combine-mask',\n    mask: (template, opts) => {\n      let current = getThemeInfo(template, opts.parentName)\n      let theme: any\n      for (const mask of masks) {\n        if (!current) {\n          throw new Error(\n            `Nothing returned from mask: ${current}, for template: ${template} and mask: ${mask.toString()}, given opts ${JSON.stringify(\n              opts,\n              null,\n              2\n            )}`\n          )\n        }\n        const next = applyMaskStateless(current, mask, opts)\n        current = next\n        theme = next.theme\n      }\n      return theme\n    },\n  }\n  return mask\n}\n"
+  ]
+}

package/types/createTheme.d.ts

@@ -0,0 +1,28 @@
+import type { CreateThemeOptions, CreateThemePalette, GenericTheme, ThemeMask } from "./createThemeTypes";
+export declare function createThemeWithPalettes<
+	Definition extends ThemeMask,
+	Extras extends GenericTheme = {}
+>(palettes: Record<string, CreateThemePalette>, defaultPalette: string, definition: Definition, options?: CreateThemeOptions, name?: string, skipCache?: boolean): { [key in keyof Definition | keyof Extras] : string };
+export declare function createTheme<
+	Definition extends ThemeMask,
+	Extras extends GenericTheme = {}
+>(palette: CreateThemePalette, definition: Definition, options?: CreateThemeOptions, name?: string, skipCache?: boolean): { [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/createTheme.d.ts.map

@@ -0,0 +1,11 @@
+{
+  "mappings": "AAAA,cACE,oBACA,oBACA,cACA,iBACK;AAMP,OAAO,iBAAS;CACd,mBAAmB;CACnB,eAAe,eAAe;EAE9B,UAAU,eAAe,qBACzB,wBACA,YAAY,YACZ,UAAU,oBACV,eACA,yBAEC,aAAa,mBAAmB;AA2BnC,OAAO,iBAAS;CACd,mBAAmB;CACnB,eAAe,eAAe;EAE9B,SAAS,oBACT,YAAY,YACZ,UAAU,oBACV,eACA,yBAEC,aAAa,mBAAmB;KAyC9B;CAAa;CAAY;OAAgB,4BAC1C,sBACS,2BAA2B;KAEnC;CAAY;CAAuC,cAAc;KACpE,MAAM,MACN,OAAO,UACJ;gBAAiB;;AAEtB,OAAO,iBAAS;CACd,eAAe;iBAAiB;;CAChC,oBAAoB,kBAAkB,QAAQ,aAAa;EAE3D,QAAQ,QACR,aAAa,cACZ,YACA,OAAO,mBAAmB,cAAc,WAAW,iBAAgB,aAAa",
+  "names": [],
+  "sources": [
+    "src/createTheme.tsx"
+  ],
+  "version": 3,
+  "sourcesContent": [
+    "import type {\n  CreateThemeOptions,\n  CreateThemePalette,\n  GenericTheme,\n  ThemeMask,\n} from './createThemeTypes'\nimport { isMinusZero } from './isMinusZero'\nimport { setThemeInfo } from './themeInfo'\n\nconst identityCache = new Map()\n\nexport function createThemeWithPalettes<\n  Definition extends ThemeMask,\n  Extras extends GenericTheme = {},\n>(\n  palettes: Record<string, CreateThemePalette>,\n  defaultPalette: string,\n  definition: Definition,\n  options?: CreateThemeOptions,\n  name?: string,\n  skipCache = false\n): {\n  [key in keyof Definition | keyof Extras]: string\n} {\n  if (!palettes[defaultPalette]) {\n    throw new Error(`No palette: ${defaultPalette}`)\n  }\n  const newDef = { ...definition }\n  for (const key in definition) {\n    let val = definition[key]\n    if (typeof val === 'string' && val[0] === '$') {\n      const [altPaletteName$, altPaletteIndex] = val.split('.')\n      const altPaletteName = altPaletteName$.slice(1)\n      const parentName = defaultPalette.split('_')[0]\n      const altPalette =\n        palettes[altPaletteName] || palettes[`${parentName}_${altPaletteName}`]\n\n      if (altPalette) {\n        const next = getValue(altPalette, +altPaletteIndex)\n        if (typeof next !== 'undefined') {\n          newDef[key] = next as any\n        }\n      }\n    }\n  }\n\n  return createTheme(palettes[defaultPalette], newDef, options, name, skipCache)\n}\n\nexport function createTheme<\n  Definition extends ThemeMask,\n  Extras extends GenericTheme = {},\n>(\n  palette: CreateThemePalette,\n  definition: Definition,\n  options?: CreateThemeOptions,\n  name?: string,\n  skipCache = false\n): {\n  [key in keyof Definition | keyof Extras]: string\n} {\n  const cacheKey = skipCache ? '' : JSON.stringify([name, palette, definition, options])\n  if (!skipCache) {\n    if (identityCache.has(cacheKey)) {\n      return identityCache.get(cacheKey)\n    }\n  }\n\n  const theme = {\n    ...(Object.fromEntries(\n      Object.entries(definition).map(([key, offset]) => {\n        return [key, getValue(palette, offset)]\n      })\n    ) as any),\n    ...options?.nonInheritedValues,\n  }\n\n  setThemeInfo(theme, { palette, definition, options, name })\n\n  if (cacheKey) {\n    identityCache.set(cacheKey, theme)\n  }\n\n  return theme\n}\n\nconst getValue = (palette: CreateThemePalette, value: string | number) => {\n  if (!palette) {\n    throw new Error(`No palette!`)\n  }\n  if (typeof value === 'string') {\n    return value\n  }\n  const max = palette.length - 1\n  const isPositive = value === 0 ? !isMinusZero(value) : value >= 0\n  const next = isPositive ? value : max + value\n  const index = Math.min(Math.max(0, next), max)\n  return palette[index]\n}\n\ntype SubThemeKeys<ParentKeys, ChildKeys> = `${ParentKeys extends string\n  ? ParentKeys\n  : never}_${ChildKeys extends string ? ChildKeys : never}`\n\ntype ChildGetter<Name extends string | number | symbol, Theme extends GenericTheme> = (\n  name: Name,\n  theme: Theme\n) => { [key: string]: Theme }\n\nexport function addChildren<\n  Themes extends { [key: string]: GenericTheme },\n  GetChildren extends ChildGetter<keyof Themes, Themes[keyof Themes]>,\n>(\n  themes: Themes,\n  getChildren: GetChildren\n): Themes & {\n  [key in SubThemeKeys<keyof Themes, keyof ReturnType<GetChildren>>]: Themes[keyof Themes]\n} {\n  const out = { ...themes }\n  for (const key in themes) {\n    const subThemes = getChildren(key, themes[key])\n    for (const sKey in subThemes) {\n      out[`${key}_${sKey}`] = subThemes[sKey] as any\n    }\n  }\n  return out as any\n}\n"
+  ]
+}