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

package/types/config.d.ts

@@ -0,0 +1,47 @@
+import { ConfigListener, TamaguiInternalConfig, Tokens } from './types';
+export declare const setConfig: (next: TamaguiInternalConfig) => void;
+export declare const setConfigFont: (name: string, font: any, fontParsed: any) => void;
+export declare const getHasConfigured: () => boolean;
+export declare const getConfig: () => TamaguiInternalConfig<import("./types").CreateTokens<import("./types").VariableVal>, {
+    [key: string]: Partial<import("./types").TamaguiBaseTheme> & {
+        [key: string]: import("./types").VariableVal;
+    };
+}, import("./types").GenericShorthands, {
+    [key: string]: {
+        [key: string]: string | number;
+    };
+}, {
+    [key: string]: string | any[] | {
+        [key: string]: any;
+    };
+}, import("./types").GenericFonts>;
+export declare const getTokens: (prefixed?: boolean) => Tokens;
+/**
+ * Note: this is the same as `getTokens`
+ */
+export declare const useTokens: (prefixed?: boolean) => Tokens;
+export declare const getThemes: () => {
+    [x: string]: {
+        [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;
+    };
+};
+export declare const configListeners: Set<ConfigListener>;
+export declare const onConfiguredOnce: (cb: ConfigListener) => void;
+export declare const updateConfig: (key: string, value: any) => void;
+//# sourceMappingURL=config.d.ts.map

package/types/constants/constants.d.ts

@@ -1,5 +1,5 @@
 export declare const THEME_NAME_SEPARATOR = "_";
-export declare const THEME_CLASSNAME_PREFIX = "tui_";
+export declare const THEME_CLASSNAME_PREFIX = "t_";
 export declare const stackDefaultStyles: {
     display?: string | undefined;
     flexBasis?: string | undefined;

package/types/constants/isDevTools.d.ts

@@ -0,0 +1,2 @@
+export declare const isDevTools: any;
+//# sourceMappingURL=isDevTools.d.ts.map

package/types/constants/platform.d.ts

@@ -1,12 +1,13 @@
-import { useEffect } from 'react';
+import { useLayoutEffect } from 'react';
 export declare const isAndroid: boolean;
 export declare const isIOS: boolean;
 export declare const isWeb: boolean;
-export declare const isSSR: boolean;
+export declare const isWindowDefined: boolean;
+export declare const isServer: boolean;
 export declare const isClient: boolean;
-export declare const useIsomorphicLayoutEffect: typeof useEffect;
+export declare const isRSC: any;
+export declare const useIsomorphicLayoutEffect: typeof useLayoutEffect;
 export declare const isChrome: boolean;
-export declare const supportsTouchWeb: boolean;
-export declare const isTouchDevice: boolean;
-export declare const isWebIOS: boolean;
+export declare const isWebTouchable: boolean;
+export declare const isTouchable: boolean;
 //# sourceMappingURL=platform.d.ts.map

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

@@ -0,0 +1,13 @@
+import { useLayoutEffect } from 'react';
+export declare const isAndroid: boolean;
+export declare const isIOS: boolean;
+export declare const isWeb = false;
+export declare const isWindowDefined = false;
+export declare const isServer = false;
+export declare const isClient = false;
+export declare const isRSC = false;
+export declare const useIsomorphicLayoutEffect: typeof useLayoutEffect;
+export declare const isChrome = false;
+export declare const isWebTouchable = false;
+export declare const isTouchable = true;
+//# sourceMappingURL=platform.native.d.ts.map

package/types/contexts/FontLanguageContext.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="react" />
+export declare const FontLanguageContext: import("react").Context<Partial<{
+    [x: string]: import("..").FontLanguages;
+}> | null>;
+//# sourceMappingURL=FontLanguageContext.d.ts.map

package/types/{ThemeContext.d.ts → contexts/ThemeContext.d.ts}

@@ -1,5 +1,5 @@
 /// <reference types="react" />
-import { ThemeName, Themes } from './types';
+import { ThemeName, Themes } from '../types';
 export declare const ThemeContext: import("react").Context<{
     themes: Themes;
     defaultTheme: ThemeName;

package/types/createComponent.d.ts

@@ -1,19 +1,36 @@
-/// <reference types="react" />
-import { View, ViewStyle } from 'react-native';
-import { SpaceTokens, StackProps, StaticConfig, StaticConfigParsed, StylableComponent, TamaguiComponent } from './types';
+import React from 'react';
+import { SpaceDirection, SpaceTokens, SpacerProps, StaticConfig, StaticConfigParsed, StylableComponent, TamaguiComponent, TamaguiElement } from './types';
 export declare const mouseUps: Set<Function>;
-export declare function createComponent<ComponentPropTypes extends Object = {}, Ref = View, BaseProps = never>(configIn: Partial<StaticConfig> | StaticConfigParsed, ParentComponent?: StylableComponent): TamaguiComponent<ComponentPropTypes, Ref, BaseProps, {}>;
-export declare const Spacer: TamaguiComponent<Omit<StackProps, "flex" | "direction"> & {
-    size?: SpaceTokens | undefined;
-    flex?: number | boolean | undefined;
-    direction?: "horizontal" | "vertical" | undefined;
-}, View, never, {}>;
-export declare function spacedChildren({ isZStack, children, space, flexDirection, spaceFlex, }: {
+export declare function createComponent<ComponentPropTypes extends Object = {}, Ref = TamaguiElement, BaseProps = never>(configIn: Partial<StaticConfig> | StaticConfigParsed, ParentComponent?: StylableComponent): TamaguiComponent<ComponentPropTypes, Ref, BaseProps, {}>;
+export declare const Unspaced: {
+    (props: {
+        children?: any;
+    }): any;
+    isUnspaced: boolean;
+};
+export declare const Spacer: TamaguiComponent<SpacerProps, TamaguiElement, never, {}>;
+export declare type SpacedChildrenProps = {
     isZStack?: boolean;
-    children: any;
-    space?: any;
+    children?: React.ReactNode;
+    space?: SpaceTokens | number | null;
     spaceFlex?: boolean | number;
-    flexDirection?: ViewStyle['flexDirection'];
-}): any[];
-export declare function AbsoluteFill(props: any): JSX.Element;
+    direction?: SpaceDirection;
+    separator?: React.ReactNode;
+};
+export declare function spacedChildren({ isZStack, children, space, direction, spaceFlex, separator, }: SpacedChildrenProps): React.ReactNode;
+export declare function processIDRefList(idRefList: string | Array<string>): string;
+export declare const accessibilityRoleToWebRole: {
+    adjustable: string;
+    button: string;
+    header: string;
+    image: string;
+    imagebutton: null;
+    keyboardkey: null;
+    label: null;
+    link: string;
+    none: string;
+    search: string;
+    summary: string;
+    text: null;
+};
 //# sourceMappingURL=createComponent.d.ts.map

package/types/createShorthands.d.ts

@@ -1,2 +1,3 @@
-export declare function createShorthands<A extends Record<string, string>>(shorthands: A): A;
+import { CreateShorthands } from './types';
+export declare function createShorthands<A extends CreateShorthands>(shorthands: A): A;
 //# sourceMappingURL=createShorthands.d.ts.map

package/types/createTamagui.d.ts

@@ -1,18 +1,3 @@
-import { Variable } from './createVariable';
-import { AnimationDriver, CreateTamaguiConfig, GenericTamaguiConfig, MediaQueryKey, TamaguiInternalConfig } from './types';
-export declare type CreateTamaguiProps = Partial<Omit<GenericTamaguiConfig, 'themes' | 'tokens' | 'animations'>> & {
-    animations?: AnimationDriver<any>;
-    tokens: GenericTamaguiConfig['tokens'];
-    themes: {
-        [key: string]: {
-            [key: string]: string | number | Variable;
-        };
-    };
-    mediaQueryDefaultActive?: MediaQueryKey[];
-    cssStyleSeparator?: string;
-    maxDarkLightNesting?: number;
-    shouldAddPrefersColorThemes?: boolean;
-    themeClassNameOnRoot?: boolean;
-};
-export declare function createTamagui<Conf extends CreateTamaguiProps>(config: Conf): Conf extends Partial<CreateTamaguiConfig<infer A, infer B, infer C, infer D, infer E, infer F>> ? TamaguiInternalConfig<A, B, C, D, E, F> : unknown;
+import { CreateTamaguiProps, InferTamaguiConfig } from './types';
+export declare function createTamagui<Conf extends CreateTamaguiProps>(configIn: Conf): InferTamaguiConfig<Conf>;
 //# sourceMappingURL=createTamagui.d.ts.map

package/types/createTheme.d.ts

@@ -2,6 +2,6 @@ import { Variable } from './createVariable';
 declare type GenericTheme = {
     [key: string]: string | Variable;
 };
-export declare const createTheme: <Theme extends GenericTheme>(theme: Theme) => { [K in keyof Theme]: string | Variable | Theme[K]; };
+export declare const createTheme: <Theme extends GenericTheme>(theme: Theme) => { [K in keyof Theme]: string | Variable<any> | Theme[K]; };
 export {};
 //# sourceMappingURL=createTheme.d.ts.map

package/types/createTokens.d.ts

@@ -1,7 +1,6 @@
 import { Variable } from './createVariable';
 import { CreateTokens } from './types';
 export declare function createTokens<T extends CreateTokens>(tokens: T): MakeTokens<T>;
-export declare const mapTokensToVariables: (tokens: CreateTokens, parentPath?: string) => CreateTokens<Variable>;
 declare type MakeTokens<T> = T extends {
     color: infer E;
     space: infer F;
@@ -10,19 +9,19 @@ declare type MakeTokens<T> = T extends {
     zIndex: infer J;
 } ? {
     color: {
-        [key in keyof E]: Variable;
+        [Key in keyof E]: E[Key] extends Variable ? E[Key] : Variable<E[Key]>;
     };
     space: {
-        [key in keyof F]: Variable;
+        [Key in keyof F]: F[Key] extends Variable ? F[Key] : Variable<F[Key]>;
     };
     size: {
-        [key in keyof G]: Variable;
+        [Key in keyof G]: G[Key] extends Variable ? G[Key] : Variable<G[Key]>;
     };
     radius: {
-        [key in keyof H]: Variable;
+        [Key in keyof H]: H[Key] extends Variable ? H[Key] : Variable<H[Key]>;
     };
     zIndex: {
-        [key in keyof J]: Variable;
+        [Key in keyof J]: J[Key] extends Variable ? J[Key] : Variable<J[Key]>;
     };
 } : never;
 export {};

package/types/createVariable.d.ts

@@ -1,20 +1,32 @@
-export declare const IS_VARIABLE_SYMBOL = "__isVariable__";
-export declare class Variable {
-    [IS_VARIABLE_SYMBOL]: boolean;
+/**
+ * Should rename this to Token
+ * Moving to objects for React Server Components support
+ */
+declare const IS_VAR = "__isVar__";
+declare type VariableIn<A = any> = {
+    val: A;
     name: string;
-    val: string | number;
-    variable: string | number;
-    constructor({ val, name }: VariableIn);
-    toString(): string;
-}
-declare type VariableIn = {
-    val: string | number | Variable;
+    key: string;
+    isFloating?: boolean;
+};
+export declare type Variable<A = any> = VariableIn<A> & {
+    [IS_VAR]?: true;
+    variable?: string;
+};
+export declare const createVariable: <A extends string | number = any>(props: VariableIn<A>) => VariableIn<A> | {
+    variable: string;
+    val: A;
     name: string;
+    key: string;
+    isFloating?: boolean | undefined;
+    __isVar__: boolean;
 };
-export declare const createVariable: (props: VariableIn) => Variable;
+export declare function variableToString(vrble?: any, getValue?: boolean): string;
 export declare function isVariable(v: Variable | any): v is Variable;
+export declare function getVariable(nameOrVariable: Variable | string): string;
 export declare function getVariableValue(v: Variable | any): any;
 export declare function getVariableName(v: Variable | any): any;
-export declare const createCSSVariable: (val: string, includeVar?: boolean) => string;
+export declare function getVariableVariable(v: Variable | any): any;
+export declare const createCSSVariable: (nameProp: string, includeVar?: boolean) => string;
 export {};
 //# sourceMappingURL=createVariable.d.ts.map

package/types/createVariables.d.ts

@@ -0,0 +1,10 @@
+import { Variable } from './createVariable';
+declare type DeepTokenObject<Val extends string | number = any> = {
+    [key: string]: Val | DeepTokenObject<Val>;
+};
+export declare type DeepVariableObject<A extends DeepTokenObject> = {
+    [Key in keyof A]: A[Key] extends string | number ? Variable<A[Key]> : A[Key] extends DeepTokenObject ? DeepVariableObject<A[Key]> : never;
+};
+export declare const createVariables: <A extends DeepTokenObject<any>>(tokens: A, parentPath?: string, isFont?: boolean) => DeepVariableObject<A>;
+export {};
+//# sourceMappingURL=createVariables.d.ts.map

package/types/helpers/RNComponents.d.ts

@@ -1,2 +1,2 @@
-export declare const RNComponents: WeakMap<object, any>;
+export declare const RNComponents: Set<any>;
 //# sourceMappingURL=RNComponents.d.ts.map

package/types/helpers/ThemeManager.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="react" />
+import { ThemeParsed, Themes } from '../types';
+declare type ThemeListener = (name: string | null, themeManager: ThemeManager) => void;
+export declare type SetActiveThemeProps = {
+    className?: string;
+    parentManager?: ThemeManager | null;
+    name?: string | null;
+    theme?: any;
+};
+export declare type GetNextThemeProps = {
+    themes?: Themes;
+    name?: string | null;
+    componentName?: string | null;
+    reset?: boolean;
+};
+export declare class ThemeManager {
+    name: string;
+    className: string;
+    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?: ThemeParsed | null, parentManager?: ThemeManager | null, reset?: boolean);
+    get didChangeTheme(): boolean | null;
+    get parentName(): string | null;
+    get fullName(): string;
+    getValue(key: string): import("..").Variable<any> | undefined;
+    isTracking(uuid: Object): boolean;
+    update({ name, theme, className }?: SetActiveThemeProps, force?: boolean, notify?: boolean): boolean;
+    getNextTheme(props?: GetNextThemeProps, debug?: any): {
+        name: string;
+        theme: ThemeParsed | null;
+        className: string | undefined;
+    };
+    getClassName(name: string): string;
+    track(uuid: any, keys: Set<string>): void;
+    notifyListeners(): void;
+    onChangeTheme(cb: ThemeListener): () => void;
+    onUpdate(uuid: any, cb: Function): () => void;
+}
+export declare const ThemeManagerContext: import("react").Context<ThemeManager | null>;
+export declare const emptyManager: ThemeManager;
+export {};
+//# sourceMappingURL=ThemeManager.d.ts.map

package/types/helpers/assignNativePropsToWeb.d.ts

@@ -0,0 +1,2 @@
+export declare function assignNativePropsToWeb(elementType: string, viewProps: any, nativeProps: any): void;
+//# sourceMappingURL=assignNativePropsToWeb.d.ts.map

package/types/helpers/assignNativePropsToWeb.native.d.ts

@@ -0,0 +1,2 @@
+export declare function assignNativePropsToWeb(elementType: string, viewProps: any, nativeProps: any): void;
+//# sourceMappingURL=assignNativePropsToWeb.native.d.ts.map

package/types/helpers/calc.d.ts

@@ -0,0 +1,17 @@
+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;
+    '-': (a: number, b: number) => number;
+    '/': (a: number, b: number) => number;
+    '*': (a: number, b: number) => number;
+};
+declare type Operator = keyof typeof operators;
+export declare const calc: (...valuesAndOperators: (CalcVal | Operator)[]) => string | number;
+export {};
+//# sourceMappingURL=calc.d.ts.map

package/types/helpers/createMediaStyle.d.ts

@@ -1,8 +1,6 @@
 import { StyleObject } from '@tamagui/helpers';
 import { MediaQueries } from '../types';
+import { PartialStyleObject } from './insertStyleRule';
 export declare const MEDIA_SEP = "_";
-export declare const createMediaStyle: ({ identifier, rules }: StyleObject, mediaKey: string, mediaQueries: MediaQueries, negate?: boolean | undefined, importance?: number | undefined) => {
-    styleRule: string;
-    identifier: string;
-};
+export declare const createMediaStyle: ({ property, identifier, rules }: StyleObject, mediaKey: string, mediaQueries: MediaQueries, negate?: boolean, importance?: number) => PartialStyleObject;
 //# sourceMappingURL=createMediaStyle.d.ts.map

package/types/helpers/createPropMapper.d.ts

@@ -1,4 +1,7 @@
-import { StaticConfig } from '../types';
-export declare type ResolveVariableTypes = 'auto' | 'value' | 'variable' | 'both';
-export declare const createPropMapper: (staticConfig: Partial<StaticConfig>) => (key: string, value: any, theme: any, props: any, returnVariablesAs?: ResolveVariableTypes, avoidDefaultProps?: boolean) => Record<string, any> | undefined;
+import { PropMapper, SplitStyleState, StaticConfigParsed, TamaguiInternalConfig } from '../types';
+export declare type ResolveVariableTypes = 'auto' | 'value' | 'variable' | 'both' | 'non-color-value';
+export declare const getReturnVariablesAs: (props: any, state: Partial<SplitStyleState>) => "auto" | "value" | "non-color-value";
+export declare const createPropMapper: (staticConfig: StaticConfigParsed) => PropMapper;
+export declare function getFontFamilyFromNameOrVariable(input: any, conf: TamaguiInternalConfig): string | undefined;
+export declare const getPropMappedFontFamily: (expanded?: any) => any;
 //# sourceMappingURL=createPropMapper.d.ts.map

package/types/helpers/expandStyle.d.ts

@@ -0,0 +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

@@ -0,0 +1,26 @@
+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("../types").TamaguiInternalConfig<import("../types").CreateTokens<import("../types").VariableVal>, {
+    [key: string]: Partial<import("../types").TamaguiBaseTheme> & {
+        [key: string]: import("../types").VariableVal;
+    };
+}, import("../types").GenericShorthands, {
+    [key: string]: {
+        [key: string]: string | number;
+    };
+}, {
+    [key: string]: string | any[] | {
+        [key: string]: any;
+    };
+}, import("../types").GenericFonts>): Record<string, any>;
+export declare function fixStyles(style: Record<string, any>): void;
+//# sourceMappingURL=expandStyles.d.ts.map

package/types/helpers/getAnimationDriver.d.ts

@@ -0,0 +1,6 @@
+export declare function getAnimationDriver(): import("..").AnimationDriver<{
+    [key: string]: string | any[] | {
+        [key: string]: any;
+    };
+}>;
+//# sourceMappingURL=getAnimationDriver.d.ts.map

package/types/helpers/getFont.d.ts

@@ -0,0 +1,3 @@
+import { FontSizeTokens, TextProps, VariantSpreadFunction } from '../types';
+export declare const getFont: VariantSpreadFunction<TextProps, FontSizeTokens>;
+//# sourceMappingURL=getFont.d.ts.map

package/types/helpers/getFontLanguage.d.ts

@@ -0,0 +1,2 @@
+export declare const getFontLanguage: (fontFamily: string) => string | null;
+//# sourceMappingURL=getFontLanguage.d.ts.map

package/types/helpers/getSize.d.ts

@@ -1,3 +1,4 @@
-import { SizeTokens } from '../types';
-export declare const getSize: (size?: SizeTokens | undefined, sizeUpOrDownBy?: number) => SizeTokens;
+import { SizeTokens, SpaceTokens } from '../types';
+export declare const getSize: (size?: SizeTokens | undefined, shift?: number, bounds?: number[]) => any;
+export declare const stepTokenUpOrDown: (tokens: Object, current?: SizeTokens | SpaceTokens | string, shift?: number, bounds?: number[]) => any;
 //# sourceMappingURL=getSize.d.ts.map

package/types/helpers/getSplitStyles.d.ts

@@ -1,24 +1,31 @@
-import { ViewStyle } from 'react-native';
-import { MediaKeys, PseudoStyles, SplitStyleState, StackProps, StaticConfigParsed, ThemeObject } from '../types';
+import type { ViewStyle } from 'react-native';
+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>;
 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 & {
-    keepVariantsAsProps?: boolean;
-}, defaultClassNames?: any) => {
+}, staticConfig: StaticConfigParsed, theme: ThemeParsed, state: SplitStyleState, defaultClassNames?: any, languageContext?: LanguageContextType, debug?: DebugProp) => {
     pseudos: PseudoStyles;
-    medias: Record<MediaKeys, ViewStyle>;
+    medias: Record<MediaQueryKey, ViewStyle>;
     style: ViewStyle;
     classNames: ClassNamesObject;
-    rulesToInsert: [string, string][];
+    rulesToInsert: RulesToInsert;
     viewProps: StackProps;
+    fontFamily: string | undefined;
+    mediaKeys: string[];
+};
+export declare const PROP_SPLIT = "-";
+export declare const pseudoCNInverse: {
+    hover: string;
+    focus: string;
+    press: string;
 };
 export declare const getSplitStyles: StyleSplitter;
