@tamagui/config 2.7.7 → 3.0.0-beta.643.1

package/src/v5-fonts.ts

@@ -1,112 +1,42 @@
-import type { FillInFont, GenericFont } from '@tamagui/core'
-import { createFont, getVariableValue } from '@tamagui/core'
-
-const isWeb = process.env.TAMAGUI_TARGET === 'web'
+import { createSystemFont } from '@tamagui/create-system-font'
 const isNative = process.env.TAMAGUI_TARGET === 'native'
 
-// web sizes
-const webSizes = {
-  1: 12,
-  2: 13,
-  3: 14,
-  4: 15,
-  true: 15,
-  5: 16,
-  6: 18,
-  7: 22,
-  8: 26,
-  9: 30,
-  10: 40,
-  11: 46,
-  12: 52,
-  13: 60,
-  14: 70,
-  15: 85,
-  16: 100,
-} as const
-
-// native sizes aligned with iOS HIG (SF Pro)
-// 4/true = body (17pt), 3 = subheadline (15pt), 2 = caption (12pt)
-const nativeSizes = {
-  1: 11,
-  2: 12,
-  3: 15,
-  4: 17,
-  true: 17,
-  5: 20,
-  6: 22,
-  7: 24,
-  8: 28,
-  9: 32,
-  10: 40,
-  11: 46,
-  12: 52,
-  13: 60,
-  14: 70,
-  15: 85,
-  16: 100,
-} as const
-
-const defaultSizes = isNative ? nativeSizes : webSizes
-
-// line height: native per iOS HIG (size + 5), web 150% tapering to ~142% for large sizes
-const defaultLineHeight = (size: number) => {
-  if (isNative) return Math.round(size + 5)
-  // taper from 1.5 at small sizes to ~1.42 at 40px
-  const ratio = 1.5 - Math.max(0, (size - 20) * 0.004)
-  return Math.round(size * ratio)
-}
-
-export const createSystemFont = <A extends GenericFont>({
-  font = {},
-  sizeLineHeight = defaultLineHeight,
-  sizeSize = (size) => Math.round(size),
-}: {
-  font?: Partial<A>
-  sizeLineHeight?: (fontSize: number) => number
-  sizeSize?: (size: number) => number
-} = {}): FillInFont<A, keyof typeof webSizes> => {
-  // merge to allow individual overrides
-  const size = Object.fromEntries(
-    Object.entries({
-      ...defaultSizes,
-      ...font.size,
-    }).map(([k, v]) => [k, sizeSize(+v)])
-  )
-  return createFont({
-    family: isWeb
-      ? '-apple-system, system-ui, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif'
-      : 'System',
-    lineHeight: Object.fromEntries(
-      Object.entries(size).map(([k, v]) => [k, sizeLineHeight(getVariableValue(v))])
-    ),
-    weight: {
-      1: '400',
-    },
-    letterSpacing: {
-      4: 0,
-    },
-    ...(font as any),
-    size,
-  })
-}
+export { createSystemFont }
 
 // heading line height: native ~120%, web original
 const headingLineHeight = (size: number) =>
   Math.round(isNative ? size * 1.2 : size * 1.12 + 5)
 
