@tamagui/core 1.0.1-beta.19 → 1.0.1-beta.190

package/types/types.d.ts

@@ -1,10 +1,47 @@
-import CSS from 'csstype';
-import React from 'react';
-import { GestureResponderEvent, Image, TextProps as ReactTextProps, Text, TextInput, TextStyle, View, ViewProps, ViewStyle } from 'react-native';
+import { Properties } from 'csstype';
+import React, { RefObject } from 'react';
+import { GestureResponderEvent, Image, PressableProps, TextProps as ReactTextProps, Text, TextInput, TextStyle, View, ViewProps, ViewStyle } from 'react-native';
 import { Variable } from './createVariable';
 import { ResolveVariableTypes } from './helpers/createPropMapper';
+import { TamaguiReactElement } from './static';
 import { RNWTextProps, RNWViewProps } from './types-rnw';
+import { FontLanguageProps } from './views/FontLanguage.types';
 import { ThemeProviderProps } from './views/ThemeProvider';
+export declare type SpaceDirection = 'vertical' | 'horizontal' | 'both';
+export declare type TamaguiElement = HTMLElement | View;
+export declare type DebugProp = boolean | 'break' | 'verbose';
+export declare type TamaguiComponentPropsBase = {
+    hitSlop?: PressableProps['hitSlop'];
+    asChild?: boolean;
+    space?: SpaceTokens | null;
+    spaceDirection?: SpaceDirection;
+    separator?: React.ReactNode;
+    dangerouslySetInnerHTML?: {
+        __html: string;
+    };
+    animation?: AnimationProp;
+    animateOnly?: string[];
+    children?: any | any[];
+    debug?: DebugProp;
+    disabled?: boolean;
+    className?: string;
+    themeShallow?: boolean;
+    id?: string;
+    tag?: string;
+    theme?: ThemeName | null;
+    componentName?: string;
+    forceStyle?: 'hover' | 'press' | 'focus';
+    onHoverIn?: (e: MouseEvent) => any;
+    onHoverOut?: (e: MouseEvent) => any;
+    onPress?: (e: GestureResponderEvent) => any;
+    onPressIn?: (e: GestureResponderEvent) => any;
+    onPressOut?: (e: GestureResponderEvent) => any;
+    onMouseEnter?: (e: MouseEvent) => any;
+    onMouseLeave?: (e: MouseEvent) => any;
+    onMouseDown?: (e: MouseEvent) => any;
+    userSelect?: Properties['userSelect'];
+    cursor?: Properties['cursor'];
+};
 export declare type ReactComponentWithRef<Props, Ref> = React.ForwardRefExoticComponent<Props & React.RefAttributes<Ref>>;
 export declare type ConfigListener = (conf: TamaguiInternalConfig) => void;
 export declare type VariableVal = number | string | Variable;
@@ -52,51 +89,121 @@ declare type GenericThemes = {
     });
 };
 declare type GenericShorthands = {};
