@tamagui/core 1.0.1-beta.167 → 1.0.1-beta.169

package/types/config.d.ts

@@ -17,8 +17,24 @@ export declare const getConfig: () => TamaguiInternalConfig<import("./types").Cr
 }, import("./types").GenericFonts>;
 export declare const getTokens: () => import("./types").CreateTokens<import("./createVariable").Variable<import("./createVariable").VariableValue>>;
 export declare const getThemes: () => {
-    [key: string]: Partial<import("./types").TamaguiBaseTheme> & {
-        [key: string]: import("./types").VariableVal;
+    [x: string]: {
+        [x: string]: import("./createVariable").Variable<import("./createVariable").VariableValue>;
+        background?: import("./createVariable").Variable<import("./createVariable").VariableValue> | undefined;
+        backgroundHover?: import("./createVariable").Variable<import("./createVariable").VariableValue> | undefined;
+        backgroundPress?: import("./createVariable").Variable<import("./createVariable").VariableValue> | undefined;
+        backgroundFocus?: import("./createVariable").Variable<import("./createVariable").VariableValue> | undefined;
+        color?: import("./createVariable").Variable<import("./createVariable").VariableValue> | undefined;
+        colorHover?: import("./createVariable").Variable<import("./createVariable").VariableValue> | undefined;
+        colorPress?: import("./createVariable").Variable<import("./createVariable").VariableValue> | undefined;
+        colorFocus?: import("./createVariable").Variable<import("./createVariable").VariableValue> | undefined;
+        borderColor?: import("./createVariable").Variable<import("./createVariable").VariableValue> | undefined;
+        borderColorHover?: import("./createVariable").Variable<import("./createVariable").VariableValue> | undefined;
+        borderColorPress?: import("./createVariable").Variable<import("./createVariable").VariableValue> | undefined;
+        borderColorFocus?: import("./createVariable").Variable<import("./createVariable").VariableValue> | undefined;
+        shadowColor?: import("./createVariable").Variable<import("./createVariable").VariableValue> | undefined;
+        shadowColorHover?: import("./createVariable").Variable<import("./createVariable").VariableValue> | undefined;
+        shadowColorPress?: import("./createVariable").Variable<import("./createVariable").VariableValue> | undefined;
+        shadowColorFocus?: import("./createVariable").Variable<import("./createVariable").VariableValue> | undefined;
     };
 };
 export declare const configListeners: Set<ConfigListener>;

package/types/constants/platform.d.ts

@@ -3,7 +3,7 @@ export declare const isAndroid: boolean;
 export declare const isIOS: boolean;
 export declare const isWeb: boolean;
 export declare const isWindowDefined: boolean;
-export declare const isSSR: boolean;
+export declare const isServer: boolean;
 export declare const isClient: boolean;
 export declare const isRSC: any;
 export declare const useIsomorphicLayoutEffect: typeof useEffect;

package/types/constants/platform.native.d.ts

@@ -3,7 +3,7 @@ export declare const isAndroid: boolean;
 export declare const isIOS: boolean;
 export declare const isWeb = false;
 export declare const isWindowDefined = false;
-export declare const isSSR = false;
+export declare const isServer = false;
 export declare const isClient = false;
 export declare const isRSC = false;
 export declare const useIsomorphicLayoutEffect: typeof useLayoutEffect;

package/types/createVariable.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Should rename this to Token
+ * Moving to objects for React Server Components support
+ */
 declare const IS_VAR = "__isVar__";
 export declare type VariableValue = string | number;
 declare type VariableIn<A extends VariableValue = VariableValue> = {

package/types/helpers/ThemeManager.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="react" />
-import { ThemeObject, Themes } from '../types';
+import { ThemeParsed, Themes } from '../types';
 declare type ThemeListener = (name: string | null, themeManager: ThemeManager) => void;
 export declare type SetActiveThemeProps = {
     className?: string;
@@ -16,22 +16,22 @@ export declare type GetNextThemeProps = {
 export declare class ThemeManager {
     name: string;
     className: string;
-    theme: ThemeObject | null;
+    theme: ThemeParsed | null;
     parentManager: ThemeManager | null;
     reset: boolean;
     keys: Map<any, Set<string>>;
     listeners: Map<any, Function>;
     themeListeners: Set<ThemeListener>;
-    constructor(name?: string, className?: string, theme?: ThemeObject | null, parentManager?: ThemeManager | null, reset?: boolean);
+    constructor(name?: string, className?: string, theme?: ThemeParsed | null, parentManager?: ThemeManager | null, reset?: boolean);
     get didChangeTheme(): boolean | null;
     get parentName(): string | null;
     get fullName(): string;
-    getValue(key: string): import("../types").VariableVal | undefined;
+    getValue(key: string): import("..").Variable<import("..").VariableValue> | undefined;
     isTracking(uuid: Object): boolean;
     update({ name, theme, className }?: SetActiveThemeProps, force?: boolean): boolean;
     getNextTheme(props?: GetNextThemeProps, debug?: any): {
         name: string;
-        theme: ThemeObject | null;
+        theme: ThemeParsed | null;
         className: string | undefined;
     };
     getClassName(name: string): string;

package/types/helpers/calc.d.ts

@@ -1,4 +1,9 @@
 import { FontLineHeightTokens, FontSizeTokens, SizeTokens, SpaceTokens } from '../types';
+/**
+ * Simple calc() that handles native + web
+ *   on web: outputs a calc() string
+ *   on native: outputs a plain number
+ */
 export declare type CalcVal = string | number | SizeTokens | SpaceTokens | FontSizeTokens | FontLineHeightTokens;
 declare const operators: {
     '+': (a: number, b: number) => number;

package/types/helpers/expandStyle.d.ts

@@ -1,2 +1,6 @@
+/**
+ * Some parts adapted from react-native-web
+ * Copyright (c) Nicolas Gallagher licensed under the MIT license.
+ */
 export declare function expandStyle(key: string, value: any): any[][] | undefined;
 //# sourceMappingURL=expandStyle.d.ts.map

package/types/helpers/expandStyles.d.ts

@@ -2,6 +2,13 @@ export declare const defaultOffset: {
     height: number;
     width: number;
 };
+/**
+ * This is what you want to run before Object.assign() a style onto another.
+ * It does the following:
+ *   1. Turns user shorthands into longhands, ie px = paddingHorizontal
+ *   2. Normalizes various inconsistent styles to be more consistent
+ *   3. Expands react-native shorthands, ie paddingHorizontal => paddingLeft, paddingRight
+ */
 export declare function expandStyles(style: Record<string, any>, config?: import("..").TamaguiInternalConfig<import("..").CreateTokens<import("..").VariableVal>, {
     [key: string]: Partial<import("..").TamaguiBaseTheme> & {
         [key: string]: import("..").VariableVal;

package/types/helpers/getSplitStyles.d.ts

@@ -1,5 +1,5 @@
 import type { ViewStyle } from 'react-native';
-import type { DebugProp, MediaQueryKey, PseudoStyles, SplitStyleState, StackProps, StaticConfigParsed, TamaguiInternalConfig, ThemeObject } from '../types';
+import type { DebugProp, MediaQueryKey, PseudoStyles, SplitStyleState, StackProps, StaticConfigParsed, TamaguiInternalConfig, ThemeParsed } from '../types';
 import { FontLanguageProps, LanguageContextType } from '../views/FontLanguage.types';
 import { RulesToInsert } from './insertStyleRule';
 export declare type SplitStyles = ReturnType<typeof getSplitStyles>;
@@ -7,7 +7,7 @@ export declare type ClassNamesObject = Record<string, string>;
 export declare type SplitStyleResult = ReturnType<typeof getSplitStyles>;
 declare type StyleSplitter = (props: {
     [key: string]: any;
-}, staticConfig: StaticConfigParsed, theme: ThemeObject, state: SplitStyleState, defaultClassNames?: any, languageContext?: LanguageContextType, debug?: DebugProp) => {
+}, staticConfig: StaticConfigParsed, theme: ThemeParsed, state: SplitStyleState, defaultClassNames?: any, languageContext?: LanguageContextType, debug?: DebugProp) => {
     pseudos: PseudoStyles;
     medias: Record<MediaQueryKey, ViewStyle>;
     style: ViewStyle;
@@ -24,7 +24,7 @@ export declare const pseudoCNInverse: {
     press: string;
 };
 export declare const getSplitStyles: StyleSplitter;
-export declare const getSubStyle: (subKey: string, styleIn: Object, staticConfig: StaticConfigParsed, theme: ThemeObject, props: any, state: SplitStyleState, conf: TamaguiInternalConfig, languageContext?: FontLanguageProps, avoidDefaultProps?: boolean) => ViewStyle;
+export declare const getSubStyle: (subKey: string, styleIn: Object, staticConfig: StaticConfigParsed, theme: ThemeParsed, props: any, state: SplitStyleState, conf: TamaguiInternalConfig, languageContext?: FontLanguageProps, avoidDefaultProps?: boolean) => ViewStyle;
 export declare const insertSplitStyles: StyleSplitter;
 export declare const useSplitStyles: StyleSplitter;
 export {};

package/types/helpers/getStylesAtomic.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Some parts adapted from react-native-web
+ * Copyright (c) Nicolas Gallagher licensed under the MIT license.
+ */
 import { StyleObject } from '@tamagui/helpers';
 import type { TextStyle, ViewStyle } from 'react-native';
 import { PseudoDescriptor } from './pseudoDescriptors';

package/types/helpers/getThemeCSSRules.d.ts

@@ -1,8 +1,8 @@
-import { CreateTamaguiProps, ThemeObject } from '../types';
+import { CreateTamaguiProps, ThemeParsed } from '../types';
 export declare function getThemeCSSRules({ config, themeName, theme, names, }: {
     config: CreateTamaguiProps;
     themeName: string;
-    theme: ThemeObject;
+    theme: ThemeParsed;
     names: string[];
 }): string[];
 //# sourceMappingURL=getThemeCSSRules.d.ts.map

package/types/helpers/mergeProps.d.ts

@@ -1,3 +1,16 @@
+/**
+ * Preserves prop ordering, so that the order most closely matches the last spread objects
+ * Useful for having { ...defaultProps, ...props } that ensure props ordering is always kept
+ *
+ *    Given:
+ *      mergeProps({ a: 1, b: 2 }, { b: 1, a: 2 })
+ *    The final key order will be:
+ *      b, a
+ *
+ * Handles a couple special tamagui cases
+ *   - classNames can be extracted out separately
+ *   - shorthands can be expanded before merging
+ */
 declare type StringRecord = Record<string, string>;
 export declare const mergeProps: (a: Object, b: Object, leaveOutClassNames?: boolean, inverseShorthands?: StringRecord) => readonly [StringRecord, StringRecord];
 export {};

package/types/helpers/normalizeValueWithProperty.d.ts

@@ -1,2 +1,6 @@
+/**
+ * Some parts adapted from react-native-web
+ * Copyright (c) Nicolas Gallagher licensed under the MIT license.
+ */
 export declare function normalizeValueWithProperty(value: any, property?: string): any;
 //# sourceMappingURL=normalizeValueWithProperty.d.ts.map

package/types/hooks/useIsSSR.d.ts

@@ -1,2 +1,4 @@
-export declare const useIsSSR: () => boolean;
+export declare const useIsSSR: (props?: {
+    immediate?: boolean;
+}) => boolean;
 //# sourceMappingURL=useIsSSR.d.ts.map

package/types/hooks/useMedia.d.ts

@@ -1,13 +1,16 @@
-import { ConfigureMediaQueryOptions, MediaQueries, MediaQueryKey, MediaQueryObject, MediaQueryState } from '../types';
+import { MediaQueries, MediaQueryKey, MediaQueryObject, MediaQueryState, TamaguiInternalConfig } from '../types';
 export declare const mediaState: MediaQueryState;
-export declare function addMediaQueryListener(key: MediaQueryKey, cb: any): () => void;
-export declare function removeMediaQueryListener(key: MediaQueryKey, cb: any): void;
+declare type MediaListener = (next: boolean) => void;
+export declare function addMediaQueryListener(key: MediaQueryKey, cb: MediaListener): () => void;
+export declare function removeMediaQueryListener(key: MediaQueryKey, cb: MediaListener): void;
 export declare const mediaQueryConfig: MediaQueries;
 export declare const getMedia: () => MediaQueryState;
-export declare const configureMedia: ({ queries, defaultActive, }?: ConfigureMediaQueryOptions) => void;
-export declare function useMediaQueryListeners(): void;
+export declare const configureMedia: (config: TamaguiInternalConfig) => void;
+export declare const getInitialMediaState: () => MediaQueryState | null;
+export declare function useMediaQueryListeners(config: TamaguiInternalConfig): void;
 export declare function useMedia(): {
     [key in MediaQueryKey]: boolean;
 };
 export declare function mediaObjectToString(query: string | MediaQueryObject): string;
+export {};
 //# sourceMappingURL=useMedia.d.ts.map

package/types/hooks/useTheme.d.ts

@@ -1,5 +1,5 @@
 import { ThemeManager } from '../helpers/ThemeManager';
-import { ThemeName, ThemeObject } from '../types';
+import { ThemeName, ThemeParsed } from '../types';
 export interface ThemeProps {
     className?: string;
     disableThemeClass?: boolean;
@@ -9,7 +9,7 @@ export interface ThemeProps {
     reset?: boolean;
     debug?: boolean | 'verbose';
 }
-export declare const useTheme: (themeName?: string | null, componentName?: string, props?: ThemeProps, forceUpdate?: any) => ThemeObject;
+export declare const useTheme: (themeName?: string | null, componentName?: string, props?: ThemeProps, forceUpdate?: any) => ThemeParsed;
 export declare const getThemeManager: (theme: any) => ThemeManager | undefined;
 export declare const useThemeName: (opts?: {
     parent?: true;
@@ -17,10 +17,10 @@ export declare const useThemeName: (opts?: {
 export declare const useDefaultThemeName: () => ThemeName | undefined;
 export declare const activeThemeManagers: Set<ThemeManager>;
 export declare const useChangeThemeEffect: (name?: string | null, componentName?: string, props?: ThemeProps, forceUpdateProp?: any, uuid?: Object) => {
-    themes: Record<string, ThemeObject>;
+    themes: Record<string, ThemeParsed>;
     themeManager: ThemeManager | null;
     name: string;
-    theme: ThemeObject | null;
+    theme: ThemeParsed | null;
     className?: string | undefined;
 };
 //# sourceMappingURL=useTheme.d.ts.map

package/types/insertFont.d.ts

@@ -1,5 +1,8 @@
 import { DeepVariableObject } from './createVariables';
 import { GenericFont } from './types';
+/**
+ * Runtime dynamic insert font
+ */
 export declare function insertFont<A extends GenericFont>(name: string, fontIn: A): DeepVariableObject<A>;
 export declare function parseFont<A extends GenericFont>(definition: A): DeepVariableObject<A>;
 export declare function registerFontVariables(parsedFont: any): string[];

package/types/styled.d.ts

@@ -14,6 +14,7 @@ export declare function styled<ParentComponent extends StylableComponent, Varian
     defaultVariants?: {
         [key: string]: any;
     };
+    acceptsClassName?: boolean;
 }, staticExtractionOptions?: Partial<StaticConfig>): TamaguiComponent<Variants extends void ? GetProps<ParentComponent> : GetBaseProps<ParentComponent> & Omit<GetVariantProps<ParentComponent>, keyof (Variants extends void ? {} : { [Key in keyof Variants]?: (Variants[Key] extends VariantSpreadFunction<any, infer Val> ? Val : GetVariantValues<keyof Variants[Key]>) | undefined; })> & (Variants extends void ? {} : { [Key in keyof Variants]?: (Variants[Key] extends VariantSpreadFunction<any, infer Val> ? Val : GetVariantValues<keyof Variants[Key]>) | undefined; }) & MediaProps<Partial<GetBaseProps<ParentComponent> & Omit<GetVariantProps<ParentComponent>, keyof (Variants extends void ? {} : { [Key in keyof Variants]?: (Variants[Key] extends VariantSpreadFunction<any, infer Val> ? Val : GetVariantValues<keyof Variants[Key]>) | undefined; })> & (Variants extends void ? {} : { [Key in keyof Variants]?: (Variants[Key] extends VariantSpreadFunction<any, infer Val> ? Val : GetVariantValues<keyof Variants[Key]>) | undefined; })>> & PseudoProps<Partial<GetBaseProps<ParentComponent> & Omit<GetVariantProps<ParentComponent>, keyof (Variants extends void ? {} : { [Key in keyof Variants]?: (Variants[Key] extends VariantSpreadFunction<any, infer Val> ? Val : GetVariantValues<keyof Variants[Key]>) | undefined; })> & (Variants extends void ? {} : { [Key in keyof Variants]?: (Variants[Key] extends VariantSpreadFunction<any, infer Val> ? Val : GetVariantValues<keyof Variants[Key]>) | undefined; })>>, TamaguiElement, GetBaseProps<ParentComponent>, GetVariantProps<ParentComponent> & (Variants extends void ? {} : { [Key in keyof Variants]?: (Variants[Key] extends VariantSpreadFunction<any, infer Val> ? Val : GetVariantValues<keyof Variants[Key]>) | undefined; })>;
 export {};
 //# sourceMappingURL=styled.d.ts.map

package/types/types.d.ts

@@ -108,7 +108,11 @@ export declare type CreateTamaguiConfig<A extends GenericTokens, B extends Gener
     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>;
@@ -129,13 +133,16 @@ declare type ConfProps<A extends GenericTokens, B extends GenericThemes, C exten
 };
 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;
+};
 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 FontLanguages = ArrayIntersection<TamaguiConfig['fontLanguages']>;
@@ -158,6 +165,24 @@ export declare type CreateTamaguiProps = {
         };
     };
     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;
@@ -177,7 +202,6 @@ export declare type TamaguiInternalConfig<A extends GenericTokens = GenericToken
     getCSS: () => string;
     parsed: boolean;
     inverseShorthands: Record<string, string>;
-    themeClassNameOnRoot?: boolean;
 };
 export declare type GetAnimationKeys<A extends GenericTamaguiConfig> = keyof A['animations']['animations'];
 export declare type UnionableString = string & {};
@@ -227,10 +251,6 @@ export declare type MediaProps<A> = {
 export declare type MediaQueries = {
     [key in MediaQueryKey]: MediaQueryObject;
 };
-export declare type ConfigureMediaQueryOptions = {
-    queries?: MediaQueries;
-    defaultActive?: Record<MediaQueryKey, boolean>;
-};
 export declare type TransformStyleProps = {
     x?: number;
     y?: number;
@@ -265,7 +285,7 @@ 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']>;
@@ -348,7 +368,7 @@ export declare type TamaguiProviderProps = Partial<Omit<ThemeProviderProps, 'chi
     disableInjectCSS?: boolean;
     children?: React.ReactNode;
 };
-export declare type PropMapper = (key: string, value: any, theme: ThemeObject, props: Record<string, any>, state: Partial<SplitStyleState>, languageContext?: FontLanguageProps, 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;
@@ -368,32 +388,106 @@ export declare type GenericVariantDefinitions = {
 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;
     };
+    /**
+     * 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;
+    /**
+     * 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;
@@ -442,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';
@@ -452,6 +551,7 @@ export declare type TamaguiComponentState = {
     pressIn: boolean;
     focus: boolean;
     mounted: boolean;
+    mediaState?: null | Record<string, boolean>;
     animation?: null | {
         style?: any;
         avoidClasses?: boolean;

package/types/updateTheme.d.ts

@@ -1,7 +1,7 @@
-import { ThemeObject } from './types';
+import { ThemeDefinition } from './types';
 export declare function updateTheme({ name, theme }: {
     name: string;
-    theme: ThemeObject;
+    theme: ThemeDefinition;
 }): {
     theme: any;
     cssRules: string[];