+// pin the v5 font size + lineHeight scales to exact "Npx" strings. numbers are
+// reserved for the v6 multiplier semantics; px strings mean "exact pixels" and
+// are normalized back to numbers (with a needsPx flag) at token creation, so
+// rendering is identical to the previous numeric config. the numeric type is
+// preserved via cast to avoid widening every font-size consumer.
+const toPxScale = <T extends Record<string, number>>(obj: T): T =>
+  Object.fromEntries(
+    Object.entries(obj).map(([k, v]) => [k, typeof v === 'number' ? `${v}px` : v])
+  ) as unknown as T
+
+const pinFontToPx = <F extends { size: any; lineHeight?: any }>(font: F): F => ({
+  ...font,
+  size: toPxScale(font.size),
+  ...(font.lineHeight ? { lineHeight: toPxScale(font.lineHeight) } : null),
+})
+
 export const fonts = {
-  body: createSystemFont(),
-  heading: createSystemFont({
-    font: {
-      weight: {
-        0: '600',
-        6: '700',
-        9: '800',
+  body: pinFontToPx(createSystemFont()),
+  heading: pinFontToPx(
+    createSystemFont({
+      font: {
+        weight: {
+          0: '600',
+          6: '700',
+          9: '800',
+        },
       },
-    },
-    sizeLineHeight: headingLineHeight,
-  }),
+      sizeLineHeight: headingLineHeight,
+    })
+  ),
 }
 
 export type V5Fonts = typeof fonts

package/src/v5.ts

@@ -1,6 +1,6 @@
 // v5 base - no animations bundled, users import from specific paths:
 //   @tamagui/config/v5-css
-//   @tamagui/config/v5-native
+//   @tamagui/config/v5-rn
 //   @tamagui/config/v5-reanimated
 
 export * from '@tamagui/themes/v5'

package/src/v6-base.ts

@@ -0,0 +1,112 @@
+// the aligned v6 base: Tailwind-aligned shorthands, scales, fonts, media and settings.
+// colors and themes are deliberately separate so createV6Config can accept any pack.
+import { shorthands } from '@tamagui/shorthands/v6'
+import type { CreateTamaguiProps } from '@tamagui/web'
+import { fonts as systemFonts } from './fonts'
+import { media } from './media'
+import { selectionStyles, settings as baseSettings } from './settings'
+import {
+  tailwindFontSize,
+  tailwindLineHeight,
+  tailwindRadius,
+  tailwindSize,
+  tailwindSpace,
+} from './v6-tailwind-scales.generated'
+
+export { shorthands }
+export { createSystemFont } from './fonts'
+export { breakpoints, media, mediaQueryDefaultActive } from './media'
+export { selectionStyles }
+export { tailwindSource } from './v6-tailwind-scales.generated'
+export {
+  v6RemovedThemeNames,
+  v6ThemeNameReplacements,
+} from '@tamagui/style-grammar/tooling'
+export { toV6Themes, type V6Theme, type V6Themes } from './v6-themes'
+// space and size deliberately remain separate configured domains even though their default
+// values coincide. z-index is literal, so its identity scale is not configured as tokens.
+export const tokens = {
+  space: tailwindSpace,
+  size: tailwindSize,
+  radius: {
+    0: 0,
+    1: 3,
+    2: 5,
+    3: 7,
+    4: 9,
+    5: 10,
+    6: 16,
+    7: 19,
+    8: 22,
+    9: 26,
+    10: 34,
+    11: 42,
+    12: 50,
+    ...tailwindRadius,
+  },
+} as const
+
+function withTailwindTypeScale<F extends { size: object; lineHeight: object }>(font: F) {
+  return {
+    ...font,
+    size: { ...font.size, ...tailwindFontSize },
+    lineHeight: { ...font.lineHeight, ...tailwindLineHeight },
+  }
+}
+
+export const fonts = {
+  body: withTailwindTypeScale(systemFonts.body),
+  heading: withTailwindTypeScale(systemFonts.heading),
+} satisfies NonNullable<CreateTamaguiProps['fonts']>
+
+export const settings = {
+  ...baseSettings,
+} satisfies CreateTamaguiProps['settings']
+
+export type V6Settings = typeof settings
+
+/**
+ * A v6 colors pack: the one seam where color choice enters the config.
+ * Themes should be generated from the same palette as the color tokens.
+ */
+export type V6Colors = {
+  themes: NonNullable<CreateTamaguiProps['themes']>
+  /** flat named colors added at tokens.color */
+  colorTokens?: Record<string, string>
+}
+
+const alignedConfig = {
+  media,
+  shorthands,
+  fonts,
+  selectionStyles,
+  settings,
+}
+
+/** Compose the aligned v6 base with a colors pack into a createTamagui-ready config. */
+export function createV6Config<
+  Themes extends NonNullable<CreateTamaguiProps['themes']>,
+  ColorTokens extends Record<string, string>,
+>(colors: {
+  themes: Themes
+  colorTokens: ColorTokens
+}): typeof alignedConfig & {
+  themes: Themes
+  tokens: typeof tokens & { color: ColorTokens }
+}
+export function createV6Config<
+  Themes extends NonNullable<CreateTamaguiProps['themes']>,
+>(colors: {
+  themes: Themes
+  colorTokens?: undefined
+}): typeof alignedConfig & {
+  themes: Themes
+  tokens: typeof tokens
+}
+export function createV6Config(colors: V6Colors) {
+  return {
+    ...alignedConfig,
+    themes: colors.themes,
+    tokens: colors.colorTokens ? { ...tokens, color: colors.colorTokens } : tokens,
+  }
+}

package/src/v6-builder.ts

@@ -0,0 +1 @@
+export * from '@tamagui/themes/builder'

package/src/v6-tailwind-scales.generated.ts

@@ -0,0 +1,161 @@
+// AUTO-GENERATED from tailwindcss@4.3.0 with @csstools/color-helpers@6.1.0. Do not edit.
+// Source checksum: d8fc16823f2b4e64ea102d9888d8ca3d7aa97e4551d9cd5f17c0ec6d65bb0bf6
+export const tailwindSource = {
+  tailwindVersion: '4.3.0',
+  colorConverter: '@csstools/color-helpers@6.1.0',
+  checksum: 'd8fc16823f2b4e64ea102d9888d8ca3d7aa97e4551d9cd5f17c0ec6d65bb0bf6',
+} as const
+
+export const tailwindSpace = {
+  '0': 0,
+  '1': 4,
+  '2': 8,
+  '3': 12,
+  '4': 16,
+  '5': 20,
+  '6': 24,
+  '7': 28,
+  '8': 32,
+  '9': 36,
+  '10': 40,
+  '11': 44,
+  '12': 48,
+  '14': 56,
+  '16': 64,
+  '20': 80,
+  '24': 96,
+  '28': 112,
+  '32': 128,
+  '36': 144,
+  '40': 160,
+  '44': 176,
+  '48': 192,
+  '52': 208,
+  '56': 224,
+  '60': 240,
+  '64': 256,
+  '72': 288,
+  '80': 320,
+  '96': 384,
+  px: 1,
+  '0-5': 2,
+  '1-5': 6,
+  '2-5': 10,
+  '3-5': 14,
+  '-px': -1,
+  '-0-5': -2,
+  '-1': -4,
+  '-1-5': -6,
+  '-2': -8,
+  '-2-5': -10,
+  '-3': -12,
+  '-3-5': -14,
+  '-4': -16,
+  '-5': -20,
+  '-6': -24,
+  '-7': -28,
+  '-8': -32,
+  '-9': -36,
+  '-10': -40,
+  '-11': -44,
+  '-12': -48,
+  '-14': -56,
+  '-16': -64,
+  '-20': -80,
+  '-24': -96,
+  '-28': -112,
+  '-32': -128,
+  '-36': -144,
+  '-40': -160,
+  '-44': -176,
+  '-48': -192,
+  '-52': -208,
+  '-56': -224,
+  '-60': -240,
+  '-64': -256,
+  '-72': -288,
+  '-80': -320,
+  '-96': -384,
+} as const
+
+export const tailwindSize = {
+  '0': 0,
+  '1': 4,
+  '2': 8,
+  '3': 12,
+  '4': 16,
+  '5': 20,
+  '6': 24,
+  '7': 28,
+  '8': 32,
+  '9': 36,
+  '10': 40,
+  '11': 44,
+  '12': 48,
+  '14': 56,
+  '16': 64,
+  '20': 80,
+  '24': 96,
+  '28': 112,
+  '32': 128,
+  '36': 144,
+  '40': 160,
+  '44': 176,
+  '48': 192,
+  '52': 208,
+  '56': 224,
+  '60': 240,
+  '64': 256,
+  '72': 288,
+  '80': 320,
+  '96': 384,
+  px: 1,
+  '0-5': 2,
+  '1-5': 6,
+  '2-5': 10,
+  '3-5': 14,
+} as const
+
+export const tailwindRadius = {
+  xs: 2,
+  sm: 4,
+  md: 6,
+  lg: 8,
+  xl: 12,
+  '2xl': 16,
+  '3xl': 24,
+  '4xl': 32,
+  full: 9999,
+} as const
+
+export const tailwindFontSize = {
+  xs: 12,
+  sm: 14,
+  base: 16,
+  lg: 18,
+  xl: 20,
+  '2xl': 24,
+  '3xl': 30,
+  '4xl': 36,
+  '5xl': 48,
+  '6xl': 60,
+  '7xl': 72,
+  '8xl': 96,
+  '9xl': 128,
+} as const
+
+export const tailwindLineHeight = {
+  xs: 16,
+  sm: 20,
+  base: 24,
+  lg: 28,
+  xl: 28,
+  '2xl': 32,
+  '3xl': 36,
+  '4xl': 40,
+  '5xl': 48,
+  '6xl': 60,
+  '7xl': 72,
+  '8xl': 96,
+  '9xl': 128,
+} as const

package/src/v6-themes.ts

@@ -0,0 +1,46 @@
+import {
+  v6RemovedThemeNames,
+  v6ThemeNameReplacements,
+} from '@tamagui/style-grammar/tooling'
+
+export type V6Theme<Theme> = {
+  [Name in keyof Theme as Name extends (typeof v6RemovedThemeNames)[number]
+    ? never
+    : Name extends keyof typeof v6ThemeNameReplacements
+      ? (typeof v6ThemeNameReplacements)[Name]
+      : Name]: Theme[Name]
+}
+
+export type V6Themes<Themes extends Record<string, object>> = {
+  [Name in keyof Themes]: V6Theme<Themes[Name]>
+}
+
+/** Apply the v6 theme-key grammar to any generated theme pack. */
+export function toV6Themes<Themes extends Record<string, object>>(
+  themes: Themes
+): V6Themes<Themes> {
+  const convertedThemes = new WeakMap<object, object>()
+
+  return Object.fromEntries(
+    Object.entries(themes).map(([themeName, theme]) => {
+      let convertedTheme = convertedThemes.get(theme)
+
+      if (!convertedTheme) {
+        convertedTheme = Object.fromEntries(
+          Object.entries(theme)
+            .filter(
+              ([name]) => !(v6RemovedThemeNames as readonly string[]).includes(name)
+            )
+            .map(([name, value]) => [
+              v6ThemeNameReplacements[name as keyof typeof v6ThemeNameReplacements] ??
+                name,
+              value,
+            ])
+        )
+        convertedThemes.set(theme, convertedTheme)
+      }
+
+      return [themeName, convertedTheme]
+    })
+  ) as V6Themes<Themes>
+}

package/src/v6.ts

@@ -0,0 +1,30 @@
+// v6 defaults: aligned scales and the statically generated recipe-tree themes.
+// no animations are bundled; import a driver from its specific entry.
+import {
+  tailwindColors,
+  themes,
+  tokens as themeTokens,
+  type Theme,
+  type ThemeNames,
+  type Themes,
+} from '@tamagui/themes'
+import type { CreateTamaguiProps } from '@tamagui/web'
+import { createV6Config, tokens as baseTokens } from './v6-base'
+import type { V6Colors } from './v6-base'
+
+export * from './v6-base'
+export { tailwindColors, themes }
+export type { Theme as V6Theme, ThemeNames as V6ThemeNames, Themes as V6Themes }
+
+/** the Tailwind colors pack: color tokens + themes generated from the same palette */
+export const colors = {
+  themes,
+  colorTokens: themeTokens.color,
+} satisfies V6Colors
+
+export const tokens = {
+  ...baseTokens,
+  color: themeTokens.color,
+} as const
+
+export const defaultConfig = createV6Config(colors) satisfies CreateTamaguiProps

package/types/{v5-css.d.ts → animations-css.d.ts}

@@ -46,4 +46,4 @@ export declare const animations: import("@tamagui/web").AnimationDriver<{
     quickest: string;
     quickestLessBouncy: string;
 }>;
-//# sourceMappingURL=v5-css.d.ts.map
+//# sourceMappingURL=animations-css.d.ts.map

package/types/animations-css.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animations-css.d.ts","sourceRoot":"","sources":["../src/animations-css.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;EAuBxB,CAAA;AAEF,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;EAAgB,CAAA"}

package/{src/v3-animations.native.ts → types/animations-css.native.d.ts}

@@ -1 +1,2 @@
-export { animationsReactNative as animations } from './animationsReactNative'
+export { animationsReactNative as animations } from './animations-rn';
+//# sourceMappingURL=animations-css.native.d.ts.map

package/types/animations-css.native.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animations-css.native.d.ts","sourceRoot":"","sources":["../src/animations-css.native.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,qBAAqB,IAAI,UAAU,EAAE,MAAM,iBAAiB,CAAA"}

package/types/{v5-motion.d.ts → animations-motion.d.ts}

@@ -208,4 +208,4 @@ export declare const animations: import("@tamagui/web").AnimationDriver<{
         stiffness: number;
     };
 }>;
