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

package/types/createComponent.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import { SpaceDirection, SpaceTokens, StackProps, StaticConfig, StaticConfigParsed, StylableComponent, TamaguiComponent, TamaguiElement } from './types';
+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 = TamaguiElement, BaseProps = never>(configIn: Partial<StaticConfig> | StaticConfigParsed, ParentComponent?: StylableComponent): TamaguiComponent<ComponentPropTypes, Ref, BaseProps, {}>;
 export declare const Unspaced: {
@@ -8,37 +8,14 @@ export declare const Unspaced: {
     }): any;
     isUnspaced: boolean;
 };
-export declare type SpacerProps = Omit<StackProps, 'flex' | 'direction'> & {
-    size?: number | SpaceTokens;
-    flex?: boolean | number;
-    direction?: SpaceDirection;
-};
 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;
     direction?: SpaceDirection;
     separator?: React.ReactNode;
 };
-export declare function spacedChildren({ isZStack, children, space, direction, spaceFlex, separator, }: SpacedChildrenProps): any;
-export declare function AbsoluteFill(props: {
-    children?: React.ReactNode;
-}): JSX.Element;
-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;
-};
+export declare function spacedChildren({ isZStack, children, space, direction, spaceFlex, separator, }: SpacedChildrenProps): React.ReactNode;
 //# sourceMappingURL=createComponent.d.ts.map

package/types/createFont.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=createFont.test.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,26 +1,3 @@
-import { SpacerProps } from './createComponent';
-import { Variable } from './createVariable';
-import { AnimationDriver, CreateTamaguiConfig, GenericTamaguiConfig, MediaQueryKey, StackProps, TamaguiInternalConfig, TextProps } 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;
-        };
-    };
-    defaultProps?: Record<string, any> & {
-        Stack?: StackProps;
-        Text?: TextProps;
-        Spacer?: SpacerProps;
-    };
-    mediaQueryDefaultActive?: MediaQueryKey[];
-    cssStyleSeparator?: string;
-    maxDarkLightNesting?: number;
-    shouldAddPrefersColorThemes?: boolean;
-    themeClassNameOnRoot?: boolean;
-};
-export declare type InferTamaguiConfig<Conf extends CreateTamaguiProps> = Conf extends Partial<CreateTamaguiConfig<infer A, infer B, infer C, infer D, infer E, infer F>> ? TamaguiInternalConfig<A, B, C, D, E, F> : unknown;
-export declare function createTamagui<Conf extends CreateTamaguiProps>(config: Conf): InferTamaguiConfig<Conf>;
-export declare const reversedShorthands: Record<string, string>;
+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

@@ -1,4 +1,4 @@
-import { Variable } from './createVariable';
+import type { Variable } from './createVariable';
 declare type GenericTheme = {
     [key: string]: string | Variable;
 };

package/types/createTokens.d.ts

@@ -9,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/createTokens.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=createTokens.test.d.ts.map

package/types/createVariable.d.ts

