@hanzogui/web 2.0.0

package/src/views/ThemeDebug.tsx

@@ -0,0 +1,95 @@
+import { useDidFinishSSR } from '@hanzogui/use-did-finish-ssr'
+import { useEffect } from 'react'
+import { createPortal } from 'react-dom'
+import { getThemeState } from '../hooks/useThemeState'
+import type { ThemeProps, ThemeState } from '../types'
+
+let node
+
+export function ThemeDebug({
+  themeState,
+  themeProps,
+  children,
+}: {
+  themeState: ThemeState
+  themeProps: ThemeProps
+  children: any
+}) {
+  if (process.env.NODE_ENV === 'development') {
+    const isHydrated = useDidFinishSSR()
+
+    if (process.env.NODE_ENV === 'development' && typeof document !== 'undefined') {
+      if (!node) {
+        node = document.createElement('div')
+        node.style.height = '200px'
+        node.style.overflowY = 'scroll'
+        node.style.position = 'fixed'
+        node.style.zIndex = 10000000
+        node.style.bottom = '30px'
+        node.style.left = '30px'
+        node.style.right = '30px'
+        node.style.display = 'flex'
+        node.style.border = '1px solid #888'
+        node.style.flexDirection = 'row'
+        node.style.background = 'var(--background)'
+      }
+    }
+
+    useEffect(() => {
+      document.body.appendChild(node)
+    }, [])
+
+    if (themeProps['disable-child-theme'] || !isHydrated) {
+      return children
+    }
+
+    const parentState = themeState.parentId ? getThemeState(themeState.parentId) : null
+
+    // hsla(0, 0%, 9%, 1)
+
+    return (
+      <>
+        {createPortal(
+          <code
+            style={{
+              whiteSpace: 'pre',
+              maxWidth: 250,
+              overflow: 'auto',
+              padding: 5,
+            }}
+          >
+            &lt;Theme {themeState.id} /&gt;&nbsp;
+            {JSON.stringify(
+              {
+                name: themeState.name,
+                color1: themeState.theme.color1.val,
+                parentId: themeState.parentId,
+                // inverses: themeState.inverses,
+                isNew: themeState.isNew,
+                themeProps: {
+                  name: themeProps.name,
+                  componentName: themeProps.componentName,
+                  reset: themeProps.reset,
+                },
+                parentState: {
+                  name: parentState?.name,
+                  isNew: parentState?.isNew,
+                },
+              },
+              null,
+              2
+            )}
+          </code>,
+          node
+        )}
+
+        <div style={{ color: 'red' }}>{themeState.id}</div>
+
+        {children}
+      </>
+    )
+  }
+  return children
+}
+
+ThemeDebug['displayName'] = 'ThemeDebug'

package/src/views/ThemeProvider.tsx

@@ -0,0 +1,45 @@
+import { useIsomorphicLayoutEffect } from '@hanzogui/constants'
+import { useId } from 'react'
+import { getSetting } from '../config'
+import { THEME_CLASSNAME_PREFIX } from '../constants/constants'
+import type { ThemeProviderProps } from '../types'
+import { Theme } from './Theme'
+
+export const ThemeProvider = (props: ThemeProviderProps) => {
+  'use no memo'
+
+  const addThemeClassName = getSetting('addThemeClassName')
+
+  // ensure theme is attached to root body node as well to work with modals by default
+  if (process.env.HANZO_GUI_TARGET === 'web') {
+    useIsomorphicLayoutEffect(() => {
+      if (addThemeClassName === false) return
+      const cn = `${THEME_CLASSNAME_PREFIX}${props.defaultTheme}`
+      const target =
+        getSetting('addThemeClassName') === 'html'
+          ? document.documentElement
+          : document.body
+      target.classList.add(cn)
+      return () => {
+        target.classList.remove(cn)
+      }
+    }, [props.defaultTheme, addThemeClassName])
+  }
+
+  // we completely disable the className here if its set to any value, 'root', 'body', or false
+  // because in all cases we are putting the classname elsewhere
+  // if its undefined, then the default behavior applies and we use the className here
+  const forceClassName = addThemeClassName === undefined
+
+  return (
+    <Theme
+      className={props.className}
+      name={props.defaultTheme}
+      forceClassName={forceClassName}
+      // @ts-expect-error
+      _isRoot={useId}
+    >
+      {props.children}
+    </Theme>
+  )
+}