-//# sourceMappingURL=v5-motion.d.ts.map
+//# sourceMappingURL=animations-motion.d.ts.map

package/types/animations-motion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animations-motion.d.ts","sourceRoot":"","sources":["../src/animations-motion.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,gBAAgB;;QAEzB,QAAQ;;;QAGR,QAAQ;;;QAGR,QAAQ;;;QAGR,QAAQ;;;QAGR,QAAQ;;;QAGR,QAAQ;;;QAGR,QAAQ;;;QAGR,QAAQ;;;QAGR,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;QAyBR,OAAO;QACP,SAAS;QACT,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmDN,CAAA;AAEF,eAAO,MAAM,UAAU;;QAxGnB,QAAQ;;;QAGR,QAAQ;;;QAGR,QAAQ;;;QAGR,QAAQ;;;QAGR,QAAQ;;;QAGR,QAAQ;;;QAGR,QAAQ;;;QAGR,QAAQ;;;QAGR,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;QAyBR,OAAO;QACP,SAAS;QACT,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqDkC,CAAA"}

package/types/{v5-reanimated.d.ts → animations-reanimated.d.ts}

@@ -200,4 +200,4 @@ export declare const animations: import("@tamagui/web").AnimationDriver<{
         stiffness: number;
     };
 }>;