@@ -1,22 +1,27 @@
-declare const IS_VARIABLE_SYMBOL = "__isVariable__";
-declare type VariableIn<A extends string | number = any> = {
+/**
+ * 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;
     key: string;
-    isFloating?: boolean;
 };
-export declare class Variable<A extends string | number = any> {
-    [IS_VARIABLE_SYMBOL]: 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> | {
+    isVar: boolean;
     key: string;
     name: string;
     val: A;
     variable: string;
-    isFloating: boolean;
-    constructor(props: VariableIn);
-    toString(): string;
-}
-export declare const createVariable: <A extends string | number = any>(props: VariableIn<A>) => Variable<any>;
+};
+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 function getVariableVariable(v: Variable | any): any;

package/types/createVariable.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=createVariable.test.d.ts.map

package/types/createVariables.d.ts

@@ -5,6 +5,6 @@ declare type DeepTokenObject<Val extends string | number = any> = {
 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) => DeepVariableObject<A>;
+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,36 @@
+import { ThemeParsed, ThemeProps } 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;
+    reset?: boolean;
+};
+export declare type ThemeManagerState = {
+    name: string;
+    theme?: ThemeParsed | null;
+    className?: string;
+    parentName?: string;
+};
+export declare function hasNoThemeUpdatingProps(props: ThemeProps): boolean;
+export declare class ThemeManager {
+    #private;
+    props: ThemeProps;
+    themeListeners: Set<ThemeListener>;
+    parentManager: ThemeManager | null;
+    state: ThemeManagerState;
+    constructor(props?: ThemeProps, parentManager?: ThemeManager | 'root' | null | undefined);
+    updateState(props?: ThemeProps & {
+        forceTheme?: ThemeParsed;
+    }, notify?: boolean): ThemeManagerState | undefined;
+    getStateIfChanged(props?: ThemeProps, state?: ThemeManagerState | null, parentManager?: ThemeManager | null): ThemeManagerState | null | undefined;
+    getStateShouldChange(nextState: ThemeManagerState | null, state?: ThemeManagerState | null): ThemeManagerState | null;
+    getState(props?: ThemeProps, parentManager?: ThemeManager | null): ThemeManagerState | null;
+    get allKeys(): Set<string>;
+    getValue(key: string, state?: ThemeManagerState): import("..").Variable<any> | undefined;
+    notify(): void;
+    onChangeTheme(cb: ThemeListener): () => void;
+}
+export {};
+//# sourceMappingURL=ThemeManager.d.ts.map

package/types/helpers/ThemeManager.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ThemeManager.test.d.ts.map

package/types/helpers/ThemeManagerContext.d.ts

@@ -0,0 +1,4 @@
+/// <reference types="react" />
+import { ThemeManager } from './ThemeManager';
+export declare const ThemeManagerContext: import("react").Context<ThemeManager | null>;
+//# sourceMappingURL=ThemeManagerContext.d.ts.map

package/types/helpers/cache.d.ts

@@ -0,0 +1,12 @@
+declare type Value = Object | Array<any> | string | number;
+export declare type Style = {
+    [key: string]: Value;
+};
+declare class Cache {
+    v: Record<string, any>;
+    get(key: string, valStr: string): any;
+    set(key: string, valStr: string, object: any): void;
+}
+export declare const cache: Cache;
+export {};
+//# sourceMappingURL=cache.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, importance?: number) => {
-    styleRule: string;
-    identifier: string;
-};
+export declare const createMediaStyle: ({ property, identifier, rules }: StyleObject, mediaKey: string, mediaQueries: MediaQueries, negate?: boolean) => PartialStyleObject;
 //# sourceMappingURL=createMediaStyle.d.ts.map

package/types/helpers/createPropMapper.d.ts

@@ -1,5 +1,7 @@
-import { PropMapper, SplitStyleState, StaticConfigParsed } from '../types';
+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/createProxy.d.ts

@@ -0,0 +1,2 @@
+export declare function createProxy<A extends object>(target: A, handler: ProxyHandler<A>): A;
+//# sourceMappingURL=createProxy.d.ts.map

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,25 @@ export declare const defaultOffset: {
     height: number;
     width: number;
 };
-export declare function expandStyles(style: Record<string, any>): Record<string, any>;
+/**
+ * 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;
+    };
+}, import("..").GenericShorthands, {
+    [key: string]: {
+        [key: string]: string | number;
+    };
+}, {
+    [key: string]: string | any[] | {
+        [key: string]: any;
+    };
+}, import("..").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/getBoundingClientRect.d.ts

@@ -0,0 +1,2 @@
+export declare const getBoundingClientRect: (node: HTMLElement | null) => void | DOMRect;
+//# sourceMappingURL=getBoundingClientRect.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/getRect.d.ts

@@ -0,0 +1,9 @@
+export declare const getRect: (node: HTMLElement) => {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    top: number;
+    left: number;
+} | undefined;
+//# sourceMappingURL=getRect.d.ts.map

package/types/helpers/getSplitStyles.d.ts

@@ -1,26 +1,42 @@
-import { ViewStyle } from 'react-native';
-import { DebugProp, MediaKeys, PseudoStyles, SplitStyleState, StackProps, StaticConfigParsed, TamaguiInternalConfig, ThemeObject } from '../types';
+import type { ViewStyle } from '@tamagui/types-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';
+import { FlatTransforms } from './mergeTransform';
+declare type GetStyleResult = {
+    pseudos: PseudoStyles;
+    medias: Record<MediaQueryKey, ViewStyle>;
+    style: ViewStyle;
+    classNames: ClassNamesObject;
+    rulesToInsert: RulesToInsert;
+    viewProps: StackProps & Record<string, any>;
+    fontFamily: string | undefined;
+    mediaKeys: string[];
+};
+declare type GetStyleState = {
+    style: ViewStyle;
+    usedKeys: Record<string, number>;
+    classNames: ClassNamesObject;
+    flatTransforms: FlatTransforms;
+    staticConfig: StaticConfigParsed;
+    theme: ThemeParsed;
+    props: Record<string, any>;
+    viewProps: Record<string, any>;
+    state: SplitStyleState;
+    conf: TamaguiInternalConfig;
+    languageContext?: FontLanguageProps;
+    avoidDefaultProps?: boolean;
+    avoidMergeTransform?: boolean;
+};
 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, defaultClassNames?: any, debug?: DebugProp) => {
-    pseudos: PseudoStyles;
-    medias: Record<MediaKeys, ViewStyle>;
-    style: ViewStyle;
-    classNames: ClassNamesObject;
-    rulesToInsert: [string, string][] | null;
-    viewProps: StackProps;
-};
+}, staticConfig: StaticConfigParsed, theme: ThemeParsed, state: SplitStyleState, parentSplitStyles?: GetStyleResult | null, languageContext?: LanguageContextType, elementType?: string, debug?: DebugProp) => GetStyleResult;
 export declare const PROP_SPLIT = "-";
-export declare const pseudoCNInverse: {
-    hover: string;
-    focus: string;
-    press: string;
-};
 export declare const getSplitStyles: StyleSplitter;
-export declare const getSubStyle: (styleIn: Object, staticConfig: StaticConfigParsed, theme: ThemeObject, props: any, state: SplitStyleState, conf: TamaguiInternalConfig, avoidDefaultProps?: boolean) => ViewStyle;
+export declare const getSubStyle: (styleState: GetStyleState, subKey: string, styleIn: Object, avoidDefaultProps?: boolean, avoidMergeTransform?: boolean) => ViewStyle;
 export declare const insertSplitStyles: StyleSplitter;
 export declare const useSplitStyles: StyleSplitter;
 export {};

package/types/helpers/getStylesAtomic.d.ts

@@ -1,17 +1,18 @@
+/**
+ * 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';
+import type { TextStyle, ViewStyle } from '@tamagui/types-react-native';
 import { PseudoDescriptor } from './pseudoDescriptors';
-export declare type ViewStyleWithPseudos = ViewStyle & {
-    hoverStyle?: ViewStyle;
-    pressStyle?: ViewStyle;
-    focusStyle?: ViewStyle;
+declare type ViewOrTextStyle = ViewStyle | TextStyle;
+export declare type ViewStyleWithPseudos = ViewOrTextStyle & {
+    hoverStyle?: ViewOrTextStyle;
+    pressStyle?: ViewOrTextStyle;
+    focusStyle?: ViewOrTextStyle;
 };
 export declare function getStylesAtomic(stylesIn: ViewStyleWithPseudos): StyleObject[];
-export declare function getAtomicStyle(style: ViewStyle, pseudo?: PseudoDescriptor): 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

@@ -1,7 +1,5 @@
-export declare function getVariantExtras(props: any, theme?: any, defaultProps?: any, avoidDefaultProps?: boolean): {
-    fonts: import("..").GenericFonts;
-    tokens: import("..").CreateTokens<import("..").Variable<any>>;
-    theme: any;
-    props: any;
-};
+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 getAllSelectors: () => Record<string, string>;
+export declare const getAllRules: () => string[];
 export declare const getAllTransforms: () => {};
 export declare function updateInserted(): void;
-export declare function updateInsertedCache(identifier: string, rule: string): boolean;
-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

@@ -1,5 +1,5 @@
 import { StaticConfig } from '../types';
-export declare function isTamaguiComponent<A extends any>(comp: A, name?: string): comp is A & {
+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, name?: string) => 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

package/types/helpers/mergeProps.d.ts

@@ -1,2 +1,17 @@
-export declare const mergeProps: (a: Object, b: Object, leaveOutClassNames?: boolean) => readonly [Record<string, string>, Record<string, string>];
+/**
+ * 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 AnyRecord = Record<string, any>;
+export declare const mergeProps: (a: Object, b: Object, leaveOutClassNames?: boolean, inverseShorthands?: AnyRecord) => readonly [AnyRecord, AnyRecord];
+export {};
 //# sourceMappingURL=mergeProps.d.ts.map

package/types/helpers/mergeTransform.d.ts

@@ -1,7 +1,9 @@
-import { ViewStyle } from 'react-native';
+import type { ViewStyle } from '@tamagui/types-react-native';
+export declare type FlatTransforms = Record<string, any>;
 export declare const mergeTransform: (obj: ViewStyle, key: string, val: any, backwards?: boolean) => void;
-export declare const invertMapTransformKeys: {
-    translateX: string;
-    translateY: string;
+export declare const mergeTransforms: (obj: ViewStyle, flatTransforms: FlatTransforms, backwards?: boolean) => void;
+export declare const mapTransformKeys: {
+    x: string;
+    y: string;
 };
 //# sourceMappingURL=mergeTransform.d.ts.map

package/types/helpers/normalizeValueWithProperty.d.ts

@@ -1,2 +1,7 @@
+/**
+ * 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;
+export declare function reverseMapClassNameToValue(key: string, className: string): any;
 //# sourceMappingURL=normalizeValueWithProperty.d.ts.map

package/types/helpers/pseudoDescriptors.d.ts

@@ -1,16 +1,10 @@
-export declare const pseudoDescriptors: {
-    readonly hoverStyle: {
-        readonly name: "hover";
-        readonly priority: 1;
-    };
-    readonly pressStyle: {
-        readonly name: "active";
-        readonly priority: 2;
-    };
-    readonly focusStyle: {
-        readonly name: "focus";
-        readonly priority: 3;
-    };
+export declare const pseudoDescriptors: Record<'hoverStyle' | 'pressStyle' | 'focusStyle' | 'enterStyle' | 'exitStyle', PseudoDescriptor>;
+export declare type PseudoDescriptor = {
+    name: string;
+    priority: number;
+    stateKey?: string;
+};
+export declare type PseudoDescriptors = {
+    [Key in keyof typeof pseudoDescriptors]: PseudoDescriptor;
 };
-export declare type PseudoDescriptor = typeof pseudoDescriptors[keyof typeof pseudoDescriptors];
 //# sourceMappingURL=pseudoDescriptors.d.ts.map

package/types/helpers/registerCSSVariable.d.ts

@@ -1,5 +1,5 @@
 import { Variable } from '../createVariable';
-export declare const registerCSSVariable: (v: Variable) => string;
-export declare const tokensValueToVariable: Map<string, Variable<any>>;
-export declare const tokenRules: Set<string>;
+export declare const registerCSSVariable: (v: Variable) => void;
+export declare const variableToCSS: (v: Variable) => string;
+export declare const tokensValueToVariable: Map<any, any>;
 //# sourceMappingURL=registerCSSVariable.d.ts.map

package/types/helpers/themeable.d.ts

@@ -1,12 +1,12 @@
 import { ThemeName } from '../types';
-export declare type ThemeableProps = {
-    theme?: ThemeName | string | null;
+export interface ThemeableProps {
+    theme?: ThemeName | null;
     themeInverse?: boolean;
-};
+    componentName?: string;
+    debug?: boolean | 'verbose';
+    reset?: boolean;
+}
 export declare function themeable<Component extends (props: any) => any>(component: Component, opts?: {
     componentName?: string;
-}): Component extends (props: infer P) => infer R ? (props: Omit<P, "theme" | "themeInverse"> & {
-    theme?: ThemeName | null | undefined;
-    themeInverse?: boolean | undefined;
-}) => R : unknown;
+}): Component extends (props: infer P) => infer R ? (props: Omit<P, "theme" | "themeInverse"> & ThemeableProps) => R : unknown;
 //# sourceMappingURL=themeable.d.ts.map

package/types/helpers/themes.d.ts

@@ -0,0 +1,4 @@
+import { CreateTamaguiProps } from '../types';
+export declare function ensureThemeVariable(theme: any, key: string): void;
+export declare function proxyThemeToParents(themeName: string, theme: any, themes: CreateTamaguiProps['themes']): any;
+//# sourceMappingURL=themes.d.ts.map