package/src/views/View.tsx

@@ -0,0 +1,25 @@
+import { validStyles } from '@hanzogui/helpers'
+
+import { createComponent } from '../createComponent'
+import type {
+  StackNonStyleProps,
+  StackStyle,
+  StackStyleBase,
+  GuiElement,
+} from '../types'
+
+export type View = GuiElement
+export type ViewNonStyleProps = StackNonStyleProps
+export type ViewStylePropsBase = StackStyleBase
+export type ViewStyle = StackStyle
+export type ViewProps = ViewNonStyleProps & ViewStyle
+
+export const View = createComponent<
+  ViewProps,
+  View,
+  ViewNonStyleProps,
+  ViewStylePropsBase
+>({
+  acceptsClassName: true,
+  validStyles,
+})

package/tsconfig.json

@@ -0,0 +1,44 @@
+{
+  "extends": "../../../tsconfig.json",
+  "compilerOptions": {
+    "composite": true,
+    "strict": true
+  },
+  "references": [
+    {
+      "path": "../../packages/timer"
+    },
+    {
+      "path": "../compose-refs"
+    },
+    {
+      "path": "../constants"
+    },
+    {
+      "path": "../helpers"
+    },
+    {
+      "path": "../normalize-css-color"
+    },
+    {
+      "path": "../types"
+    },
+    {
+      "path": "../use-did-finish-ssr"
+    },
+    {
+      "path": "../use-event"
+    },
+    {
+      "path": "../use-force-update"
+    }
+  ],
+  "exclude": [
+    "types",
+    "dist",
+    "**/__tests__",
+    "vitest.config.*",
+    "**/*.test.ts",
+    "**/*.test-d.ts"
+  ]
+}

package/tsconfig.test.json

@@ -0,0 +1,9 @@
+{
+  "extends": "../../../tsconfig.json",
+  "compilerOptions": {
+    "strict": true,
+    "noEmit": true
+  },
+  "include": ["src/**/*.test-d.ts", "src/**/*.ts", "src/**/*.tsx"],
+  "exclude": ["types", "dist", "node_modules"]
+}

package/types/Gui.d.ts

@@ -0,0 +1,15 @@
+import * as Helpers from '@hanzogui/helpers';
+export declare const Gui: {
+    Helpers: typeof Helpers;
+    get mediaState(): {
+        [x: string]: boolean;
+        [x: number]: boolean;
+    };
+    get config(): import("./types").GuiInternalConfig;
+    get insertedRules(): string[];
+    get allSelectors(): Record<string, string>;
+    get identifierToValue(): Map<string, any>;
+} | undefined;
+export declare const getValueFromIdentifier: (identifier: string) => any;
+export declare const setIdentifierValue: (identifier: string, value: any) => void;
+//# sourceMappingURL=Gui.d.ts.map

package/types/_withStableStyle.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+/** internal: this is for hanzo-gui babel plugin usage only */
+export declare const _withStableStyle: (Component: any, createStyle: (theme: any, expressions: any[]) => object) => React.NamedExoticComponent<Omit<any, "ref"> & React.RefAttributes<unknown>>;
+//# sourceMappingURL=_withStableStyle.d.ts.map

package/types/config.d.ts