-//# sourceMappingURL=v5-reanimated.d.ts.map
+//# sourceMappingURL=animations-reanimated.d.ts.map

package/types/animations-reanimated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animations-reanimated.d.ts","sourceRoot":"","sources":["../src/animations-reanimated.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAsC7B,OAAO;QACP,IAAI;QACJ,SAAS;;;QAGT,OAAO;QACP,IAAI;QACJ,SAAS;;;QAGT,OAAO;QACP,IAAI;QACJ,SAAS;;;QAGT,OAAO;QACP,SAAS;QACT,IAAI;;;QAGJ,OAAO;QACP,IAAI;QACJ,SAAS;;;QAGT,OAAO;QACP,SAAS;;;QAGT,OAAO;QACP,SAAS;;;QAGT,OAAO;QACP,IAAI;QACJ,SAAS;;;QAGT,OAAO;QACP,IAAI;QACJ,SAAS;;;QAGT,OAAO;QACP,IAAI;QACJ,SAAS;;;QAGT,OAAO;QACP,IAAI;QACJ,SAAS;;;QAGT,OAAO;QACP,IAAI;QACJ,SAAS;;;QAGT,OAAO;QACP,IAAI;QACJ,SAAS;;EAEX,CAAA;AAEF,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAhEnB,OAAO;QACP,IAAI;QACJ,SAAS;;;QAGT,OAAO;QACP,IAAI;QACJ,SAAS;;;QAGT,OAAO;QACP,IAAI;QACJ,SAAS;;;QAGT,OAAO;QACP,SAAS;QACT,IAAI;;;QAGJ,OAAO;QACP,IAAI;QACJ,SAAS;;;QAGT,OAAO;QACP,SAAS;;;QAGT,OAAO;QACP,SAAS;;;QAGT,OAAO;QACP,IAAI;QACJ,SAAS;;;QAGT,OAAO;QACP,IAAI;QACJ,SAAS;;;QAGT,OAAO;QACP,IAAI;QACJ,SAAS;;;QAGT,OAAO;QACP,IAAI;QACJ,SAAS;;;QAGT,OAAO;QACP,IAAI;QACJ,SAAS;;;QAGT,OAAO;QACP,IAAI;QACJ,SAAS;;EAIiC,CAAA"}