-declare type GenericMedia<K extends string = string> = {
-    [key in K]: {
+declare type GenericMedia = {
+    [key: string]: {
         [key: string]: number | string;
     };
 };
-declare type GenericFonts = {
-    [key: string]: GenericFont;
-};
+export declare type GenericFonts = Record<string, GenericFont>;
 declare type GenericAnimations = {
     [key: string]: string | {
         [key: string]: any;
-    };
+    } | any[];
 };
 export interface TamaguiCustomConfig {
 }
 export interface TamaguiConfig extends Omit<GenericTamaguiConfig, keyof TamaguiCustomConfig>, TamaguiCustomConfig {
 }
-export declare type CreateTamaguiConfig<A extends GenericTokens, B extends GenericThemes, C extends GenericShorthands = GenericShorthands, D extends GenericMedia = GenericMedia, E extends GenericAnimations = GenericAnimations, F extends GenericFonts = GenericFonts> = Partial<Pick<ThemeProviderProps, 'defaultTheme' | 'disableRootThemeClass'>> & {
-    fonts: F;
+export declare type CreateTamaguiConfig<A extends GenericTokens, B extends GenericThemes, C extends GenericShorthands = GenericShorthands, D extends GenericMedia = GenericMedia, E extends GenericAnimations = GenericAnimations, F extends GenericFonts = GenericFonts> = {
+    fonts: RemoveLanguagePostfixes<F>;
+    fontLanguages: GetLanguagePostfixes<F> extends never ? string[] : GetLanguagePostfixes<F>[];
     tokens: A;
-    themes: B;
+    themes: {
+        [Name in keyof B]: {
+            [Key in keyof B[Name]]: Variable;
+        };
+    };
     shorthands: C;
     media: D;
     animations: AnimationDriver<E>;
 };
+declare type GetLanguagePostfix<Set> = Set extends string ? Set extends `${string}_${infer Postfix}` ? Postfix : never : never;
+declare type OmitLanguagePostfix<Set> = Set extends string ? Set extends `${infer Prefix}_${string}` ? Prefix : Set : never;
+declare type RemoveLanguagePostfixes<F extends GenericFonts> = {
+    [Key in OmitLanguagePostfix<keyof F>]: F[Key];
+};
+declare type GetLanguagePostfixes<F extends GenericFonts> = GetLanguagePostfix<keyof F>;
+declare type ConfProps<A extends GenericTokens, B extends GenericThemes, C extends GenericShorthands = GenericShorthands, D extends GenericMedia = GenericMedia, E extends GenericAnimations = GenericAnimations, F extends GenericFonts = GenericFonts> = {
+    tokens: A;
+    themes: B;
+    shorthands?: C;
+    media?: D;
+    animations?: AnimationDriver<E>;
+    fonts: F;
+};
+export declare type InferTamaguiConfig<Conf> = Conf extends ConfProps<infer A, infer B, infer C, infer D, infer E, infer F> ? TamaguiInternalConfig<A, B, C, D, E, F> : unknown;
 export declare type GenericTamaguiConfig = CreateTamaguiConfig<GenericTokens, GenericThemes, GenericShorthands, GenericMedia, GenericAnimations, GenericFonts>;
-export declare type ThemeObject = TamaguiConfig['themes'][keyof TamaguiConfig['themes']];
+export declare type ThemeDefinition = TamaguiConfig['themes'][keyof TamaguiConfig['themes']];
+export declare type ThemeKeys = keyof ThemeDefinition;
+export declare type ThemeParsed = {
+    [key in ThemeKeys]: Variable<any>;
+};
 export declare type Tokens = TamaguiConfig['tokens'];
 export declare type Shorthands = TamaguiConfig['shorthands'];
 export declare type Media = TamaguiConfig['media'];
 export declare type Themes = TamaguiConfig['themes'];
 export declare type ThemeName = GetAltThemeNames<keyof Themes>;
-export declare type ThemeKeys = keyof ThemeObject;
 export declare type ThemeTokens = `$${ThemeKeys}`;
-export declare type AnimationKeys = Omit<GetAnimationKeys<TamaguiConfig>, number>;
+export declare type AnimationKeys = TamaguiConfig['animations'] extends AnimationDriver<infer Config> ? keyof Config : string;
+export declare type FontLanguages = ArrayIntersection<TamaguiConfig['fontLanguages']>;
+declare type ArrayIntersection<A extends any[]> = A[keyof A];
 declare type GetAltThemeNames<S> = (S extends `${string}_${infer Alt}` ? GetAltThemeNames<Alt> : S) | S;
-export declare type TamaguiInternalConfig<A extends GenericTokens = GenericTokens, B extends GenericThemes = GenericThemes, C extends GenericShorthands = GenericShorthands, D extends GenericMedia = GenericMedia, E extends GenericAnimations = GenericAnimations, F extends GenericFonts = GenericFonts> = CreateTamaguiConfig<A, B, C, D, E, F> & {
-    Provider: (props: TamaguiProviderProps) => any;
+export declare type SpacerProps = Omit<StackProps, 'flex' | 'direction' | 'size'> & {
+    size?: number | SpaceTokens | null;
+    flex?: boolean | number;
+    direction?: SpaceDirection;
+};
+export declare type CreateTamaguiProps = {
+    shorthands?: GenericTamaguiConfig['shorthands'];
+    media?: GenericTamaguiConfig['media'];
+    animations?: AnimationDriver<any>;
+    fonts: GenericTamaguiConfig['fonts'];
+    tokens: GenericTamaguiConfig['tokens'];
+    themes: {
+        [key: string]: {
+            [key: string]: string | number | Variable;
+        };
+    };
+    defaultTheme?: string;
+    /**
+     * *Advanced use case* For all CSS extracted views, this has no effect.
+     *
+     * For SSR compatibility on the web, Tamagui will render once with the settings
+     * from `mediaQueryDefaultActive` set for all media queries. Then, it will render
+     * again after the initial render using the proper media query values. This is so that
+     * hydration will match perfectly with the server.
+     *
+     * Setting disableSSR will avoid this second render by setting the media query state
+     * to the actual browser dimensions on initial load. This is only useful for client-only
+     * apps.
+     *
+     */
+    disableSSR?: boolean;
+    /**
+     * Disable inserting a theme class in the DOM or context, allowing you to manually place it higher.
+     * For custom use cases like integration with next-theme.
+     */
+    disableRootThemeClass?: boolean;
+    defaultProps?: Record<string, any> & {
+        Stack?: StackProps;
+        Text?: TextProps;
+        Spacer?: SpacerProps;
+    };
+    mediaQueryDefaultActive?: Record<MediaQueryKey, boolean>;
+    cssStyleSeparator?: string;
+    maxDarkLightNesting?: number;
+    shouldAddPrefersColorThemes?: boolean;
+    themeClassNameOnRoot?: boolean;
+};
+export declare type TamaguiInternalConfig<A extends GenericTokens = GenericTokens, B extends GenericThemes = GenericThemes, C extends GenericShorthands = GenericShorthands, D extends GenericMedia = GenericMedia, E extends GenericAnimations = GenericAnimations, F extends GenericFonts = GenericFonts> = Omit<CreateTamaguiProps, keyof GenericTamaguiConfig> & CreateTamaguiConfig<A, B, C, D, E, F> & {
     tokensParsed: CreateTokens<Variable>;
     themeConfig: any;
     fontsParsed: GenericFonts;
     getCSS: () => string;
     parsed: boolean;
+    inverseShorthands: Record<string, string>;
 };
-export declare type GetAnimationKeys<A extends GenericTamaguiConfig> = keyof A['animations']['animations'];
+export declare type GetAnimationKeys<A extends GenericTamaguiConfig> = keyof A['animations'];
 export declare type UnionableString = string & {};
 export declare type UnionableNumber = number & {};
 export declare type PropTypes<A extends TamaguiComponent> = A extends React.FunctionComponent<infer Props> ? Props : unknown;
@@ -123,8 +230,13 @@ export declare type GenericFont<Key extends number | string = number | string> =
     color?: Partial<{
         [key in Key]: string | Variable;
     }>;
+    face?: {
+        [key in FontWeightSteps]: {
+            normal?: string;
+            italic?: string;
+        };
+    };
 };
-export declare type MediaKeys = keyof Media;
 export declare type MediaQueryObject = {
     [key: string]: string | number | string;
 };
@@ -139,10 +251,6 @@ export declare type MediaProps<A> = {
 export declare type MediaQueries = {
     [key in MediaQueryKey]: MediaQueryObject;
 };
-export declare type ConfigureMediaQueryOptions = {
-    queries?: MediaQueries;
-    defaultActive?: MediaQueryKey[];
-};
 export declare type TransformStyleProps = {
     x?: number;
     y?: number;
@@ -173,41 +281,18 @@ export declare type AnimationProp = AnimationKeys | {
         };
     }
 ];
-export declare type TamaguiComponentPropsBase = {
-    asChild?: boolean;
-    space?: SpaceTokens;
-    dangerouslySetInnerHTML?: {
-        __html: string;
-    };
-    animation?: AnimationProp;
-    animateOnly?: string[];
-    children?: any | any[];
-    debug?: boolean | 'break' | 'verbose';
-    disabled?: boolean;
-    className?: string;
-    id?: string;
-    tag?: string;
-    theme?: ThemeName | null;
-    onHoverIn?: (e: MouseEvent) => any;
-    onHoverOut?: (e: MouseEvent) => any;
-    onPress?: (e: GestureResponderEvent) => any;
-    onPressIn?: (e: GestureResponderEvent) => any;
-    onPressOut?: (e: GestureResponderEvent) => any;
-    onMouseEnter?: (e: MouseEvent) => any;
-    onMouseLeave?: (e: MouseEvent) => any;
-    onMouseDown?: (e: MouseEvent) => any;
-};
-declare type GetTokenFontKeysFor<A extends 'size' | 'weight' | 'letterSpacing' | 'family' | 'lineHeight' | 'transform' | 'style' | 'color'> = keyof TamaguiConfig['fonts'][keyof TamaguiConfig['fonts']][A];
+declare type GetTokenFontKeysFor<A extends 'size' | 'weight' | 'letterSpacing' | 'family' | 'lineHeight' | 'transform' | 'style' | 'color'> = keyof TamaguiConfig['fonts']['body'][A];
 declare type GetTokenString<A> = A extends string | number ? `$${A}` : `$${string}`;
 export declare type SizeTokens = GetTokenString<keyof Tokens['size']> | number;
 export declare type SpaceTokens = GetTokenString<keyof Tokens['space']> | number | boolean;
-export declare type ColorTokens = GetTokenString<keyof Tokens['color']> | GetTokenString<keyof ThemeObject> | CSSColorNames;
+export declare type ColorTokens = GetTokenString<keyof Tokens['color']> | GetTokenString<keyof ThemeParsed> | CSSColorNames;
 export declare type ZIndexTokens = GetTokenString<keyof Tokens['zIndex']> | number;
 export declare type RadiusTokens = GetTokenString<keyof Tokens['radius']> | number;
 export declare type FontTokens = GetTokenString<keyof TamaguiConfig['fonts']>;
 export declare type FontSizeTokens = GetTokenString<GetTokenFontKeysFor<'size'>> | number;
 export declare type FontLineHeightTokens = `$${GetTokenFontKeysFor<'lineHeight'>}` | number;
-export declare type FontWeightTokens = `$${GetTokenFontKeysFor<'weight'>}` | `${1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9}00`;
+export declare type FontWeightSteps = `${1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9}00`;
+export declare type FontWeightTokens = `$${GetTokenFontKeysFor<'weight'>}` | FontWeightSteps;
 export declare type FontColorTokens = `$${GetTokenFontKeysFor<'color'>}` | number;
 export declare type FontLetterSpacingTokens = `$${GetTokenFontKeysFor<'letterSpacing'>}` | number;
 export declare type FontStyleTokens = `$${GetTokenFontKeysFor<'style'>}` | TextStyle['fontStyle'];
@@ -237,7 +322,7 @@ export declare type PseudoProps<A> = {
     exitStyle?: A | null;
     enterStyle?: A | null;
 };
-export declare type PsuedoPropKeys = keyof PseudoProps<any>;
+export declare type PseudoPropKeys = keyof PseudoProps<any>;
 export declare type PseudoStyles = {
     hoverStyle?: ViewStyle;
     pressStyle?: ViewStyle;
@@ -259,15 +344,14 @@ export declare type StackPropsBaseShared = Omit<ViewProps, 'display' | 'children
 export declare type StackStyleProps = WithThemeShorthandsPseudosMediaAnimation<StackStylePropsBase>;
 export declare type StackPropsBase = StackPropsBaseShared & WithThemeAndShorthands<StackStylePropsBase>;
 export declare type StackProps = StackPropsBaseShared & StackStyleProps;
+export declare type GestureReponderEvent = Exclude<View['props']['onResponderMove'], void> extends (event: infer Event) => void ? Event : never;
 export declare type TextStylePropsBase = Omit<TextStyle, 'display' | 'backfaceVisibility'> & TransformStyleProps & WebOnlyStyleProps & {
     ellipse?: boolean;
     selectable?: boolean;
     textDecorationDistance?: number;
-    userSelect?: CSS.Properties['userSelect'];
-    textOverflow?: CSS.Properties['textOverflow'];
-    whiteSpace?: CSS.Properties['whiteSpace'];
-    wordWrap?: CSS.Properties['wordWrap'];
-    cursor?: CSS.Properties['cursor'];
+    textOverflow?: Properties['textOverflow'];
+    whiteSpace?: Properties['whiteSpace'];
+    wordWrap?: Properties['wordWrap'];
 };
 export declare type TextPropsBaseShared = Omit<ReactTextProps, 'children'> & RNWTextProps & TamaguiComponentPropsBase;
 export declare type TextPropsBase = TextPropsBaseShared & WithThemeAndShorthands<TextStylePropsBase>;
@@ -280,67 +364,148 @@ declare type StaticComponentObject = {
     extractable: <X>(a: X, opts?: Partial<StaticConfig>) => X;
 };
 export declare type TamaguiProviderProps = Partial<Omit<ThemeProviderProps, 'children'>> & {
-    injectCSS?: boolean;
+    config: TamaguiInternalConfig;
+    disableInjectCSS?: boolean;
     children?: React.ReactNode;
 };
+export declare type PropMapper = (key: string, value: any, theme: ThemeParsed, props: Record<string, any>, state: Partial<SplitStyleState>, languageContext?: FontLanguageProps, avoidDefaultProps?: boolean, debug?: DebugProp) => undefined | [string, any][];
 export declare type StaticConfigParsed = StaticConfig & {
     parsed: true;
-    propMapper: (key: string, value: any, theme: ThemeObject, props: any, resolveVariablesAs?: ResolveVariableTypes, avoidDefaultProps?: boolean) => undefined | boolean | {
-        [key: string]: any;
-    };
+    propMapper: PropMapper;
     variantsParsed?: {
         [key: string]: {
             [key: string]: any;
         };
     };
 };
-export declare type StaticConfig = {
-    Component?: React.FunctionComponent<any> & StaticComponentObject;
-    variants?: {
-        [key: string]: {
-            [key: string]: ((a: any, b: any) => any) | {
-                [key: string]: any;
-            };
+export declare type GenericVariantDefinitions = {
+    [key: string]: {
+        [key: string]: ((a: any, b: any) => any) | {
+            [key: string]: any;
         };
     };
+};
+export declare type StaticConfig = {
+    Component?: React.FunctionComponent<any> & StaticComponentObject;
+    variants?: GenericVariantDefinitions;
+    /**
+     * Used for applying sub theme style
+     */
     componentName?: string;
+    /**
+     * (compiler) If you need to pass context or something, prevents from ever
+     * flattening. The 'jsx' option means it will never flatten. if you
+     * pass JSX as a children (if its purely string, it will still flatten).
+     */
     neverFlatten?: boolean | 'jsx';
+    /**
+     * Determines ultimate output tag (Text vs View)
+     */
     isText?: boolean;
+    /**
+     * Attempts to attach focus styles at runtime (useful for native)
+     */
     isInput?: boolean;
+    /**
+     * React native web images need special handling for className support
+     */
     isImage?: boolean;
+    /**
+     * Which style keys are allowed to be extracted.
+     */
     validStyles?: {
         [key: string]: boolean;
     };
-    defaultProps?: any;
+    /**
+     * Same as React.defaultProps, be sure to sync
+     */
+    defaultProps: Record<string, any>;
+    /**
+     * (compiler) If these props are encountered, bail on all optimization.
+     */
     deoptProps?: Set<string>;
+    /**
+     * (compiler) If these props are encountered, leave them un-extracted.
+     */
     inlineProps?: Set<string>;
+    /**
+     * (compiler) If not flattening, leave this prop as original value.
+     * Only applies to style attributes
+     */
+    inlineWhenUnflattened?: Set<string>;
+    /**
+     * (compiler) A bit odd, only for more advanced heirarchies.
+     * Indicates that the component will set this prop so the
+     * static extraction can ensure it sets them to ={undefined}
+     * so they get overriddent. In the future, this can be smarter.
+     */
     ensureOverriddenProp?: {
         [key: string]: boolean;
     };
+    /**
+     * Auto-detected, but can ovverride. Wraps children to space them on top
+     */
     isZStack?: boolean;
+    /**
+     * Merges into defaultProps later on, used internally yonly
+     */
     defaultVariants?: {
         [key: string]: any;
     };
+    /**
+     * Auto-detect, but can ovverride, passes styles properly to react-native-web
+     */
     isReactNativeWeb?: boolean;
+    /**
+     * Used internally to keep reference to the original rnw component
+     */
     reactNativeWebComponent?: any;
+    /**
+     * Memoize the component
+     */
     memo?: boolean;
+    /**
+     * Auto-detect, but can ovverride, passes styles properly to react-native-web
+     */
     isTamagui?: boolean;
-};
-export declare type StylableComponent = TamaguiComponent | React.Component | React.ForwardRefExoticComponent<any> | (new (props: any) => any) | typeof View | typeof Text | typeof TextInput | typeof Image;
+    /**
+     * Used internally to handle extractable HoC separate
+     */
+    isHOC?: boolean;
+    /**
+     * Used insternally to attach default props to names
+     */
+    parentNames?: string[];
+    /**
+     * By default if styled() doesn't recognize a parent Tamagui compoent or specific react-native views,
+     * it will assume the passed in component only accepts style={} for react-native compatibility.
+     * Setting `acceptsClassName: true` indicates Tamagui can pass in className props.
+     */
+    acceptsClassName?: boolean;
+};
+/**
+ * --------------------------------------------
+ *   variants
+ * --------------------------------------------
+ */
+export declare type StylableComponent = TamaguiComponent | React.Component | React.ForwardRefExoticComponent<any> | ReactComponentWithRef<any, any> | (new (props: any) => any) | typeof View | typeof Text | typeof TextInput | typeof Image;
+export declare type GetStyledVariants<A extends TamaguiComponent> = A extends TamaguiComponent<any, any, any, infer Variants> ? Variants : never;
 export declare type GetBaseProps<A extends StylableComponent> = A extends TamaguiComponent<any, any, infer BaseProps> ? BaseProps : never;
-export declare type GetProps<A extends StylableComponent> = A extends TamaguiComponent<infer Props> ? Props : A extends React.Component<infer Props> ? GetGenericComponentTamaguiProps<Props> : A extends new (props: infer Props) => any ? GetGenericComponentTamaguiProps<Props> : {};
+export declare type GetProps<A extends StylableComponent> = A extends TamaguiComponent<infer Props> ? Props : A extends TamaguiReactElement<infer Props> ? Props : A extends React.Component<infer Props> ? GetGenericComponentTamaguiProps<Props> : A extends new (props: infer Props) => any ? GetGenericComponentTamaguiProps<Props> : {};
 declare type GetGenericComponentTamaguiProps<P> = P & Omit<'textAlign' extends keyof P ? TextProps : StackProps, keyof P>;
-export declare type SpreadKeys = '...fontSize' | '...fontStyle' | '...fontTransform' | '...lineHeight' | '...letterSpacing' | '...size' | '...color' | '...zIndex' | '...theme' | '...radius';
+export declare type SpreadKeys = '...fontSize' | '...fontStyle' | '...fontTransform' | '...lineHeight' | '...letterSpacing' | '...size' | '...space' | '...color' | '...zIndex' | '...theme' | '...radius';
 export declare type VariantDefinitions<Parent extends StylableComponent = TamaguiComponent, MyProps extends Object = GetProps<Parent>, Val = any> = VariantDefinitionFromProps<MyProps, Val>;
 export declare type VariantDefinitionFromProps<MyProps, Val> = MyProps extends Object ? {
     [propName: string]: VariantSpreadFunction<MyProps, Val> | ({
-        [Key in SpreadKeys]?: Key extends '...fontSize' ? FontSizeVariantSpreadFunction<MyProps> : Key extends '...size' ? SizeVariantSpreadFunction<MyProps> : Key extends '...color' ? ColorVariantSpreadFunction<MyProps> : Key extends '...lineHeight' ? FontLineHeightVariantSpreadFunction<MyProps> : Key extends '...fontTransform' ? FontTransformVariantSpreadFunction<MyProps> : Key extends '...fontStyle' ? FontStyleVariantSpreadFunction<MyProps> : Key extends '...letterSpacing' ? FontLetterSpacingVariantSpreadFunction<MyProps> : Key extends '...zIndex' ? ZIndexVariantSpreadFunction<MyProps> : Key extends '...radius' ? RadiusVariantSpreadFunction<MyProps> : Key extends '...theme' ? ThemeVariantSpreadFunction<MyProps> : never;
+        [Key in SpreadKeys]?: Key extends '...fontSize' ? FontSizeVariantSpreadFunction<MyProps> : Key extends '...size' ? SizeVariantSpreadFunction<MyProps> : Key extends '...space' ? SpaceVariantSpreadFunction<MyProps> : Key extends '...color' ? ColorVariantSpreadFunction<MyProps> : Key extends '...lineHeight' ? FontLineHeightVariantSpreadFunction<MyProps> : Key extends '...fontTransform' ? FontTransformVariantSpreadFunction<MyProps> : Key extends '...fontStyle' ? FontStyleVariantSpreadFunction<MyProps> : Key extends '...letterSpacing' ? FontLetterSpacingVariantSpreadFunction<MyProps> : Key extends '...zIndex' ? ZIndexVariantSpreadFunction<MyProps> : Key extends '...radius' ? RadiusVariantSpreadFunction<MyProps> : Key extends '...theme' ? ThemeVariantSpreadFunction<MyProps> : never;
     } & {
-        [Key in string | number]?: MyProps | VariantSpreadFunction<MyProps, Val>;
+        [Key in string | number | 'true' | 'false']?: MyProps | VariantSpreadFunction<MyProps, Val>;
     } & {
         [Key in VariantTypeKeys]?: Key extends ':number' ? VariantSpreadFunction<MyProps, number> : Key extends ':boolean' ? VariantSpreadFunction<MyProps, boolean> : Key extends ':string' ? VariantSpreadFunction<MyProps, string> : never;
     });
 } : never;
+export declare type GenericStackVariants = VariantDefinitionFromProps<StackProps, any>;
+export declare type GenericTextVariants = VariantDefinitionFromProps<StackProps, any>;
 export declare type GetVariantProps<Variants> = {
     [Key in keyof Variants]?: Variants[Key] extends VariantSpreadFunction<any, infer Val> ? Val : GetVariantValues<keyof Variants[Key]>;
 };
@@ -362,6 +527,7 @@ export declare type VariantTypeKeys = ':string' | ':boolean' | ':number';
 export declare type GetVariantValues<Key> = Key extends `...${infer VariantSpread}` ? ThemeValueByCategory<VariantSpread> : Key extends 'true' | 'false' ? boolean : Key extends ':string' ? string : Key extends ':boolean' ? boolean : Key extends ':number' ? number : Key;
 export declare type FontSizeVariantSpreadFunction<A extends PropLike> = VariantSpreadFunction<A, FontSizeTokens>;
 export declare type SizeVariantSpreadFunction<A extends PropLike> = VariantSpreadFunction<A, SizeTokens>;
+export declare type SpaceVariantSpreadFunction<A extends PropLike> = VariantSpreadFunction<A, SpaceTokens>;
 export declare type ColorVariantSpreadFunction<A extends PropLike> = VariantSpreadFunction<A, ColorTokens>;
 export declare type FontLineHeightVariantSpreadFunction<A extends PropLike> = VariantSpreadFunction<A, FontLineHeightTokens>;
 export declare type FontLetterSpacingVariantSpreadFunction<A extends PropLike> = VariantSpreadFunction<A, FontLetterSpacingTokens>;
@@ -370,6 +536,11 @@ export declare type FontTransformVariantSpreadFunction<A extends PropLike> = Var
 export declare type ZIndexVariantSpreadFunction<A extends PropLike> = VariantSpreadFunction<A, ZIndexTokens>;
 export declare type RadiusVariantSpreadFunction<A extends PropLike> = VariantSpreadFunction<A, RadiusTokens>;
 export declare type ThemeVariantSpreadFunction<A extends PropLike> = VariantSpreadFunction<A, ThemeTokens>;
+/**
+ * --------------------------------------------
+ *   end variants
+ * --------------------------------------------
+ */
 declare type SizeKeys = 'width' | 'height' | 'minWidth' | 'minHeight' | 'maxWidth' | 'maxHeight' | 'shadowRadius';
 declare type ColorKeys = 'color' | 'backgroundColor' | 'borderColor' | 'borderBottomColor' | 'borderTopColor' | 'borderLeftColor' | 'borderRightColor' | 'shadowColor' | 'textShadowColor';
 declare type SpaceKeys = 'space' | 'padding' | 'paddingHorizontal' | 'paddingVertical' | 'paddingLeft' | 'paddingTop' | 'paddingBottom' | 'paddingLeft' | 'paddingRight' | 'paddingEnd' | 'paddingStart' | 'margin' | 'marginHorizontal' | 'marginVertical' | 'marginLeft' | 'marginTop' | 'marginBottom' | 'marginLeft' | 'marginRight' | 'marginEnd' | 'marginStart' | 'x' | 'y' | 'scale' | 'scaleX' | 'scaleY' | 'borderTopEndRadius' | 'borderTopLeftRadius' | 'borderTopRightRadius' | 'borderTopStartRadius' | 'borderBottomEndRadius' | 'borderBottomLeftRadius' | 'borderBottomRightRadius' | 'borderBottomStartRadius' | 'borderBottomWidth' | 'borderLeftWidth' | 'borderRadius' | 'borderRightWidth' | 'borderTopEndRadius' | 'borderTopLeftRadius' | 'borderTopRightRadius' | 'borderEndWidth' | 'borderStartWidth' | 'borderTopStartRadius' | 'borderTopWidth' | 'borderWidth' | 'left' | 'top' | 'right' | 'bottom' | 'shadowOffset';
@@ -380,6 +551,8 @@ export declare type TamaguiComponentState = {
     pressIn: boolean;
     focus: boolean;
     mounted: boolean;
+    mediaState?: null | Record<string, boolean>;
+    hasAnimation?: boolean;
     animation?: null | {
         style?: any;
         avoidClasses?: boolean;
@@ -387,24 +560,52 @@ export declare type TamaguiComponentState = {
 };
 export declare type SplitStyleState = TamaguiComponentState & {
     noClassNames?: boolean;
+    dynamicStylesInline?: boolean;
     resolveVariablesAs?: ResolveVariableTypes;
-    fallbackProps?: Object;
+    fallbackProps?: Record<string, any>;
+    keepVariantsAsProps?: boolean;
+    hasTextAncestor?: boolean;
 };
 declare type AnimationConfig = {
     [key: string]: any;
 };
+export declare type AnimatedNumberStrategy = {
+    type: 'spring';
+    stiffness?: number;
+    damping?: number;
+    mass?: number;
+    overshootClamping?: boolean;
+    restSpeedThreshold?: number;
+    restDisplacementThreshold?: number;
+} | {
+    type: 'timing';
+    duration: number;
+} | {
+    type: 'direct';
+};
+export declare type UniversalAnimatedNumber<A> = {
+    getInstance(): A;
+    getValue(): number;
+    setValue(next: number, config?: AnimatedNumberStrategy): void;
+    stop(): void;
+};
 export declare type AnimationDriver<A extends AnimationConfig = AnimationConfig> = {
     avoidClasses?: boolean;
     useAnimations: UseAnimationHook;
+    useAnimatedNumber: (initial: number) => UniversalAnimatedNumber<any>;
+    useAnimatedNumberStyle: <V extends UniversalAnimatedNumber<any>>(val: V, getStyle: (current: any) => any) => void;
+    useAnimatedNumberReaction: (val: UniversalAnimatedNumber<any>, onValue: (current: number) => void) => void;
     animations: A;
     View?: any;
     Text?: any;
 };
 export declare type UseAnimationProps = TamaguiComponentPropsBase & Record<string, any>;
 export declare type UseAnimationHelpers = {
+    hostRef: RefObject<HTMLElement | View>;
     staticConfig: StaticConfigParsed;
     getStyle: (props?: {
         isEntering?: boolean;
+        isExiting?: boolean;
         exitVariant?: string | null;
         enterVariant?: string | null;
     }) => ViewStyle;
@@ -413,9 +614,8 @@ export declare type UseAnimationHelpers = {
     onDidAnimate?: any;
     delay?: number;
 };
-export declare type UseAnimationHook = (props: UseAnimationProps, helpers: UseAnimationHelpers) => {
+export declare type UseAnimationHook = (props: UseAnimationProps, helpers: UseAnimationHelpers) => null | {
     style?: StackStylePropsBase | StackStylePropsBase[];
-    safeToUnmount?: () => void;
 };
 export {};
 //# sourceMappingURL=types.d.ts.map

package/types/updateTheme.d.ts

@@ -0,0 +1,9 @@
+import { ThemeDefinition } from './types';
+export declare function updateTheme({ name, theme }: {
+    name: string;
+    theme: ThemeDefinition;
+}): {
+    theme: any;
+    cssRules: string[];
+};
+//# sourceMappingURL=updateTheme.d.ts.map

package/types/vendor/Pressability.d.ts

@@ -0,0 +1,3 @@
+export declare const Pressability: any;
+export declare const usePressability: Function;
+//# sourceMappingURL=Pressability.d.ts.map

package/types/vendor/Pressability.native.d.ts

@@ -0,0 +1,3 @@
+export declare const Pressability: any;
+export declare const usePressability: any;
+//# sourceMappingURL=Pressability.native.d.ts.map

package/types/views/FontLanguage.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { FontLanguageProps } from './FontLanguage.types';
+export declare const FontLanguage: ({ children, ...props }: FontLanguageProps) => JSX.Element;
+//# sourceMappingURL=FontLanguage.d.ts.map

package/types/views/FontLanguage.native.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { FontLanguageProps } from './FontLanguage.types';
+export declare const FontLanguage: ({ children, ...props }: FontLanguageProps) => JSX.Element;
+//# sourceMappingURL=FontLanguage.native.d.ts.map

package/types/views/FontLanguage.types.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { FontLanguages, FontTokens } from '../types';
+declare type FontFamilies = FontTokens extends `$${infer Token}` ? Token : never;
+export declare type LanguageContextType = Partial<{
+    [key in FontFamilies]: FontLanguages | 'default';
+}>;
+export declare type FontLanguageProps = LanguageContextType & {
+    children?: React.ReactNode;
+};
+export {};
+//# sourceMappingURL=FontLanguage.types.d.ts.map

package/types/views/Slot.d.ts

@@ -6,4 +6,5 @@ export declare const Slot: React.ForwardRefExoticComponent<SlotProps & React.Ref
 export declare const Slottable: ({ children }: {
     children: React.ReactNode;
 }) => JSX.Element;
+export declare function mergeEvent(a?: Function, b?: Function): (...args: unknown[]) => void;
 //# sourceMappingURL=Slot.d.ts.map

package/types/views/TamaguiProvider.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import type { TamaguiProviderProps } from '../types';
+export declare function TamaguiProvider({ children, disableInjectCSS, config, ...themePropsProvider }: TamaguiProviderProps): JSX.Element;
+//# sourceMappingURL=TamaguiProvider.d.ts.map

package/types/views/Theme.d.ts

@@ -1,12 +1,6 @@
 import React from 'react';
-import { ThemeName } from '../types';
-export declare type ThemeProps = {
-    className?: string;
-    disableThemeClass?: boolean;
-    name: Exclude<ThemeName, number> | null;
-    componentName?: string;
-    children?: any;
-    debug?: boolean;
-};
+import { ThemeManager } from '../helpers/ThemeManager';
+import { ThemeProps } from '../hooks/useTheme';
 export declare const Theme: React.NamedExoticComponent<ThemeProps>;
+export declare function wrapThemeManagerContext(children: any, themeManager?: ThemeManager | null, shouldSetChildrenThemeToParent?: boolean): any;
 //# sourceMappingURL=Theme.d.ts.map

package/types/views/ThemeInverse.d.ts

@@ -1,10 +1,6 @@
-/// <reference types="react" />
-declare type StringRecord = {
-    [key: string]: string;
-};
-export declare function setThemeInversions(next: StringRecord): void;
-export declare const ThemeInverse: (props: {
-    children: any;
+import React from 'react';
+export declare const ThemeInverse: ({ children, disable, }: {
+    children: React.ReactNode;
+    disable?: boolean | undefined;
 }) => JSX.Element;
-export {};
 //# sourceMappingURL=ThemeInverse.d.ts.map

package/types/views/ThemeProvider.d.ts

@@ -1,10 +1,11 @@
 /// <reference types="react" />
 export declare type ThemeProviderProps = {
     className?: string;
-    themes: any;
     defaultTheme: string;
     disableRootThemeClass?: boolean;
+    themeClassNameOnRoot?: boolean;
     children?: any;
+    reset?: boolean;
 };
 export declare const ThemeProvider: (props: ThemeProviderProps) => JSX.Element;
 //# sourceMappingURL=ThemeProvider.d.ts.map