@@ -0,0 +1,72 @@
+import type { AnimationDriver, GenericGuiSettings, GuiInternalConfig, Token, Tokens, TokensMerged } from './types';
+export declare const getSetting: <Key extends keyof GenericGuiSettings>(key: Key) => GenericGuiSettings[Key];
+export declare const setConfig: (next: GuiInternalConfig) => void;
+export declare const setConfigFont: (name: string, font: any, fontParsed: any) => void;
+export declare const getConfig: () => GuiInternalConfig;
+export declare const getConfigMaybe: () => GuiInternalConfig | null;
+export declare function setTokens(_: TokensMerged): void;
+export declare const getTokens: ({ prefixed, }?: {
+    /**
+     * Force either with $ or without $ prefix
+     */
+    prefixed?: boolean;
+}) => TokensMerged;
+export declare const getTokenObject: (value: Token, group?: keyof Tokens) => import("./types").Variable<any>;
+export declare const getToken: (value: Token, group?: keyof Tokens, useVariable?: boolean) => any;
+export declare const getTokenValue: (value: Token | "unset" | "auto", group?: keyof Tokens) => any;
+/**
+ * Note: this is the same as `getTokens`
+ */
+export declare const useTokens: ({ prefixed, }?: {
+    /**
+     * Force either with $ or without $ prefix
+     */
+    prefixed?: boolean;
+}) => TokensMerged;
+export declare const getThemes: () => {
+    [x: string]: {
+        [x: string]: import("./types").Variable<any> | import("./types").Variable<string> | import("./types").Variable<number> | import("./types").Variable<import("./types").VariableValGeneric> | import("./types").Variable<import("./types").PxValue>;
+        background?: import("./types").Variable<any> | import("./types").Variable<string> | import("./types").Variable<undefined> | undefined;
+        backgroundHover?: import("./types").Variable<any> | import("./types").Variable<string> | import("./types").Variable<undefined> | undefined;
+        backgroundPress?: import("./types").Variable<any> | import("./types").Variable<string> | import("./types").Variable<undefined> | undefined;
+        backgroundFocus?: import("./types").Variable<any> | import("./types").Variable<string> | import("./types").Variable<undefined> | undefined;
+        color?: import("./types").Variable<any> | import("./types").Variable<string> | import("./types").Variable<undefined> | undefined;
+        colorHover?: import("./types").Variable<any> | import("./types").Variable<string> | import("./types").Variable<undefined> | undefined;
+        colorPress?: import("./types").Variable<any> | import("./types").Variable<string> | import("./types").Variable<undefined> | undefined;
+        colorFocus?: import("./types").Variable<any> | import("./types").Variable<string> | import("./types").Variable<undefined> | undefined;
+        borderColor?: import("./types").Variable<any> | import("./types").Variable<string> | import("./types").Variable<undefined> | undefined;
+        borderColorHover?: import("./types").Variable<any> | import("./types").Variable<string> | import("./types").Variable<undefined> | undefined;
+        borderColorPress?: import("./types").Variable<any> | import("./types").Variable<string> | import("./types").Variable<undefined> | undefined;
+        borderColorFocus?: import("./types").Variable<any> | import("./types").Variable<string> | import("./types").Variable<undefined> | undefined;
+        shadowColor?: import("./types").Variable<any> | import("./types").Variable<string> | import("./types").Variable<undefined> | undefined;
+        shadowColorHover?: import("./types").Variable<any> | import("./types").Variable<string> | import("./types").Variable<undefined> | undefined;
+        shadowColorPress?: import("./types").Variable<any> | import("./types").Variable<string> | import("./types").Variable<undefined> | undefined;
+        shadowColorFocus?: import("./types").Variable<any> | import("./types").Variable<string> | import("./types").Variable<undefined> | undefined;
+    };
+};
+export declare const updateConfig: (key: string, value: any) => void;
+export declare const getFont: (name: string) => import("./types").GenericFont<string | number | symbol>;
+type DevConfig = {
+    visualizer?: boolean | {
+        key?: string;
+        delay?: number;
+    };
+};
+export declare let devConfig: DevConfig | undefined;
+export declare function setupDev(conf: DevConfig): void;
+/**
+ * Dynamically load an animation driver at runtime.
+ * Useful for lazy loading heavier animation drivers after initial page load.
+ *
+ * @example
+ * ```tsx
+ * // import loadAnimationDriver from gui
+ * // import createAnimations from your preferred driver (e.g. animations-reanimated)
+ *
+ * const driver = createAnimations({ bouncy: { type: 'spring', damping: 10 } })
+ * loadAnimationDriver('spring', driver)
+ * ```
+ */
+export declare function loadAnimationDriver(name: string, driver: AnimationDriver): void;
+export {};
+//# sourceMappingURL=config.d.ts.map