+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 declare const getSubStyle: (styleIn: Object, staticConfig: StaticConfigParsed, theme: ThemeObject, props: any, state: SplitStyleState, avoidDefaultProps?: boolean | undefined) => ViewStyle;
-export declare function normalizeStyleObject(style: any): void;
 export {};
 //# sourceMappingURL=getSplitStyles.d.ts.map

package/types/helpers/getStackSize.d.ts

@@ -0,0 +1,8 @@
+import { SizeTokens, VariantSpreadExtras } from '../types';
+export declare type ScaleVariantExtras = Pick<VariantSpreadExtras<any>, 'tokens' | 'props' | 'fonts'>;
+export declare const getButtonSize: (val: SizeTokens | number, { tokens }: VariantSpreadExtras<any>) => {
+    paddingHorizontal: any;
+    height: any;
+    borderRadius: import("../types").VariableVal;
+};
+//# sourceMappingURL=getStackSize.d.ts.map

package/types/helpers/getStylesAtomic.d.ts

@@ -1,27 +1,22 @@
+/**
+ * Some parts adapted from react-native-web
+ * Copyright (c) Nicolas Gallagher licensed under the MIT license.
+ */
 import { StyleObject } from '@tamagui/helpers';
-import { ViewStyle } from 'react-native';
-export declare type ViewStyleWithPseudos = ViewStyle & {
-    hoverStyle?: ViewStyle;
-    pressStyle?: ViewStyle;
-    focusStyle?: ViewStyle;
+import type { TextStyle, ViewStyle } from 'react-native';
+import { PseudoDescriptor } from './pseudoDescriptors';
+declare type ViewOrTextStyle = ViewStyle | TextStyle;
+export declare type ViewStyleWithPseudos = ViewOrTextStyle & {
+    hoverStyle?: ViewOrTextStyle;
+    pressStyle?: ViewOrTextStyle;
+    focusStyle?: ViewOrTextStyle;
 };
-declare type AtomicStyleOptions = {
-    splitTransforms?: boolean;
-};
-export declare function getStylesAtomic(stylesIn: ViewStyleWithPseudos, options?: AtomicStyleOptions): StyleObject[];
-export declare const pseudos: {
-    hoverStyle: {
-        name: string;
-        priority: number;
-    };
-    pressStyle: {
-        name: string;
-        priority: number;
-    };
-    focusStyle: {
-        name: string;
-        priority: number;
-    };
+export declare function getStylesAtomic(stylesIn: ViewStyleWithPseudos): StyleObject[];
+export declare function getAtomicStyle(style: ViewOrTextStyle, pseudo?: PseudoDescriptor): StyleObject[];
+export declare function styleToCSS(style: Record<string, any>): void;
+declare type Value = Object | Array<any> | string | number;
+export declare type Style = {
+    [key: string]: Value;
 };
 export {};
 //# sourceMappingURL=getStylesAtomic.d.ts.map

package/types/helpers/getThemeCSSRules.d.ts

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

package/types/helpers/getThemeCSSRules.native.d.ts

@@ -0,0 +1,2 @@
+export declare function getThemeCSSRules(): never[];
+//# sourceMappingURL=getThemeCSSRules.native.d.ts.map

package/types/helpers/getVariantExtras.d.ts

@@ -0,0 +1,5 @@
+import { GenericFonts } from '../types';
+import { LanguageContextType } from '../views/FontLanguage.types';
+export declare function getVariantExtras(props: any, languageContext?: LanguageContextType, theme?: any, defaultProps?: any, avoidDefaultProps?: boolean): any;
+export declare function getFontsForLanguage(fonts: GenericFonts, language: LanguageContextType): any;
+//# sourceMappingURL=getVariantExtras.d.ts.map

package/types/helpers/insertStyleRule.d.ts

@@ -1,8 +1,12 @@
+import type { StyleObject } from '@tamagui/helpers';
 export declare const insertedTransforms: {};
 export declare const getAllSelectors: () => {};
-export declare const getInsertedRules: () => unknown[];
+export declare const getAllRules: () => unknown[];
 export declare const getAllTransforms: () => {};
 export declare function updateInserted(): void;
-export declare function updateInsertedCache(identifier: string, rule: string): void;
-export declare function insertStyleRule(identifier: string, rule: string): void;
+export declare function updateRules(identifier: string, rules: string[]): boolean;
+export declare type PartialStyleObject = Pick<StyleObject, 'identifier' | 'property' | 'rules'>;
+export declare type RulesToInsert = PartialStyleObject[];
+export declare function insertStyleRules(rulesToInsert: RulesToInsert): void;
+export declare function shouldInsertStyleRules(styleObject: PartialStyleObject): boolean;
 //# sourceMappingURL=insertStyleRule.d.ts.map

package/types/helpers/isTamaguiComponent.d.ts

@@ -0,0 +1,5 @@
+import { StaticConfig } from '../types';
+export declare function isTamaguiComponent<A>(comp: A, name?: string): comp is A & {
+    staticConfig: StaticConfig;
+};
+//# sourceMappingURL=isTamaguiComponent.d.ts.map

package/types/helpers/isTamaguiElement.d.ts

@@ -1,3 +1,7 @@
 import React from 'react';
-export declare const isTamaguiElement: (child: any) => child is React.ReactElement<any, string | React.JSXElementConstructor<any>>;
+import { TamaguiComponent } from '../types';
+export declare type TamaguiReactElement<P = any> = React.ReactElement<P> & {
+    type: TamaguiComponent;
+};
+export declare const isTamaguiElement: (child: any, name?: string) => child is TamaguiReactElement<any>;
 //# sourceMappingURL=isTamaguiElement.d.ts.map

package/types/helpers/matchMedia.d.ts

@@ -1,2 +1,2 @@
-export declare const matchMedia: any;
+export declare const matchMedia: ((query: string) => MediaQueryList) & typeof globalThis.matchMedia;
 //# sourceMappingURL=matchMedia.d.ts.map