@tamagui/core 1.0.1-beta.99 → 1.0.1-rc.0

package/types/types.d.ts

@@ -1,18 +1,22 @@
-import { Properties } from 'csstype';
-import React from 'react';
-import { GestureResponderEvent, Image, TextProps as ReactTextProps, Text, TextInput, TextStyle, View, ViewProps, ViewStyle } from 'react-native';
-import { Variable } from './createVariable';
-import { ResolveVariableTypes } from './helpers/createPropMapper';
-import { RNWTextProps, RNWViewProps } from './types-rnw';
-import { ThemeProviderProps } from './views/ThemeProvider';
+import type { Image, PressableProps, TextProps as ReactTextProps, Text, TextInput, TextStyle, View, ViewProps, ViewStyle } from '@tamagui/types-react-native';
+import type { Properties } from 'csstype';
+import type { ComponentType, ForwardRefExoticComponent, FunctionComponent, HTMLAttributes, ReactNode, RefAttributes, RefObject } from 'react';
+import type { Variable } from './createVariable';
+import type { ResolveVariableTypes } from './helpers/createPropMapper';
+import type { TamaguiReactElement } from './static';
+import type { RNWTextProps, RNWViewProps } from './types-rnw';
+import type { FontLanguageProps } from './views/FontLanguage.types';
+import type { ThemeProviderProps } from './views/ThemeProvider';
 export declare type SpaceDirection = 'vertical' | 'horizontal' | 'both';
 export declare type TamaguiElement = HTMLElement | View;
 export declare type DebugProp = boolean | 'break' | 'verbose';
+declare type DivAttributes = HTMLAttributes<HTMLDivElement>;
 export declare type TamaguiComponentPropsBase = {
+    hitSlop?: PressableProps['hitSlop'];
     asChild?: boolean;
     space?: SpaceTokens | null;
     spaceDirection?: SpaceDirection;
-    separator?: React.ReactNode;
+    separator?: ReactNode;
     dangerouslySetInnerHTML?: {
         __html: string;
     };
@@ -22,23 +26,25 @@ export declare type TamaguiComponentPropsBase = {
     debug?: DebugProp;
     disabled?: boolean;
     className?: string;
+    themeShallow?: boolean;
     id?: string;
     tag?: string;
     theme?: ThemeName | null;
     componentName?: string;
+    /**
+     * Forces the pseudo style state to be on
+     */
     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>>;
+    onHoverIn?: DivAttributes['onMouseEnter'];
+    onHoverOut?: DivAttributes['onMouseLeave'];
+    onPress?: PressableProps['onPress'];
+    onPressIn?: PressableProps['onPress'];
+    onPressOut?: PressableProps['onPress'];
+    onMouseEnter?: DivAttributes['onMouseEnter'];
+    onMouseLeave?: DivAttributes['onMouseLeave'];
+    onMouseDown?: DivAttributes['onMouseDown'];
+};
+export declare type ReactComponentWithRef<Props, Ref> = ForwardRefExoticComponent<Props & RefAttributes<Ref>>;
 export declare type ConfigListener = (conf: TamaguiInternalConfig) => void;
 export declare type VariableVal = number | string | Variable;
 export declare type VariableColorVal = string | Variable;
@@ -84,57 +90,142 @@ declare type GenericThemes = {
         [key: string]: VariableVal;
     });
 };