package/types/constants/accessibilityDirectMap.d.ts

@@ -0,0 +1,6 @@
+export declare const accessibilityDirectMap: Record<string, string>;
+export declare const webToNativeAccessibilityDirectMap: Record<string, string>;
+export declare const nativeAccessibilityValue: Record<string, string>;
+export declare const nativeAccessibilityState: Record<string, string>;
+export declare const accessibilityWebRoleToNativeRole: Record<string, string>;
+//# sourceMappingURL=accessibilityDirectMap.d.ts.map

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

@@ -0,0 +1,6 @@
+export declare const accessibilityDirectMap: {};
+export declare const webToNativeAccessibilityDirectMap: {};
+export declare const nativeAccessibilityValue: {};
+export declare const nativeAccessibilityState: {};
+export declare const accessibilityWebRoleToNativeRole: {};
+//# sourceMappingURL=accessibilityDirectMap.native.d.ts.map

package/types/constants/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const THEME_NAME_SEPARATOR = "_";
+export declare const THEME_CLASSNAME_PREFIX = "t_";
+export declare const FONT_DATA_ATTRIBUTE_NAME = "data-gui-font";
+export declare const MISSING_THEME_MESSAGE: string;
+//# sourceMappingURL=constants.d.ts.map

package/types/constants/isDevTools.d.ts

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

package/types/contexts/ComponentContext.d.ts

@@ -0,0 +1,4 @@
+import type { ComponentContextI } from '../types';
+export declare const ComponentContext: import("../types").StyledContext<ComponentContextI>;
+export declare const useConfiguration: () => ComponentContextI;
+//# sourceMappingURL=ComponentContext.d.ts.map

package/types/contexts/GroupContext.d.ts

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

package/types/createComponent.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { StaticConfig, GuiComponent, GuiComponentState, GuiElement } from './types';
+type ComponentSetState = React.Dispatch<React.SetStateAction<GuiComponentState>>;
+export declare const componentSetStates: Set<ComponentSetState>;
+export declare function createComponent<ComponentPropTypes extends Record<string, any> = {}, Ref extends GuiElement = GuiElement, BaseProps = never, BaseStyles extends object = never>(staticConfig: StaticConfig): GuiComponent<ComponentPropTypes, Ref, BaseProps, BaseStyles, {}>;
+export {};
+//# sourceMappingURL=createComponent.d.ts.map

package/types/createFont.d.ts

@@ -0,0 +1,3 @@
+import type { GenericFont } from './types';
+export declare const createFont: <A extends GenericFont>(font: A) => A;
+//# sourceMappingURL=createFont.d.ts.map

package/types/createGui.d.ts

@@ -0,0 +1,3 @@
+import type { CreateGuiProps, InferGuiConfig } from './types';
+export declare function createGui<Conf extends CreateGuiProps>(configIn: Conf): InferGuiConfig<Conf>;
+//# sourceMappingURL=createGui.d.ts.map

package/types/createShorthands.d.ts

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

package/types/createTokens.d.ts

