@hanzogui/web 3.0.6 → 4.4.0

package/types/helpers/isActivePlatform.d.ts

@@ -1,2 +1,16 @@
+/**
+ * Returns the specificity bump for a platform media key so that more specific
+ * platform selectors reliably override more general ones regardless of the order
+ * props are declared.
+ *
+ * Cascade (low -> high importance):
+ *   $platform-native / $platform-web         -> bump 0  (widest)
+ *   $platform-android / $platform-ios        -> bump 1  (OS-specific)
+ *   $platform-tv                             -> bump 2  (TV subset of Android/iOS)
+ *   $platform-androidtv / $platform-tvos     -> bump 3  (most specific)
+ *
+ * @param mediaKeyShort - Platform media key without the leading '$' (e.g. 'platform-tv', 'platform-androidtv')
+ */
+export declare function getPlatformSpecificityBump(mediaKeyShort: string): number;
 export declare function isActivePlatform(key: string): boolean;
 //# sourceMappingURL=isActivePlatform.d.ts.map

package/types/helpers/mainThreadPressEvents.d.ts

@@ -1,2 +1,2 @@
-export declare function useMainThreadPressEvents(_events: any, _viewProps: any, _enabled?: boolean): void;
+export declare function useMainThreadPressEvents(_events: any, _viewProps: any, _enabled?: boolean, _debugName?: string | null): void;
 //# sourceMappingURL=mainThreadPressEvents.d.ts.map

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

@@ -1,10 +1,9 @@
 /**
- * Fallback press handling using React Native's usePressability
- * Split into separate file to avoid deep import warnings when RNGH is enabled
+ * Fallback press handling when RNGH is not available.
  *
- * NOTE: This hook must be called unconditionally in the parent to avoid
- * rules of hooks violations when disabled toggles. The `enabled` param
- * controls whether the pressability events are actually applied.
+ * Implements the responder-based press detection that usePressability provides,
+ * without the deep RN internal import. Supports pressIn/pressOut delays,
+ * long press, cancellation, and min press duration.
  */
-export declare function useMainThreadPressEvents(events: any, viewProps: any, enabled?: boolean): void;
+export declare function useMainThreadPressEvents(events: any, viewProps: any, enabled?: boolean, debugName?: string | null): void;
 //# sourceMappingURL=mainThreadPressEvents.native.d.ts.map

package/types/helpers/parseNativeStyle.d.ts

@@ -5,7 +5,7 @@
  * supports: backgroundImage (linear-gradient), boxShadow, textShadow
  * filter has no RN object equivalent, returns undefined (falls back to string)
  *
- * only called inside process.env.HANZO_GUI_TARGET === 'native' checks,
+ * only called inside process.env.GUI_TARGET === 'native' checks,
  * so this code is dead-code-eliminated on web builds.
  */
 type TokenMap = Map<string, any>;

package/types/helpers/skipProps.d.ts