package/types/{v5-rn.d.ts → animations-rn.d.ts}

@@ -220,4 +220,4 @@ export declare const animations: import("@tamagui/web").AnimationDriver<{
         stiffness: number;
     };
 }>;
-//# sourceMappingURL=v5-rn.d.ts.map
+//# sourceMappingURL=animations-rn.d.ts.map

package/types/animations-rn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animations-rn.d.ts","sourceRoot":"","sources":["../src/animations-rn.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QA8D9B,OAAO;QACP,SAAS;QACT,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAqCJ,OAAO;QACP,IAAI;QACJ,SAAS;;;QAGT,OAAO;QACP,IAAI;QACJ,SAAS;;EAEX,CAAA;AAEF,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAlDnB,OAAO;QACP,SAAS;QACT,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAqCJ,OAAO;QACP,IAAI;QACJ,SAAS;;;QAGT,OAAO;QACP,IAAI;QACJ,SAAS;;EAIkC,CAAA"}

package/types/fonts.d.ts

@@ -1,70 +1,8 @@
+import { createSystemFont } from '@tamagui/create-system-font';
+export { createSystemFont };
 export declare const fonts: {
-    heading: import("@tamagui/font-inter").FillInFont<{
-        size: {
-            5: number;
-            6: number;
-            9: number;
-            10: number;
-        };
-        transform: {
-            6: "uppercase";
-            7: "none";
-        };
-        weight: {
-            6: string;
-            7: string;
-        };
-        color: {
-            6: string;
-            7: string;
-        };
-        letterSpacing: {
-            5: number;
-            6: number;
-            7: number;
-            8: number;
-            9: number;
-            10: number;
-            12: number;
-            14: number;
-            15: number;
-        };
-        face: {
-            700: {
-                normal: string;
-            };
-            800: {
-                normal: string;
-            };
-            900: {
-                normal: string;
-            };
-        };
-    }, 9 | 15 | 1 | 10 | 3 | 2 | 5 | 6 | 16 | 11 | 12 | 14 | 4 | 7 | 8 | 13 | "true">;
-    body: import("@tamagui/font-inter").FillInFont<import("@tamagui/font-inter").GenericFont, 9 | 15 | 1 | 10 | 3 | 2 | 5 | 6 | 16 | 11 | 12 | 14 | 4 | 7 | 8 | 13 | "true">;
-    mono: {
-        weight: {
-            1: string;
-        };
-        size: {
-            1: number;
-            2: number;
-            3: number;
-            4: number;
-            5: number;
-            6: number;
-            7: number;
-            8: number;
-            9: number;
-            10: number;
-            11: number;
-            12: number;
-            13: number;
-            14: number;
-            15: number;
-            16: number;
-        };
-    };
-    silkscreen: import("@tamagui/font-inter").FillInFont<import("@tamagui/font-inter").GenericFont, 9 | 15 | 1 | 10 | 3 | 2 | 5 | 6 | 16 | 11 | 12 | 14 | 4 | 7 | 8 | 13>;
+    body: import("@tamagui/web").FillInFont<import("@tamagui/web").GenericFont, 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16>;
+    heading: import("@tamagui/web").FillInFont<import("@tamagui/web").GenericFont, 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16>;
 };
+export type Fonts = typeof fonts;
 //# sourceMappingURL=fonts.d.ts.map

package/types/fonts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fonts.d.ts","sourceRoot":"","sources":["../src/fonts.ts"],"names":[],"mappings":"AA0FA,eAAO,MAAM,KAAK;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKjB,CAAA"}
+{"version":3,"file":"fonts.d.ts","sourceRoot":"","sources":["../src/fonts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AAG9D,OAAO,EAAE,gBAAgB,EAAE,CAAA;AAM3B,eAAO,MAAM,KAAK;IAChB,IAAI;IACJ,OAAO;CAUR,CAAA;AAED,MAAM,MAAM,KAAK,GAAG,OAAO,KAAK,CAAA"}