@@ -0,0 +1,22 @@
+import type { CreateTokens, Variable } from './types';
+export declare function createTokens<T extends CreateTokens>(tokens: T): MakeTokens<T>;
+type NormalizeTokens<A, Type = A[keyof A]> = {
+    [Key in keyof A as Key extends number ? `${Key}` : Key]: Variable<Type>;
+};
+type MakeTokens<T extends CreateTokens> = T extends {
+    color?: infer E;
+    space?: infer F;
+    size?: infer G;
+    radius?: infer H;
+    zIndex?: infer J;
+} ? {
+    color: NormalizeTokens<E, string>;
+    space: NormalizeTokens<F, number>;
+    size: NormalizeTokens<G, number>;
+    radius: NormalizeTokens<H, number>;
+    zIndex: NormalizeTokens<J, number>;
+} & Omit<{
+    [key in keyof T]: NormalizeTokens<T[key]>;
+}, 'color' | 'space' | 'size' | 'radius' | 'zIndex'> : never;
+export {};
+//# sourceMappingURL=createTokens.d.ts.map

package/types/createVariable.d.ts

@@ -0,0 +1,22 @@
+import type { PxValue, TokenCategories, Variable } from './types';
+type VariableIn<A = any> = Pick<Variable<A>, 'key' | 'name' | 'val'>;
+export declare const createVariable: <A extends string | number | Variable = any>(props: VariableIn<A>, skipHash?: boolean) => Variable<A>;
+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 | any, group?: TokenCategories): any;
+export declare const setDidGetVariableValue: (val: boolean) => boolean;
+export declare const didGetVariableValue: () => boolean;
+export declare function getVariableValue(v: Variable | any, group?: TokenCategories): any;
+export declare function getVariableName(v: Variable | any): any;
+export declare function getVariableVariable(v: Variable | string | undefined): string | undefined;
+export declare const createCSSVariable: (nameProp: string, includeVar?: boolean) => string;
+/**
+ * Helper function to mark a token value as needing px units.
+ * Usage: px(100) creates a token that will become "100px" on web, 100 on native.
+ *
+ * @param value - The numeric value
+ * @returns A special object that indicates this value needs px units
+ */
+export declare function px(value: number): PxValue;
+export {};
+//# sourceMappingURL=createVariable.d.ts.map

package/types/createVariables.d.ts

@@ -0,0 +1,10 @@
+import type { Variable } from './types';
+type DeepTokenObject<Val extends string | number = any> = {
+    [key: string]: Val | DeepTokenObject<Val>;
+};
+export 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>(tokens: A, parentPath?: string, isFont?: boolean) => DeepVariableObject<A>;
+export {};
+//# sourceMappingURL=createVariables.d.ts.map

package/types/defaultComponentState.d.ts

@@ -0,0 +1,5 @@
+import type { GuiComponentState } from './types';
+export declare const defaultComponentState: GuiComponentState;
+export declare const defaultComponentStateMounted: GuiComponentState;
+export declare const defaultComponentStateShouldEnter: GuiComponentState;
+//# sourceMappingURL=defaultComponentState.d.ts.map

package/types/eventHandling.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Web event handling - maps RN-style events to DOM events
+ */
+import type { GuiComponentEvents } from './interfaces/GuiComponentEvents';
+type EventKeys = keyof GuiComponentEvents;
+type EventLikeObject = {
+    [key in EventKeys]?: any;
+};
+export declare function getWebEvents<E extends EventLikeObject>(events: E, webStyle?: boolean): {
+    [x: string]: any;
+    onMouseEnter: any;
+    onMouseLeave: any;
+    onMouseDown: any;
+    onMouseUp: any;
+    onTouchStart: any;
+    onTouchEnd: any;
+    onFocus: any;
+    onBlur: any;
+};
+export declare function wrapWithGestureDetector(content: any, _gesture: any, _stateRef: {
+    current: any;
+}, _isHOC?: boolean): any;
+export declare function useEvents(_events: any, _viewProps: any, _stateRef: {
+    current: any;
+}, _staticConfig: any, _isHOC?: boolean, _isInsideNativeMenu?: boolean): null;
+export {};
+//# sourceMappingURL=eventHandling.d.ts.map