-declare type GenericShorthands = {};
-declare type GenericMedia<K extends string = string> = {
-    [key in K]: {
+declare type AllStyleKeys = keyof StackStylePropsBase | keyof TextStylePropsBase;
+export declare type CreateShorthands = {
+    [key: string]: AllStyleKeys;
+};
+export declare type GenericShorthands = {};
+declare type GenericMedia = {
+    [key: string]: {
         [key: string]: number | string;
     };
 };
-export 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>;
-    defaultProps?: Record<string, Object>;
 };
+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 ThemeName = Exclude<GetAltThemeNames<keyof Themes>, number>;
 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']>;
+export interface ThemeProps {
+    className?: string;
+    disableThemeClass?: boolean;
+    name?: Exclude<ThemeName, number> | null;
+    componentName?: string;
+    children?: any;
+    reset?: boolean;
+    debug?: boolean | 'verbose';
+    inverse?: boolean;
+}
+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;
+declare type SpacerPropsBase = {
+    size?: number | SpaceTokens | null;
+    flex?: boolean | number;
+    direction?: SpaceDirection;
+};
+declare type SpacerOwnProps = SpacerPropsBase & WithThemeShorthandsPseudosMediaAnimation<SpacerPropsBase>;
+export declare type SpacerProps = Omit<StackProps, 'flex' | 'direction' | 'size'> & SpacerOwnProps;
+export declare type CreateTamaguiProps = {
+    reactNative?: any;
+    shorthands?: CreateShorthands;
+    media?: GenericTamaguiConfig['media'];
+    animations?: AnimationDriver<any>;
+    fonts: GenericTamaguiConfig['fonts'];
+    tokens: GenericTamaguiConfig['tokens'];
+    themes: {
+        [key: string]: {
+            [key: string]: string | number | Variable;
+        };
+    };
+    /**
+     * *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;
-    themeClassNameOnRoot?: boolean;
+    inverseShorthands: Record<string, string>;
+    reactNative?: any;
 };
-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;
+export declare type PropTypes<A extends TamaguiComponent> = A extends FunctionComponent<infer Props> ? Props : unknown;
 export declare type GenericFont<Key extends number | string = number | string> = {
     size: {
         [key in Key]: number | Variable;
@@ -158,8 +249,13 @@ export declare type GenericFont<Key extends number | string = number | string> =
     color?: Partial<{
         [key in Key]: string | Variable;
     }>;
+    face?: Partial<{
+        [key in FontWeightSteps]: {
+            normal?: string;
+            italic?: string;
+        };
+    }>;
 };
-export declare type MediaKeys = keyof Media;
 export declare type MediaQueryObject = {
     [key: string]: string | number | string;
 };
@@ -174,10 +270,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;
@@ -212,13 +304,14 @@ declare type GetTokenFontKeysFor<A extends 'size' | 'weight' | 'letterSpacing' |
 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'];
@@ -230,7 +323,7 @@ declare type FontWeightKeys = 'fontWeight';
 declare type FontLetterSpacingKeys = 'letterSpacing';
 declare type LineHeightKeys = 'lineHeight';
 declare type ZIndexKeys = 'zIndex';
-export declare type ThemeValueGet<K extends string | number | symbol> = K extends 'theme' ? ThemeTokens : K extends SizeKeys ? SizeTokens : K extends FontKeys ? FontTokens : K extends FontSizeKeys ? FontSizeTokens : K extends SpaceKeys ? K extends 'shadowOffset' ? {
+export declare type ThemeValueGet<K extends string | number | symbol> = K extends 'theme' ? ThemeTokens : K extends SizeKeys ? SizeTokens : K extends FontKeys ? FontTokens : K extends FontSizeKeys ? FontSizeTokens : K extends `${`border${string | ''}Radius`}` ? RadiusTokens : K extends SpaceKeys ? K extends 'shadowOffset' ? {
     width: SpaceTokens;
     height: SpaceTokens;
 } : SpaceTokens : K extends ColorKeys ? ColorTokens : K extends ZIndexKeys ? ZIndexTokens : K extends LineHeightKeys ? FontLineHeightTokens : K extends FontWeightKeys ? FontWeightTokens : K extends FontLetterSpacingKeys ? FontLetterSpacingTokens : never;
@@ -259,19 +352,18 @@ export declare type PseudoStyles = {
 declare type WithThemeAndShorthands<A extends object> = WithThemeValues<A> & WithShorthands<WithThemeValues<A>>;
 declare type WithThemeShorthandsAndPseudos<A extends object> = WithThemeAndShorthands<A> & PseudoProps<WithThemeAndShorthands<A>>;
 declare type WithThemeShorthandsPseudosMediaAnimation<A extends object> = WithThemeShorthandsAndPseudos<A> & MediaProps<WithThemeShorthandsAndPseudos<A>>;
-declare type WebOnlyStyleProps = {
-    cursor?: string;
-    contain?: 'none' | 'strict' | 'content' | 'size' | 'layout' | 'paint' | string;
-    display?: 'inherit' | 'none' | 'inline' | 'block' | 'contents' | 'flex' | 'inline-flex';
+/**
+ * Base style-only props (no media, pseudo):
+ */
+declare type StylePropsWebOnly = {
     pointerEvents?: ViewProps['pointerEvents'];
+    cursor?: Properties['cursor'];
+    contain?: Properties['contain'];
+    display?: 'inherit' | 'none' | 'inline' | 'block' | 'contents' | 'flex' | 'inline-flex';
+    userSelect?: Properties['userSelect'];
 };
-export declare type StackStylePropsBase = Omit<ViewStyle, 'display' | 'backfaceVisibility' | 'elevation'> & TransformStyleProps & WebOnlyStyleProps;
-export declare type StackPropsBaseShared = Omit<ViewProps, 'display' | 'children'> & RNWViewProps & TamaguiComponentPropsBase;
-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 & {
+export declare type StackStylePropsBase = Omit<ViewStyle, 'display' | 'backfaceVisibility' | 'elevation'> & TransformStyleProps & StylePropsWebOnly;
+export declare type TextStylePropsBase = Omit<TextStyle, 'display' | 'backfaceVisibility'> & TransformStyleProps & StylePropsWebOnly & {
     ellipse?: boolean;
     selectable?: boolean;
     textDecorationDistance?: number;
@@ -279,10 +371,14 @@ export declare type TextStylePropsBase = Omit<TextStyle, 'display' | 'backfaceVi
     whiteSpace?: Properties['whiteSpace'];
     wordWrap?: Properties['wordWrap'];
 };
-export declare type TextPropsBaseShared = Omit<ReactTextProps, 'children'> & RNWTextProps & TamaguiComponentPropsBase;
-export declare type TextPropsBase = TextPropsBaseShared & WithThemeAndShorthands<TextStylePropsBase>;
+export declare type StackNonStyleProps = Omit<ViewProps, 'display' | 'children'> & RNWViewProps & TamaguiComponentPropsBase;
+export declare type StackStyleProps = WithThemeShorthandsPseudosMediaAnimation<StackStylePropsBase>;
+export declare type StackPropsBase = StackNonStyleProps & WithThemeAndShorthands<StackStylePropsBase>;
+export declare type StackProps = StackNonStyleProps & StackStyleProps;
+export declare type TextNonStyleProps = Omit<ReactTextProps, 'children'> & RNWTextProps & TamaguiComponentPropsBase;
+export declare type TextPropsBase = TextNonStyleProps & WithThemeAndShorthands<TextStylePropsBase>;
 export declare type TextStyleProps = WithThemeShorthandsPseudosMediaAnimation<TextStylePropsBase>;
-export declare type TextProps = TextPropsBaseShared & TextStyleProps;
+export declare type TextProps = TextNonStyleProps & TextStyleProps;
 export declare type ViewOrTextProps = WithThemeShorthandsPseudosMediaAnimation<Omit<TextStylePropsBase, keyof StackStylePropsBase> & StackStylePropsBase>;
 export declare type TamaguiComponent<Props = any, Ref = any, BaseProps = {}, VariantProps = {}> = ReactComponentWithRef<Props, Ref> & StaticComponentObject;
 declare type StaticComponentObject = {
@@ -290,10 +386,11 @@ declare type StaticComponentObject = {
     extractable: <X>(a: X, opts?: Partial<StaticConfig>) => X;
 };
 export declare type TamaguiProviderProps = Partial<Omit<ThemeProviderProps, 'children'>> & {
+    config: TamaguiInternalConfig;
     disableInjectCSS?: boolean;
-    children?: React.ReactNode;
+    children?: ReactNode;
 };
-export declare type PropMapper = (key: string, value: any, theme: ThemeObject, props: Record<string, any>, state: Partial<SplitStyleState>, avoidDefaultProps?: boolean, debug?: DebugProp) => undefined | [string, any][];
+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: PropMapper;
@@ -310,39 +407,105 @@ export declare type GenericVariantDefinitions = {
         };
     };
 };
-export declare type StaticConfig = {
-    Component?: React.FunctionComponent<any> & StaticComponentObject;
-    variants?: GenericVariantDefinitions;
-    componentName?: string;
+export declare type StaticConfigPublic = {
+    /**
+     * (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;
-    isInput?: boolean;
-    isImage?: boolean;
+    /**
+     * Which style keys are allowed to be extracted.
+     */
     validStyles?: {
         [key: string]: boolean;
     };
-    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;
+    /**
+     * Auto-detect, but can override, passes styles properly to react-native-web
+     */
+    isReactNative?: boolean;
+    /**
+     * 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;
+};
+export declare type StaticConfig = StaticConfigPublic & {
+    Component?: FunctionComponent<any> & StaticComponentObject;
+    variants?: GenericVariantDefinitions;
+    /**
+     * Used for applying sub theme style
+     */
+    componentName?: string;
+    /**
+     * Same as React.defaultProps, be sure to sync
+     */
+    defaultProps: Record<string, any>;
+    /**
+     * Merges into defaultProps later on, used internally yonly
+     */
     defaultVariants?: {
         [key: string]: any;
     };
-    isReactNativeWeb?: boolean;
-    reactNativeWebComponent?: any;
+    /**
+     * Memoize the component
+     */
     memo?: boolean;
-    isTamagui?: boolean;
-    isExtractable?: 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;
+    /**
+     * Used internally for handling focus
+     */
+    isInput?: boolean;
 };
-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;
+/**
+ * --------------------------------------------
+ *   variants
+ * --------------------------------------------
+ */
+export declare type StylableComponent = TamaguiComponent | ComponentType<any> | 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 ComponentType<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' | '...space' | '...color' | '...zIndex' | '...theme' | '...radius';
 export declare type VariantDefinitions<Parent extends StylableComponent = TamaguiComponent, MyProps extends Object = GetProps<Parent>, Val = any> = VariantDefinitionFromProps<MyProps, Val>;
@@ -387,6 +550,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';
@@ -396,7 +564,8 @@ export declare type TamaguiComponentState = {
     press: boolean;
     pressIn: boolean;
     focus: boolean;
-    mounted: boolean;
+    unmounted: boolean;
+    mediaState?: null | Record<string, boolean>;
     animation?: null | {
         style?: any;
         avoidClasses?: boolean;
@@ -409,33 +578,73 @@ export declare type SplitStyleState = TamaguiComponentState & {
     fallbackProps?: Record<string, any>;
     keepVariantsAsProps?: boolean;
     hasTextAncestor?: boolean;
-};
+    isExiting?: boolean;
+    exitVariant?: string;
+    enterVariant?: string;
+};
+export interface PresenceContextProps {
+    id: string;
+    isPresent: boolean;
+    register: (id: string) => () => void;
+    onExitComplete?: (id: string) => void;
+    initial?: false | string | string[];
+    custom?: any;
+    exitVariant?: string | null;
+    enterVariant?: string | null;
+}
+declare type SafeToRemoveCallback = () => void;
+declare type AlwaysPresent = [true, null, null];
+declare type Present = [true, undefined, PresenceContextProps];
+declare type NotPresent = [false, SafeToRemoveCallback, PresenceContextProps];
+export declare type UsePresenceResult = AlwaysPresent | Present | NotPresent;
 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;
+    isReactNative?: boolean;
     useAnimations: UseAnimationHook;
+    usePresence: () => UsePresenceResult;
+    useAnimatedNumber: (initial: number) => UniversalAnimatedNumber<any>;
+    useAnimatedNumberStyle: <V extends UniversalAnimatedNumber<any>>(val: V, getStyle: (current: any) => any) => any;
+    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 = {
+export declare type UseAnimationHook = (props: {
+    style: Record<string, any>;
+    props: Record<string, any>;
+    presence?: UsePresenceResult | null;
+    hostRef: RefObject<HTMLElement | View>;
     staticConfig: StaticConfigParsed;
-    getStyle: (props?: {
-        isEntering?: boolean;
-        isExiting?: boolean;
-        exitVariant?: string | null;
-        enterVariant?: string | null;
-    }) => ViewStyle;
     state: SplitStyleState;
     pseudos: PseudoProps<ViewStyle>;
     onDidAnimate?: any;
     delay?: number;
-};
-export declare type UseAnimationHook = (props: UseAnimationProps, helpers: UseAnimationHelpers) => {
+}) => null | {
     style?: StackStylePropsBase | StackStylePropsBase[];
 };
+export declare type GestureReponderEvent = Exclude<View['props']['onResponderMove'], void> extends (event: infer Event) => void ? Event : never;
 export {};
 //# sourceMappingURL=types.d.ts.map

package/types/updateTheme.d.ts

@@ -0,0 +1,30 @@
+import { ThemeDefinition } from './types';
+export declare function updateTheme({ name, theme, }: {
+    name: string;
+    theme: Partial<Record<keyof ThemeDefinition, any>>;
+}): {
+    theme: {
+        [x: string]: import("./createVariable").Variable<any>;
+        background?: import("./createVariable").Variable<any> | undefined;
+        backgroundHover?: import("./createVariable").Variable<any> | undefined;
+        backgroundPress?: import("./createVariable").Variable<any> | undefined;
+        backgroundFocus?: import("./createVariable").Variable<any> | undefined;
+        color?: import("./createVariable").Variable<any> | undefined;
+        colorHover?: import("./createVariable").Variable<any> | undefined;
+        colorPress?: import("./createVariable").Variable<any> | undefined;
+        colorFocus?: import("./createVariable").Variable<any> | undefined;
+        borderColor?: import("./createVariable").Variable<any> | undefined;
+        borderColorHover?: import("./createVariable").Variable<any> | undefined;
+        borderColorPress?: import("./createVariable").Variable<any> | undefined;
+        borderColorFocus?: import("./createVariable").Variable<any> | undefined;
+        shadowColor?: import("./createVariable").Variable<any> | undefined;
+        shadowColorHover?: import("./createVariable").Variable<any> | undefined;
+        shadowColorPress?: import("./createVariable").Variable<any> | undefined;
+        shadowColorFocus?: import("./createVariable").Variable<any> | undefined;
+    };
+    cssRules?: undefined;
+} | {
+    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

@@ -1,10 +1,10 @@
-import * as React from 'react';
+import { ReactNode } from 'react';
 export declare type SlotProps = {
-    children?: React.ReactNode;
+    children?: ReactNode;
 };
-export declare const Slot: React.ForwardRefExoticComponent<SlotProps & React.RefAttributes<HTMLElement>>;
+export declare const Slot: import("react").ForwardRefExoticComponent<SlotProps & import("react").RefAttributes<HTMLElement>>;
 export declare const Slottable: ({ children }: {
-    children: React.ReactNode;
+    children: ReactNode;
 }) => JSX.Element;
 export declare function mergeEvent(a?: Function, b?: Function): (...args: unknown[]) => void;
 //# sourceMappingURL=Slot.d.ts.map