@@ -1,5 +1,5 @@
 /**
- * These are props that dont pass down below Hanzo GUI styled components
+ * These are props that dont pass down below GUI styled components
  */
 export declare const skipProps: {
     untilMeasured: number;

package/types/interfaces/GuiComponentPropsBaseBase.d.ts

@@ -82,7 +82,7 @@ export type GuiComponentPropsBaseBase = {
     disableClassName?: boolean;
     /**
      * Adds some area outside the typical bounds of the component for touch actions to register.
-     * Hanzo GUI uses Pressable internally so it supports `number | Insets` rather than just `Insets`
+     * GUI uses Pressable internally so it supports `number | Insets` rather than just `Insets`
      */
     hitSlop?: number | Insets | null;
 };

package/types/styled.d.ts

@@ -30,7 +30,7 @@ export declare function styledHtml<Tag extends keyof HTMLElementTagNameMap, Vari
     context?: StyledContext;
 }): GuiComponent<TamaDefer, HTMLElementTagNameMap[Tag], GuiComponentPropsBase & HTMLElementSpecificProps<Tag>, HTMLElementStyleBase<Tag>, Variants extends undefined ? {} : AreVariantsUndefined<NonNullable<Variants>> extends true ? {} : GetVariantAcceptedValues<NonNullable<Variants>>, {}>;
 /**
- * styled() for creating Hanzo GUI components from other components.
+ * styled() for creating GUI components from other components.
  */
 declare function styled<ParentComponent extends StylableComponent, StyledConfig extends StaticConfigPublic, Variants extends VariantDefinitions<ParentComponent, StyledConfig>>(ComponentIn: ParentComponent, options?: Partial<InferStyledProps<ParentComponent, StyledConfig>> & {
     name?: string;

package/types/types.d.ts

@@ -123,7 +123,7 @@ export type GuiComponentPropsBaseBase = {
     disableClassName?: boolean;
     /**
      * Adds some area outside the typical bounds of the component for touch actions to register.
-     * Hanzo GUI uses Pressable internally so it supports `number | Insets` rather than just `Insets`
+     * GUI uses Pressable internally so it supports `number | Insets` rather than just `Insets`
      */
     hitSlop?: number | Insets | null;
     /**
@@ -242,7 +242,7 @@ export interface GuiElementMethods {
 }
 /**
  * Cross-platform element ref type. On web, includes GuiElementMethods
- * (measure, focus, blur) which Hanzo GUI adds at runtime. On native, View
+ * (measure, focus, blur) which GUI adds at runtime. On native, View
  * already has these via NativeMethods.
  */
 export type GuiElement = (HTMLElement & GuiElementMethods) | View;
@@ -594,14 +594,14 @@ type AutocompleteSpecificTokensSetting = boolean | 'except-special';
 export interface GenericGuiSettings {
     /**
      * When true, flexBasis will be set to 0 when flex is positive. This will be
-     * the default in v2 of Hanzo GUI alongside an alternative mode for web compat.
+     * the default in v2 of GUI alongside an alternative mode for web compat.
      */
     styleCompat?: 'react-native' | 'legacy';
     /**
-     * When true, Hanzo GUI will always prefer a more specific style prop over a
+     * When true, GUI will always prefer a more specific style prop over a
      * less specific one.
      *
-     * By default, Hanzo GUI processes all style props in order of definition on the
+     * By default, GUI processes all style props in order of definition on the
      * object. This is a bit strange to most people, but it gets around many
      * annoying issues with specificity. You can see our docs on this here:
      * https://gui.hanzo.ai/docs/intro/styles#style-order-is-important
@@ -648,12 +648,12 @@ export interface GenericGuiSettings {
      */
     autocompleteSpecificTokens?: AutocompleteSpecificTokensSetting;
     /**
-     * On iOS, this enables a mode where Hanzo GUI returns color values using
+     * On iOS, this enables a mode where GUI returns color values using
      * `DynamicColorIOS` This is a React Native built in feature, you can read the
      * docs here: https://reactnative.dev/docs/dynamiccolorios
      *
      * We're working to make this enabled by default without any setting, but
-     * Hanzo GUI themes support inversing and/or changing to light/dark at any point
+     * GUI themes support inversing and/or changing to light/dark at any point
      * in the tree. We haven't implemented support for either of these cases when
      * combined with this feature.
      *
@@ -690,7 +690,7 @@ export interface GenericGuiSettings {
     /**
      * If building a non-server rendered app, set this to true.
      *
-     * For SSR compatibility on the web, Hanzo GUI will render once with the settings
+     * For SSR compatibility on the web, GUI 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.
@@ -717,14 +717,14 @@ export interface GenericGuiSettings {
     /**
      * If you want to style your <body> tag to use theme CSS variables on web, you
      * must place the theme className onto the body element or above. This will do so.
-     * If disabled, Hanzo GUI will place the className onto the element rendered by
+     * If disabled, GUI will place the className onto the element rendered by
      * the GuiProvider
      *
      * @default html
      */
     addThemeClassName?: 'body' | 'html' | false;
     /**
-     * Sets the default position value for all Hanzo GUI components.
+     * Sets the default position value for all GUI components.
      * @default 'static'
      */
     defaultPosition?: 'static' | 'relative';
@@ -877,10 +877,14 @@ export type GroupMediaKeys = `$group-${GroupNames}` | `$group-${GroupNames}-${Pa
 export type WithMediaProps<A> = {
     [Key in MediaPropKeys | GroupMediaKeys | ThemeMediaKeys | PlatformMediaKeys]?: Key extends MediaPropKeys ? A & {
         [Key in PlatformMediaKeys]?: AddWebOnlyStyleProps<A>;
-    } : Key extends `$platform-web` ? AddWebOnlyStyleProps<A> : A;
+    } : Key extends `$platform-web` ? AddWebOnlyStyleProps<A> & {
+        [Key in MediaPropKeys]?: AddWebOnlyStyleProps<A>;
+    } : A & {
+        [Key in MediaPropKeys]?: A;
+    };
 };
-type AddWebOnlyStyleProps<A> = {
-    [SubKey in keyof A | keyof CSSProperties]?: SubKey extends keyof CSSProperties ? CSSProperties[SubKey] : SubKey extends keyof A ? A[SubKey] : SubKey extends keyof WebOnlyValidStyleValues ? WebOnlyValidStyleValues[SubKey] : never;
+export type AddWebOnlyStyleProps<A> = Partial<CSSProperties> & Partial<WebOnlyValidStyleValues> & {
+    [K in Exclude<keyof A, keyof CSSProperties>]?: A[K];
 };
 export type WebOnlyValidStyleValues = {
     position: '-webkit-sticky';
@@ -1060,7 +1064,7 @@ export type PseudoStyles = {
     enterStyle?: ViewStyle;
     exitStyle?: ViewStyle;
 };
-export type AllPlatforms = 'web' | 'native' | 'android' | 'ios';
+export type AllPlatforms = 'web' | 'native' | 'android' | 'ios' | 'tv' | 'androidtv' | 'tvos';
 type MaybeOmitLonghands<A> = OnlyShorthandStyleProps extends true ? Omit<A, ShorthandLonghandProps> : A;
 export type WithThemeAndShorthands<A extends object, Variants = {}> = OnlyAllowShorthands extends true ? WithThemeValues<MaybeOmitLonghands<Omit<A, Longhands>>> & Variants & WithShorthands<WithThemeValues<A>> : WithThemeValues<MaybeOmitLonghands<A>> & Variants & WithShorthands<WithThemeValues<A>>;
 export type WithThemeShorthandsAndPseudos<A extends object, Variants = {}> = WithThemeAndShorthands<A, Variants> & WithPseudoProps<WithThemeAndShorthands<A, Variants>>;
@@ -1472,6 +1476,7 @@ export interface StackStyleBase extends Omit<ViewStyle, keyof ExtendedBaseProps
 }
 export interface TextStylePropsBase extends Omit<RNTextStyle, keyof ExtendedBaseProps>, ExtendedBaseProps {
     ellipsis?: boolean;
+    numberOfLines?: number;
     textDecorationDistance?: number;
     textOverflow?: Properties['textOverflow'];
     whiteSpace?: Properties['whiteSpace'];
@@ -1609,7 +1614,7 @@ export type StaticConfigPublic = {
         [key: string]: boolean;
     };
     /**
-     * Accept Hanzo GUI tokens for these props (key for the prop key, val for the token category)
+     * Accept GUI tokens for these props (key for the prop key, val for the token category)
      */
     accept?: {
         [key: string]: keyof Tokens | 'style' | 'textStyle';
@@ -1632,9 +1637,9 @@ export type StaticConfigPublic = {
      */
     isReactNative?: boolean;
     /**
-     * By default if styled() doesn't recognize a parent Hanzo GUI component or specific react-native views,
+     * By default if styled() doesn't recognize a parent GUI component or specific react-native views,
      * it will assume the passed in component only accepts style={} for react-native compatibility.
-     * Setting `acceptsClassName: true` indicates Hanzo GUI can pass in className props.
+     * Setting `acceptsClassName: true` indicates GUI can pass in className props.
      */
     acceptsClassName?: boolean;
     /**
@@ -1807,6 +1812,7 @@ export type UseAnimatedNumberReaction<V extends UniversalAnimatedNumber<any> = U
     hostRef: RefObject<GuiElement>;
 }, onValue: (current: number) => void) => void;
 export type UseAnimatedNumberStyle<V extends UniversalAnimatedNumber<any> = UniversalAnimatedNumber<any>> = (val: V, getStyle: (current: any) => any) => any;
+export type UseAnimatedNumbersStyle<V extends UniversalAnimatedNumber<any> = UniversalAnimatedNumber<any>> = (vals: V[], getStyle: (...currentValues: any[]) => any) => any;
 export type UseAnimatedNumber<N extends UniversalAnimatedNumber<any> = UniversalAnimatedNumber<any>> = (initial: number) => N;
 export type AnimationDriver<A extends AnimationConfig = AnimationConfig> = {
     isReactNative?: boolean;
@@ -1827,6 +1833,7 @@ export type AnimationDriver<A extends AnimationConfig = AnimationConfig> = {
     }) => React.ReactNode;
     useAnimatedNumber: UseAnimatedNumber;
     useAnimatedNumberStyle: UseAnimatedNumberStyle;
+    useAnimatedNumbersStyle?: UseAnimatedNumbersStyle;
     useAnimatedNumberReaction: UseAnimatedNumberReaction;
     animations: A;
     View?: any;