package/types/eventHandling.native.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Native event handling - uses RNGH when available, falls back to usePressability
+ */
+import type { StaticConfig, GuiComponentStateRef } from './types';
+export declare function getWebEvents(): {};
+export declare function useEvents(events: any, viewProps: any, stateRef: {
+    current: GuiComponentStateRef;
+}, staticConfig: StaticConfig, isHOC?: boolean, isInsideNativeMenu?: boolean): any;
+export declare function wrapWithGestureDetector(content: any, gesture: any, stateRef: {
+    current: GuiComponentStateRef;
+}, isHOC?: boolean): any;
+//# sourceMappingURL=eventHandling.native.d.ts.map

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

@@ -0,0 +1,7 @@
+export declare const groupEnd: () => void;
+export declare const groupCollapsed: {
+    (...data: any[]): void;
+    (message?: any, ...optionalParams: any[]): void;
+    (message?: any, ...optionalParams: any[]): void;
+};
+//# sourceMappingURL=consoleLog.native.d.ts.map

package/types/helpers/createDesignSystem.d.ts

@@ -0,0 +1,47 @@
+import type { CreateGuiProps, Variable } from '../types';
+type ThemeConfig = {
+    cssRuleSets: string[];
+    getThemeRulesSets: () => string[];
+};
+declare function getFontPropertyDeclarations(fontParsed: any, tokenKey?: string): string[];
+export { getFontPropertyDeclarations };
+/**
+ * Generates CSS for tokens - registers CSS variables and builds declaration strings
+ */
+export declare function createTokenCSS(tokens: Record<string, Record<string, Variable>>, shouldTokenCategoryHaveUnits: (category: string) => boolean): string[];
+/**
+ * Generates CSS for fonts
+ */
+export declare function createFontCSS(fontsParsed: Record<string, any> | undefined, registerFontVariables: (fontParsed: any) => string[]): Record<string, {
+    name: string;
+    declarations: string[];
+    language?: string;
+    fontParsed: any;
+}>;
+/**
+ * Builds CSS rulesets from declarations
+ */
+export declare function buildCSSRuleSets(declarations: string[], fontDeclarations: Record<string, {
+    name: string;
+    declarations: string[];
+    language?: string;
+    fontParsed: any;
+}>, defaultFontToken?: string): string[];
+/**
+ * Generates theme CSS rules
+ */
+export declare function createThemeCSS(dedupedThemes: Array<{
+    names: string[];
+    theme: any;
+}>, configIn: CreateGuiProps): string[];
+/**
+ * Gets all generated CSS - design system + runtime styles
+ */
+export declare function getCSS(themeConfig: ThemeConfig, opts: {
+    separator?: string;
+    sinceLastCall?: boolean;
+    exclude?: "themes" | "design-system" | string | null;
+} | undefined, lastIndex: {
+    value: number;
+}): string;
+//# sourceMappingURL=createDesignSystem.d.ts.map

package/types/helpers/createMediaStyle.d.ts

@@ -0,0 +1,5 @@
+import type { IsMediaType, MediaQueries, MediaStyleObject, StyleObject } from '../types';
+export declare const MEDIA_SEP = "_";
+export declare function resetMediaStyleCache(): void;
+export declare const createMediaStyle: (styleObject: StyleObject, mediaKeyIn: string, mediaQueries: MediaQueries, type: IsMediaType, negate?: boolean, priority?: number) => MediaStyleObject;
+//# sourceMappingURL=createMediaStyle.d.ts.map

package/types/helpers/createStyledContext.d.ts

@@ -0,0 +1,3 @@
+import type { StyledContext } from '../types';
+export declare const createStyledContext: <VariantProps extends Record<string, any>>(defaultValues?: VariantProps, namespace?: string) => StyledContext<VariantProps>;
+//# sourceMappingURL=createStyledContext.d.ts.map

package/types/helpers/defaultAnimationDriver.d.ts

@@ -0,0 +1,3 @@
+import type { AnimationDriver } from '../types';
+export declare const defaultAnimationDriver: AnimationDriver;
+//# sourceMappingURL=defaultAnimationDriver.d.ts.map

package/types/helpers/defaultOffset.d.ts

@@ -0,0 +1,5 @@
+export declare const defaultOffset: {
+    height: number;
+    width: number;
+};
+//# sourceMappingURL=defaultOffset.d.ts.map

package/types/helpers/expandStyle.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Some parts adapted from react-native-web
+ * Copyright (c) Nicolas Gallagher licensed under the MIT license.
+ */
+import type { PropMappedValue } from '../types';
+export declare function expandStyle(key: string, value: any): PropMappedValue;
+//# sourceMappingURL=expandStyle.d.ts.map

package/types/helpers/expandStyles.d.ts

@@ -0,0 +1,2 @@
+export declare function fixStyles(style: Record<string, any>): void;
+//# sourceMappingURL=expandStyles.d.ts.map

package/types/helpers/getCSSStylesAtomic.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Some parts adapted from react-native-web
+ * Copyright (c) Nicolas Gallagher licensed under the MIT license.
+ */
+import type { StyleObject } from '@hanzogui/helpers';
+import type { ViewStyleWithPseudos } from '../types';
+import type { PseudoDescriptor } from './pseudoDescriptors';
+export declare function getCSSStylesAtomic(style: ViewStyleWithPseudos): StyleObject[];
+export declare const getStyleAtomic: (style: ViewStyleWithPseudos, pseudo?: PseudoDescriptor) => StyleObject[];
+export declare function styleToCSS(style: Record<string, any>): void;
+//# sourceMappingURL=getCSSStylesAtomic.d.ts.map

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

@@ -0,0 +1,4 @@
+export declare const getCSSStylesAtomic: () => void;
+export declare const getStyleAtomic: () => void;
+export declare const styleToCSS: () => void;
+//# sourceMappingURL=getCSSStylesAtomic.native.d.ts.map

package/types/helpers/getDefaultProps.d.ts

@@ -0,0 +1,3 @@
+import type { StaticConfig } from '../types';
+export declare const getDefaultProps: (staticConfig: StaticConfig, propsComponentName?: string) => Record<string, any> | undefined;
+//# sourceMappingURL=getDefaultProps.d.ts.map

package/types/helpers/getDynamicVal.d.ts

@@ -0,0 +1,16 @@
+export declare function getOppositeScheme(scheme: string): "light" | "dark";
+/**
+ * Check if a style key is a color property that supports DynamicColorIOS.
+ */
+export declare function isColorStyleKey(key: string): boolean;
+export declare function getDynamicVal({ scheme, val, oppositeVal, }: {
+    scheme: string;
+    val: string;
+    oppositeVal: string;
+}): {
+    dynamic: {
+        [x: string]: string;
+    };
+};
+export declare function extractValueFromDynamic(val: any, scheme: string): any;
+//# sourceMappingURL=getDynamicVal.d.ts.map

package/types/helpers/getExpandedShorthands.d.ts

@@ -0,0 +1,7 @@
+import type { Shorthands } from '../types';
+/**
+ * @deprecated use useProps instead
+ */
+export declare function getExpandedShorthands<A extends object>(props: A): Omit<A, keyof Shorthands>;
+export declare function getExpandedShorthand(propKey: string, props: object): any;
+//# sourceMappingURL=getExpandedShorthands.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/getGroupPropParts.d.ts

@@ -0,0 +1,7 @@
+export type GroupParts = {
+    name: string;
+    pseudo?: string;
+    media?: string;
+};
+export declare function getGroupPropParts(groupProp: string): GroupParts;
+//# sourceMappingURL=getGroupPropParts.d.ts.map