blend-native 0.0.1-beta.0

package/lib/typescript/module/overlay/useAnchoredPosition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useAnchoredPosition.d.ts","sourceRoot":"","sources":["../../../../src/overlay/useAnchoredPosition.ts"],"names":[],"mappings":"AACA,OAAO,EAEH,KAAK,iBAAiB,EACtB,KAAK,IAAI,EACZ,MAAM,cAAc,CAAA;AACrB,OAAO,EAEH,KAAK,SAAS,EACd,KAAK,gBAAgB,EACrB,KAAK,SAAS,EAGjB,MAAM,kBAAe,CAAA;AAEtB;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,CAAC,EAAE;IAC1C,SAAS,CAAC,EAAE,SAAS,CAAA;IACrB,SAAS,CAAC,EAAE,SAAS,CAAA;IACrB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,eAAe,CAAC,EAAE,MAAM,CAAA;CAC3B;;;6BAa+C,iBAAiB;;EAgChE"}

package/lib/typescript/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/typescript/module/primitives/Block.d.ts

@@ -0,0 +1,37 @@
+import React from 'react';
+import { View, type ViewProps, type ViewStyle } from 'react-native';
+import { type SurfaceStyleProps } from '../adapters/surfaceStyle.js';
+/**
+ * Native `Block` — a `View` driven by token-shaped style props.
+ *
+ * Style resolution is delegated to `resolveSurfaceStyle`, the same function
+ * `Pressable` uses, so a component that swaps between the two depending on
+ * whether it is interactive (web's `TagElement = onClick ? PrimitiveButton :
+ * Block` pattern) renders identically in both branches. Before that was
+ * shared, `Block` could not render a border, radius, shadow, or height at
+ * all.
+ *
+ * Note there is **no `color` prop**. On web, `Block`'s `color` maps to CSS
+ * `color` — a foreground value that SVG icons inherit via `currentColor`.
+ * RN has no such inheritance, and mapping `color` to `backgroundColor` (as
+ * this file previously did) silently inverted the meaning of every call
+ * copied over from web. Use `backgroundColor` for a background, and `Slot`
+ * for tinting icons.
+ */
+export type BlockProps = SurfaceStyleProps & {
+    children?: React.ReactNode;
+    /** Escape hatch for RN styles the token props do not cover. */
+    style?: ViewStyle;
+} & Omit<ViewProps, 'style'>;
+/**
+ * Memoised because primitives sit at the leaves of every component tree: a
+ * parent re-render should not walk the whole subtree when none of the
+ * token-derived props changed.
+ */
+export declare const Block: React.NamedExoticComponent<SurfaceStyleProps & {
+    children?: React.ReactNode;
+    /** Escape hatch for RN styles the token props do not cover. */
+    style?: ViewStyle;
+} & Omit<ViewProps, "style"> & React.RefAttributes<View>>;
+export default Block;
+//# sourceMappingURL=Block.d.ts.map

package/lib/typescript/module/primitives/Block.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Block.d.ts","sourceRoot":"","sources":["../../../../src/primitives/Block.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA2B,MAAM,OAAO,CAAA;AAC/C,OAAO,EACH,IAAI,EAIJ,KAAK,SAAS,EACd,KAAK,SAAS,EACjB,MAAM,cAAc,CAAA;AACrB,OAAO,EAEH,KAAK,iBAAiB,EACzB,MAAM,6BAA0B,CAAA;AAEjC;;;;;;;;;;;;;;;;GAgBG;AAEH,MAAM,MAAM,UAAU,GAAG,iBAAiB,GAAG;IACzC,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IAC1B,+DAA+D;IAC/D,KAAK,CAAC,EAAE,SAAS,CAAA;CACpB,GAAG,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;AA4E5B;;;;GAIG;AACH,eAAO,MAAM,KAAK;eApFH,KAAK,CAAC,SAAS;IAC1B,+DAA+D;YACvD,SAAS;yDAkFe,CAAA;AAWpC,eAAe,KAAK,CAAA"}

package/lib/typescript/module/primitives/Pressable.d.ts

@@ -0,0 +1,135 @@
+import React from 'react';
+import { View, type GestureResponderEvent, type PressableProps, type ViewStyle } from 'react-native';
+import { type SurfaceStyleProps } from '../adapters/surfaceStyle.js';
+import { MIN_TOUCH_TARGET } from './touchTarget.js';
+export { MIN_TOUCH_TARGET };
+/**
+ * Native `Pressable` — the interactive surface for buttons, tags, and any
+ * other pressable token-driven component.
+ *
+ * Web's `PrimitiveButton` is a styled-components `button` with `_active`,
+ * `_hover`, `_focusVisible` and `_disabled` pseudo-state objects. RN has no
+ * CSS pseudo-selectors; instead `Pressable` exposes a `style` callback
+ * receiving `{ pressed }`. This primitive takes the same token-derived CSS
+ * strings, translates them through the shared adapter, and composes them per
+ * state.
+ *
+ * `_hover` is ignored — RN has no hover. `_focusVisible` is ignored — there
+ * is no focus ring on touch.
+ */
+/**
+ * `expo-linear-gradient` is an **optional** peer (probe shared with
+ * Skeleton in `adapters/optionalGradient`). When it is absent the surface
+ * falls back to the gradient's first colour, which `resolveSurfaceStyle`
+ * already supplies as `backgroundColor` — so a gradient button degrades to
+ * a solid one rather than rendering transparent.
+ */
+/**
+ * Note this extends `SurfaceStyleProps`, exactly as `BlockProps` does.
+ *
+ * That shared base is load-bearing, not cosmetic. Components that switch
+ * between `Block` and `Pressable` depending on interactivity (Tag, and web's
+ * `TagElement = onClick ? PrimitiveButton : Block` pattern) build one surface
+ * object and hand it to whichever they render. If the two accepted different
+ * prop sets, the extras would fall silently into `...rest` in one branch and
+ * vanish — and TypeScript would not catch it, because spreading an object
+ * into JSX skips excess-property checking. Keeping one base makes that class
+ * of bug unrepresentable.
+ */
+export type PrimitivePressableProps = SurfaceStyleProps & {
+    children?: React.ReactNode;
+    /** Active-state background (CSS string). */
+    activeBackground?: string;
+    /** Disabled-state background (CSS string). */
+    disabledBackground?: string;
+    activeBorder?: string;
+    disabledBorder?: string;
+    activeBoxShadow?: string;
+    disabled?: boolean;
+    /**
+     * Render a spinner in place of `children` while keeping the surface
+     * chrome (background, border, padding) intact — the same substitution
+     * web performs in `renderButtonContent`.
+     */
+    loading?: boolean;
+    loaderColor?: string;
+    loaderSize?: number | 'small' | 'large';
+    /** Announced to screen readers when `loading` becomes true. */
+    loadingAccessibilityLabel?: string;
+    /** Pressed scale transform (web uses `scale(0.99)`). */
+    pressedScale?: number;
+    /**
+     * Colour of the Android ripple. Defaults to the active-state background
+     * token, so press feedback tracks the design system without callers
+     * having to supply anything.
+     *
+     * Ignored on every other platform — see the note on `pressFeedback`.
+     */
+    rippleColor?: string;
+    /**
+     * Whether the ripple is drawn without bounds (a circle centred on the
+     * touch, used for icon-only controls). Mirrors RN's `android_ripple.borderless`.
+     */
+    rippleBorderless?: boolean;
+    /**
+     * Minimum tappable size in points. When the rendered surface is smaller,
+     * `hitSlop` expands the touch area without changing the visual box.
+     *
+     * Apple HIG asks for 44x44pt and Material for 48x48dp; small controls
+     * (an `xs` Tag is 20pt tall) fall well under both by design, so the tap
+     * target has to be widened rather than the control. Pass `0` to opt out.
+     */
+    minTouchTarget?: number;
+    onPress?: (event: GestureResponderEvent) => void;
+    style?: ViewStyle;
+} & Omit<PressableProps, 'style' | 'onPress' | 'disabled' | 'children'>;
+/** Memoised — see the note on `Block`. */
+export declare const Pressable: React.NamedExoticComponent<SurfaceStyleProps & {
+    children?: React.ReactNode;
+    /** Active-state background (CSS string). */
+    activeBackground?: string;
+    /** Disabled-state background (CSS string). */
+    disabledBackground?: string;
+    activeBorder?: string;
+    disabledBorder?: string;
+    activeBoxShadow?: string;
+    disabled?: boolean;
+    /**
+     * Render a spinner in place of `children` while keeping the surface
+     * chrome (background, border, padding) intact — the same substitution
+     * web performs in `renderButtonContent`.
+     */
+    loading?: boolean;
+    loaderColor?: string;
+    loaderSize?: number | "small" | "large";
+    /** Announced to screen readers when `loading` becomes true. */
+    loadingAccessibilityLabel?: string;
+    /** Pressed scale transform (web uses `scale(0.99)`). */
+    pressedScale?: number;
+    /**
+     * Colour of the Android ripple. Defaults to the active-state background
+     * token, so press feedback tracks the design system without callers
+     * having to supply anything.
+     *
+     * Ignored on every other platform — see the note on `pressFeedback`.
+     */
+    rippleColor?: string;
+    /**
+     * Whether the ripple is drawn without bounds (a circle centred on the
+     * touch, used for icon-only controls). Mirrors RN's `android_ripple.borderless`.
+     */
+    rippleBorderless?: boolean;
+    /**
+     * Minimum tappable size in points. When the rendered surface is smaller,
+     * `hitSlop` expands the touch area without changing the visual box.
+     *
+     * Apple HIG asks for 44x44pt and Material for 48x48dp; small controls
+     * (an `xs` Tag is 20pt tall) fall well under both by design, so the tap
+     * target has to be widened rather than the control. Pass `0` to opt out.
+     */
+    minTouchTarget?: number;
+    onPress?: (event: GestureResponderEvent) => void;
+    style?: ViewStyle;
+} & Omit<PressableProps, "children" | "style" | "onPress" | "disabled"> & React.RefAttributes<View>>;
+export default Pressable;
+//# sourceMappingURL=Pressable.d.ts.map

package/lib/typescript/module/primitives/Pressable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Pressable.d.ts","sourceRoot":"","sources":["../../../../src/primitives/Pressable.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA2D,MAAM,OAAO,CAAA;AAC/E,OAAO,EAGH,IAAI,EAEJ,KAAK,qBAAqB,EAE1B,KAAK,cAAc,EAEnB,KAAK,SAAS,EACjB,MAAM,cAAc,CAAA;AAMrB,OAAO,EAEH,KAAK,iBAAiB,EACzB,MAAM,6BAA0B,CAAA;AAKjC,OAAO,EACH,gBAAgB,EAInB,MAAM,kBAAe,CAAA;AAItB,OAAO,EAAE,gBAAgB,EAAE,CAAA;AAE3B;;;;;;;;;;;;;GAaG;AAEH;;;;;;GAMG;AAEH;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,uBAAuB,GAAG,iBAAiB,GAAG;IACtD,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IAC1B,4CAA4C;IAC5C,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,8CAA8C;IAC9C,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,cAAc,CAAC,EAAE,MAAM,CAAA;IACvB,eAAe,CAAC,EAAE,MAAM,CAAA;IAExB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO,CAAA;IACvC,+DAA+D;IAC/D,yBAAyB,CAAC,EAAE,MAAM,CAAA;IAClC,wDAAwD;IACxD,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B;;;;;;;OAOG;IACH,cAAc,CAAC,EAAE,MAAM,CAAA;IAEvB,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,qBAAqB,KAAK,IAAI,CAAA;IAChD,KAAK,CAAC,EAAE,SAAS,CAAA;CACpB,GAAG,IAAI,CAAC,cAAc,EAAE,OAAO,GAAG,SAAS,GAAG,UAAU,GAAG,UAAU,CAAC,CAAA;AAoZvE,0CAA0C;AAC1C,eAAO,MAAM,SAAS;eApcP,KAAK,CAAC,SAAS;IAC1B,4CAA4C;uBACzB,MAAM;IACzB,8CAA8C;yBACzB,MAAM;mBACZ,MAAM;qBACJ,MAAM;sBACL,MAAM;eAEb,OAAO;IAClB;;;;OAIG;cACO,OAAO;kBACH,MAAM;iBACP,MAAM,GAAG,OAAO,GAAG,OAAO;IACvC,+DAA+D;gCACnC,MAAM;IAClC,wDAAwD;mBACzC,MAAM;IACrB;;;;;;OAMG;kBACW,MAAM;IACpB;;;OAGG;uBACgB,OAAO;IAC1B;;;;;;;OAOG;qBACc,MAAM;cAEb,CAAC,KAAK,EAAE,qBAAqB,KAAK,IAAI;YACxC,SAAS;oGAsZuB,CAAA;AAG5C,eAAe,SAAS,CAAA"}

package/lib/typescript/module/primitives/PrimitiveInput.d.ts

@@ -0,0 +1,42 @@
+import { TextInput as RNTextInput, type TextInputProps as RNTextInputProps, type TextStyle } from 'react-native';
+/**
+ * Native `PrimitiveInput` — a bare RN `TextInput` driven by token-shaped
+ * text props, the input counterpart of `Text`.
+ *
+ * Deliberately *only* the text field: web's `PrimitiveInput` styles the
+ * `<input>` element itself with border and padding, but RN inputs carry
+ * leading/trailing slots, so the bordered container is a `Block` row that
+ * the field component owns and this primitive sits inside with `flex: 1`.
+ *
+ * Font family comes from the provider's role map (`body`), matching `Text`,
+ * and OS font scaling stays on per the package policy.
+ */
+export type PrimitiveInputProps = {
+    /** CSS string like `"14px"` or a number. */
+    fontSize?: string | number;
+    /** CSS font-weight keyword or numeric string (`"500"`). */
+    fontWeight?: string | number;
+    /** Text colour for the current state. */
+    color?: string;
+    /** CSS line-height like `"20px"` or a number. */
+    lineHeight?: string | number;
+    /** Placeholder colour for the current state. */
+    placeholderColor?: string;
+    style?: TextStyle;
+} & Omit<RNTextInputProps, 'style' | 'placeholderTextColor'>;
+/** Memoised — see the note on `Block`. */
+export declare const PrimitiveInput: import("react").NamedExoticComponent<{
+    /** CSS string like `"14px"` or a number. */
+    fontSize?: string | number;
+    /** CSS font-weight keyword or numeric string (`"500"`). */
+    fontWeight?: string | number;
+    /** Text colour for the current state. */
+    color?: string;
+    /** CSS line-height like `"20px"` or a number. */
+    lineHeight?: string | number;
+    /** Placeholder colour for the current state. */
+    placeholderColor?: string;
+    style?: TextStyle;
+} & Omit<RNTextInputProps, "style" | "placeholderTextColor"> & import("react").RefAttributes<RNTextInput>>;
+export default PrimitiveInput;
+//# sourceMappingURL=PrimitiveInput.d.ts.map

package/lib/typescript/module/primitives/PrimitiveInput.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PrimitiveInput.d.ts","sourceRoot":"","sources":["../../../../src/primitives/PrimitiveInput.tsx"],"names":[],"mappings":"AACA,OAAO,EACH,SAAS,IAAI,WAAW,EAExB,KAAK,cAAc,IAAI,gBAAgB,EACvC,KAAK,SAAS,EACjB,MAAM,cAAc,CAAA;AAKrB;;;;;;;;;;;GAWG;AAEH,MAAM,MAAM,mBAAmB,GAAG;IAC9B,4CAA4C;IAC5C,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IAC1B,2DAA2D;IAC3D,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IAC5B,yCAAyC;IACzC,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,iDAAiD;IACjD,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IAC5B,gDAAgD;IAChD,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,KAAK,CAAC,EAAE,SAAS,CAAA;CACpB,GAAG,IAAI,CAAC,gBAAgB,EAAE,OAAO,GAAG,sBAAsB,CAAC,CAAA;AAoC5D,0CAA0C;AAC1C,eAAO,MAAM,cAAc;IAhDvB,4CAA4C;eACjC,MAAM,GAAG,MAAM;IAC1B,2DAA2D;iBAC9C,MAAM,GAAG,MAAM;IAC5B,yCAAyC;YACjC,MAAM;IACd,iDAAiD;iBACpC,MAAM,GAAG,MAAM;IAC5B,gDAAgD;uBAC7B,MAAM;YACjB,SAAS;0GAsCiC,CAAA;AAatD,eAAe,cAAc,CAAA"}

package/lib/typescript/module/primitives/Separator.d.ts

@@ -0,0 +1,28 @@
+import { type ViewStyle } from 'react-native';
+/**
+ * Decorative divider.
+ *
+ * Native counterpart of web's `components/common/Seperator.tsx` — a fixed-size
+ * block of colour used to separate adjacent content. Alert renders one between
+ * its actions and its close button when the actions sit inline.
+ *
+ * Always hidden from assistive tech: it carries no information that the
+ * surrounding content does not already convey.
+ */
+export type SeparatorProps = {
+    /** Which way the line runs. Defaults to vertical, as Alert needs. */
+    orientation?: 'vertical' | 'horizontal';
+    /** Length along the run of the line. Token string or number. */
+    length?: string | number;
+    /** Thickness across the line. Token string or number. */
+    thickness?: string | number;
+    color?: string;
+    style?: ViewStyle;
+    testID?: string;
+};
+export declare function Separator({ orientation, length, thickness, color, style, testID, }: SeparatorProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace Separator {
+    var displayName: string;
+}
+export default Separator;
+//# sourceMappingURL=Separator.d.ts.map

package/lib/typescript/module/primitives/Separator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Separator.d.ts","sourceRoot":"","sources":["../../../../src/primitives/Separator.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAoB,KAAK,SAAS,EAAE,MAAM,cAAc,CAAA;AAI/D;;;;;;;;;GASG;AAEH,MAAM,MAAM,cAAc,GAAG;IACzB,qEAAqE;IACrE,WAAW,CAAC,EAAE,UAAU,GAAG,YAAY,CAAA;IACvC,gEAAgE;IAChE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IACxB,yDAAyD;IACzD,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,KAAK,CAAC,EAAE,SAAS,CAAA;IACjB,MAAM,CAAC,EAAE,MAAM,CAAA;CAClB,CAAA;AAMD,wBAAgB,SAAS,CAAC,EACtB,WAAwB,EACxB,MAAuB,EACvB,SAA6B,EAC7B,KAAqB,EACrB,KAAK,EACL,MAAM,GACT,EAAE,cAAc,2CAsBhB;yBA7Be,SAAS;;;AAiCzB,eAAe,SAAS,CAAA"}

package/lib/typescript/module/primitives/Slot.d.ts

@@ -0,0 +1,48 @@
+import React from 'react';
+import { type ViewStyle } from 'react-native';
+import { tintSlot } from './tintSlot.js';
+export { tintSlot };
+/**
+ * Leading / trailing icon slot.
+ *
+ * Shared by `Button` and `Tag`, both of which need identical behaviour and
+ * both of which previously got it wrong in the same three ways:
+ *
+ * 1. **Tinting.** On web, components pass `color` to `Block`, which maps to
+ *    CSS `color`, and SVG icons pick it up through `currentColor`. The native
+ *    `Block` mapped `color` to `backgroundColor`, so the same call painted a
+ *    solid rectangle *behind* the icon and never tinted the icon at all. RN
+ *    has no `currentColor`, so the tint has to be handed to the element
+ *    explicitly — that is what this component does.
+ * 2. **Per-slot `maxHeight`.** `leftSlot.maxHeight` / `rightSlot.maxHeight`
+ *    are part of the web prop contract and were ignored.
+ * 3. **Screen readers.** Web marks slots `aria-hidden` when the component
+ *    also renders text, so the icon is not announced separately from the
+ *    label. Native rendered them as visible accessibility nodes.
+ */
+export type SlotProps = {
+    /** The icon element to render. */
+    children?: React.ReactNode;
+    /**
+     * Colour to tint the icon with. Passed to the child as `color` (and
+     * `fill`, which `react-native-svg` elements use).
+     */
+    color?: string;
+    /**
+     * Max height for the icon box. Accepts token strings (`"16px"`),
+     * percentages (`"100%"`, used by Button's inline subType), or numbers.
+     */
+    maxHeight?: string | number;
+    /**
+     * Hide from screen readers. Should be `true` whenever the parent also
+     * renders a text label, matching web's `aria-hidden`.
+     */
+    hidden?: boolean;
+    style?: ViewStyle;
+    testID?: string;
+};
+declare function SlotImpl({ children, color, maxHeight, hidden, style, testID, }: SlotProps): import("react/jsx-runtime").JSX.Element | null;
+/** Memoised — see the note on `Block`. */
+export declare const Slot: React.MemoExoticComponent<typeof SlotImpl>;
+export default Slot;
+//# sourceMappingURL=Slot.d.ts.map

package/lib/typescript/module/primitives/Slot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Slot.d.ts","sourceRoot":"","sources":["../../../../src/primitives/Slot.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAe,MAAM,OAAO,CAAA;AACnC,OAAO,EAAoB,KAAK,SAAS,EAAE,MAAM,cAAc,CAAA;AAE/D,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAY,CAAA;AAErC,OAAO,EAAE,QAAQ,EAAE,CAAA;AAEnB;;;;;;;;;;;;;;;;;GAiBG;AAEH,MAAM,MAAM,SAAS,GAAG;IACpB,kCAAkC;IAClC,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IAC1B;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;IACd;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IAC3B;;;OAGG;IACH,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,KAAK,CAAC,EAAE,SAAS,CAAA;IACjB,MAAM,CAAC,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,iBAAS,QAAQ,CAAC,EACd,QAAQ,EACR,KAAK,EACL,SAAS,EACT,MAAc,EACd,KAAK,EACL,MAAM,GACT,EAAE,SAAS,kDAuBX;AAED,0CAA0C;AAC1C,eAAO,MAAM,IAAI,4CAAiB,CAAA;AAYlC,eAAe,IAAI,CAAA"}

package/lib/typescript/module/primitives/Text.d.ts

@@ -0,0 +1,50 @@
+import React from 'react';
+import { type TextProps as RNTextProps, type TextStyle } from 'react-native';
+import type { NativeFontRole } from '../theme/fonts.js';
+/**
+ * Native `Text` — renders a RN `Text` from token-driven style props.
+ *
+ * Mirrors the web `Text` component's API (`fontSize`, `fontWeight`, `color`,
+ * `lineHeight`, `textAlign`) but accepts CSS-string values directly from
+ * Blend tokens and translates them to `TextStyle` numbers.
+ *
+ * **Font family** comes from the provider's resolved role map (web has CSS
+ * inheritance; RN does not, so the provider is the inheritance mechanism).
+ * Defaults to the `body` role; `fontRole` picks another role and an explicit
+ * `fontFamily` wins outright.
+ *
+ * **Font scaling** is deliberately left ON (RN's default). The package policy
+ * is to respect OS Dynamic Type and let controls grow — components size with
+ * `minHeight`, never a fixed `height`, so scaled text expands the control
+ * instead of clipping. Consumers needing a cap can pass RN's own
+ * `maxFontSizeMultiplier` through `...rest`.
+ */
+export type BlendTextProps = {
+    children?: React.ReactNode;
+    /** CSS string like `"14px"` or a number. */
+    fontSize?: string | number;
+    /** CSS font-weight keyword or number (`"500"`, `500`, `"bold"`). */
+    fontWeight?: string | number;
+    color?: string;
+    /** CSS line-height like `"20px"` or a number. */
+    lineHeight?: string | number;
+    textAlign?: 'left' | 'right' | 'center' | 'justify';
+    /**
+     * Explicit font family. Overrides the provider's role map; rarely needed
+     * outside consumer escape hatches.
+     */
+    fontFamily?: string;
+    /** Which provider font role to use when `fontFamily` is not given. */
+    fontRole?: NativeFontRole;
+    /** Set true to hide from screen readers (web `aria-hidden`). */
+    'aria-hidden'?: boolean;
+    /** Flex display — web `Text` is sometimes `inline`; on RN Text is always inline. */
+    as?: string;
+} & Omit<RNTextProps, 'style'> & {
+    style?: TextStyle;
+};
+declare function TextImpl({ children, fontSize, fontWeight, color, lineHeight, textAlign, fontFamily, fontRole, style, ...rest }: BlendTextProps): import("react/jsx-runtime").JSX.Element;
+/** Memoised — see the note on `Block`. */
+export declare const Text: React.MemoExoticComponent<typeof TextImpl>;
+export default Text;
+//# sourceMappingURL=Text.d.ts.map

package/lib/typescript/module/primitives/Text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Text.d.ts","sourceRoot":"","sources":["../../../../src/primitives/Text.tsx"],"names":[],"mappings":"AAAA,OAAO,KAA2B,MAAM,OAAO,CAAA;AAC/C,OAAO,EAGH,KAAK,SAAS,IAAI,WAAW,EAC7B,KAAK,SAAS,EACjB,MAAM,cAAc,CAAA;AAIrB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAgB,CAAA;AAEpD;;;;;;;;;;;;;;;;;GAiBG;AAEH,MAAM,MAAM,cAAc,GAAG;IACzB,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IAC1B,4CAA4C;IAC5C,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IAC1B,oEAAoE;IACpE,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,iDAAiD;IACjD,UAAU,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IAC5B,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,SAAS,CAAA;IACnD;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,sEAAsE;IACtE,QAAQ,CAAC,EAAE,cAAc,CAAA;IACzB,gEAAgE;IAChE,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,oFAAoF;IACpF,EAAE,CAAC,EAAE,MAAM,CAAA;CACd,GAAG,IAAI,CAAC,WAAW,EAAE,OAAO,CAAC,GAAG;IACzB,KAAK,CAAC,EAAE,SAAS,CAAA;CACpB,CAAA;AAEL,iBAAS,QAAQ,CAAC,EACd,QAAQ,EACR,QAAQ,EACR,UAAU,EACV,KAAK,EACL,UAAU,EACV,SAAS,EACT,UAAU,EACV,QAAiB,EACjB,KAAK,EACL,GAAG,IAAI,EACV,EAAE,cAAc,2CAoBhB;AAED,0CAA0C;AAC1C,eAAO,MAAM,IAAI,4CAAiB,CAAA;AAOlC,eAAe,IAAI,CAAA"}

package/lib/typescript/module/primitives/pressFeedback.d.ts

@@ -0,0 +1,39 @@
+import type { ViewStyle } from 'react-native';
+/**
+ * Press feedback is platform-idiomatic, not uniform.
+ *
+ * Web scales the surface by `0.99`, and that reads correctly on iOS where a
+ * subtle depress is the convention. Android users expect a **ripple**, and a
+ * scale transform there looks like a bug. Applying both would double the
+ * feedback.
+ *
+ * The decision lives here — a leaf module with no `react-native` value import
+ * — so it is unit-testable outside a renderer, the same split as
+ * `theme/breakpoint.ts`, `primitives/touchTarget.ts` and the shadow handling
+ * in `adapters/surfaceStyle.ts`. `Pressable` passes the real `Platform.OS`.
+ */
+export type PressFeedbackPlatform = 'ios' | 'android' | 'web' | 'windows' | 'macos';
+export type AndroidRipple = {
+    color: string;
+    borderless: boolean;
+};
+export type PressFeedback = {
+    /** Passed to RN's `android_ripple`; `undefined` off Android. */
+    androidRipple?: AndroidRipple;
+    /** Style merged in while pressed; empty on Android, where the ripple carries it. */
+    pressedTransform: ViewStyle;
+};
+/**
+ * Ripple colour used when neither the caller nor the active-state token
+ * supplies one. Low-alpha black is Android's own default for light surfaces.
+ */
+export declare const DEFAULT_RIPPLE_COLOR = "rgba(0, 0, 0, 0.12)";
+export declare function resolvePressFeedback(platform: PressFeedbackPlatform, options?: {
+    /** Explicit ripple colour from the caller. */
+    rippleColor?: string;
+    /** Active-state background token, used when no explicit colour is set. */
+    activeBackgroundColor?: string;
+    rippleBorderless?: boolean;
+    pressedScale?: number;
+}): PressFeedback;
+//# sourceMappingURL=pressFeedback.d.ts.map

package/lib/typescript/module/primitives/pressFeedback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pressFeedback.d.ts","sourceRoot":"","sources":["../../../../src/primitives/pressFeedback.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAE7C;;;;;;;;;;;;GAYG;AAEH,MAAM,MAAM,qBAAqB,GAC3B,KAAK,GACL,SAAS,GACT,KAAK,GACL,SAAS,GACT,OAAO,CAAA;AAEb,MAAM,MAAM,aAAa,GAAG;IACxB,KAAK,EAAE,MAAM,CAAA;IACb,UAAU,EAAE,OAAO,CAAA;CACtB,CAAA;AAED,MAAM,MAAM,aAAa,GAAG;IACxB,gEAAgE;IAChE,aAAa,CAAC,EAAE,aAAa,CAAA;IAC7B,oFAAoF;IACpF,gBAAgB,EAAE,SAAS,CAAA;CAC9B,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,oBAAoB,wBAAwB,CAAA;AAEzD,wBAAgB,oBAAoB,CAChC,QAAQ,EAAE,qBAAqB,EAC/B,OAAO,GAAE;IACL,8CAA8C;IAC9C,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,0EAA0E;IAC1E,qBAAqB,CAAC,EAAE,MAAM,CAAA;IAC9B,gBAAgB,CAAC,EAAE,OAAO,CAAA;IAC1B,YAAY,CAAC,EAAE,MAAM,CAAA;CACnB,GACP,aAAa,CA0Bf"}

package/lib/typescript/module/primitives/textStyle.d.ts

@@ -0,0 +1,13 @@
+import type { TextStyle } from 'react-native';
+/**
+ * Shared text-style resolution for `Text` and `PrimitiveInput`.
+ *
+ * Leaf module with only a type import from `react-native`, so it stays
+ * vitest-testable — the `theme/breakpoint.ts` pattern.
+ */
+/**
+ * Resolve a CSS font-weight value to a RN-compatible `TextStyle['fontWeight']`.
+ * RN accepts `'normal' | 'bold' | '100'..'900'` (as string or number).
+ */
+export declare function resolveFontWeight(w: string | number | undefined): TextStyle['fontWeight'];
+//# sourceMappingURL=textStyle.d.ts.map

package/lib/typescript/module/primitives/textStyle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"textStyle.d.ts","sourceRoot":"","sources":["../../../../src/primitives/textStyle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAE7C;;;;;GAKG;AAEH;;;GAGG;AACH,wBAAgB,iBAAiB,CAC7B,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,GAC/B,SAAS,CAAC,YAAY,CAAC,CAQzB"}

package/lib/typescript/module/primitives/tintSlot.d.ts

@@ -0,0 +1,10 @@
+import type { ReactNode } from 'react';
+/**
+ * Apply a tint to an icon element.
+ *
+ * Only sets `color`, and only when the element has not set it explicitly —
+ * an icon rendered as `<Icon color="red" />` keeps red. Non-element children
+ * (a bare string, a number, `null`) are returned untouched.
+ */
+export declare function tintSlot(node: ReactNode, color: string | undefined): ReactNode;
+//# sourceMappingURL=tintSlot.d.ts.map

package/lib/typescript/module/primitives/tintSlot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tintSlot.d.ts","sourceRoot":"","sources":["../../../../src/primitives/tintSlot.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAgB,MAAM,OAAO,CAAA;AAyBpD;;;;;;GAMG;AACH,wBAAgB,QAAQ,CACpB,IAAI,EAAE,SAAS,EACf,KAAK,EAAE,MAAM,GAAG,SAAS,GAC1B,SAAS,CAOX"}

package/lib/typescript/module/primitives/touchTarget.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Minimum tap-target policy.
+ *
+ * Kept in its own leaf module — importing nothing from `react-native` — so it
+ * stays unit-testable outside a renderer. (RN's entrypoint ships Flow syntax
+ * that non-Metro bundlers cannot parse, so any module that value-imports it is
+ * unusable from a plain Node test runner. Same split as `theme/breakpoint.ts`.)
+ */
+/** Inset applied to each edge of the touch region. */
+export type HitSlop = {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+};
+/**
+ * Apple's Human Interface Guidelines minimum tappable size, in points. Also
+ * clears Material's 48dp target once RN's density conversion is applied.
+ */
+export declare const MIN_TOUCH_TARGET = 44;
+/**
+ * Slop needed to bring a rendered control up to the minimum tap target.
+ *
+ * Design-system controls are frequently smaller than the guideline by intent —
+ * an `xs` Tag is 20pt tall — so the fix is to widen the *touch* region rather
+ * than the control. Returns `undefined` when the control already complies (or
+ * when the minimum is disabled with `0`), so no `hitSlop` prop is emitted.
+ *
+ * ```
+ * resolveHitSlop(120, 48) -> undefined          // already compliant
+ * resolveHitSlop(60, 20)  -> { top: 12, bottom: 12, left: 0, right: 0 }
+ * resolveHitSlop(24, 24)  -> { top: 10, bottom: 10, left: 10, right: 10 }
+ * ```
+ */
+export declare function resolveHitSlop(width: number, height: number, minTouchTarget?: number): HitSlop | undefined;
+/**
+ * Whether two slop values are equivalent.
+ *
+ * Lets callers skip a state update when a re-measure produces the same result,
+ * which keeps a control that never needed slop from re-rendering at all.
+ */
+export declare function sameHitSlop(a?: HitSlop, b?: HitSlop): boolean;
+//# sourceMappingURL=touchTarget.d.ts.map

package/lib/typescript/module/primitives/touchTarget.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"touchTarget.d.ts","sourceRoot":"","sources":["../../../../src/primitives/touchTarget.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,sDAAsD;AACtD,MAAM,MAAM,OAAO,GAAG;IAClB,GAAG,EAAE,MAAM,CAAA;IACX,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;CAChB,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,gBAAgB,KAAK,CAAA;AAElC;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAC1B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,cAAc,GAAE,MAAyB,GAC1C,OAAO,GAAG,SAAS,CAarB;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,EAAE,OAAO,GAAG,OAAO,CAS7D"}

package/lib/typescript/module/theme/BlendNativeProvider.d.ts

@@ -0,0 +1,69 @@
+import React from 'react';
+import { FOUNDATION_THEME, Theme, type BreakpointType } from '@juspay/blend-design-system/node';
+import type { NativeComponentTokenOverrides } from './nativeTokenRegistry.js';
+import { type NativeFontFamilies, type NativeFontFamilyOption } from './fonts.js';
+import { SYSTEM_THEME, type NativeThemeSetting } from './systemTheme.js';
+/**
+ * Theme context for `blend-native`.
+ *
+ * Replaces the per-component `theme` prop the package shipped with. A prop
+ * meant no app-wide dark mode (every call site had to thread it), no nested
+ * theme scopes, and — most importantly — no `componentTokens` overrides,
+ * which is a first-class feature of web Blend that native consumers simply
+ * did not have.
+ *
+ * Mirrors web's `ThemeProvider` API (`{ theme, componentTokens,
+ * foundationTokens }`) so the two platforms are configured the same way, and
+ * like web it is optional: components fall back to these defaults when no
+ * provider is mounted.
+ *
+ * Two native-only additions:
+ *
+ * - `theme="system"` follows the OS appearance via `useColorScheme`,
+ *   re-rendering when the user flips light/dark. The sentinel is resolved
+ *   *before* the value enters context, so consumers only ever see a concrete
+ *   theme.
+ * - `fontFamily` resolves one font family per role (see `theme/fonts.ts`) —
+ *   RN's replacement for web's CSS font inheritance.
+ */
+export type BlendNativeThemeValue = {
+    theme: Theme | string;
+    componentTokens: NativeComponentTokenOverrides;
+    foundationTokens: typeof FOUNDATION_THEME;
+    breakpoints: BreakpointType;
+    /** Resolved family per role; `null` leaves the platform font. */
+    fontFamily: NativeFontFamilies;
+};
+export declare const DEFAULT_NATIVE_THEME: BlendNativeThemeValue;
+export declare const BlendNativeThemeContext: React.Context<BlendNativeThemeValue>;
+export type BlendNativeProviderProps = {
+    children?: React.ReactNode;
+    /**
+     * `'light' | 'dark' | 'system'`. Defaults to light. `'system'` follows
+     * the OS appearance setting.
+     */
+    theme?: NativeThemeSetting;
+    /**
+     * Partial per-slot token overrides, deep-merged onto the active theme's
+     * defaults. Supply only the paths you want to change — every untouched
+     * path keeps its light/dark value.
+     */
+    componentTokens?: NativeComponentTokenOverrides;
+    /** Override foundation tokens (colours, spacing, radii, ...). */
+    foundationTokens?: typeof FOUNDATION_THEME;
+    /** Override breakpoint thresholds. */
+    breakpoints?: BreakpointType;
+    /**
+     * Font families per role. Defaults to the foundation `font.family`
+     * tokens; pass `'system'` for platform fonts, or a partial map to
+     * override/disable individual roles. See `theme/fonts.ts`.
+     */
+    fontFamily?: NativeFontFamilyOption;
+};
+export declare function BlendNativeProvider({ children, theme, componentTokens, foundationTokens, breakpoints, fontFamily, }: BlendNativeProviderProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace BlendNativeProvider {
+    var displayName: string;
+}
+export { SYSTEM_THEME };
+export default BlendNativeProvider;
+//# sourceMappingURL=BlendNativeProvider.d.ts.map

package/lib/typescript/module/theme/BlendNativeProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlendNativeProvider.d.ts","sourceRoot":"","sources":["../../../../src/theme/BlendNativeProvider.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAiC,MAAM,OAAO,CAAA;AAErD,OAAO,EAEH,gBAAgB,EAChB,KAAK,EACL,KAAK,cAAc,EACtB,MAAM,kCAAkC,CAAA;AACzC,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,0BAAuB,CAAA;AAG1E,OAAO,EAEH,KAAK,kBAAkB,EACvB,KAAK,sBAAsB,EAC9B,MAAM,YAAS,CAAA;AAChB,OAAO,EAEH,YAAY,EACZ,KAAK,kBAAkB,EAC1B,MAAM,kBAAe,CAAA;AAEtB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,MAAM,MAAM,qBAAqB,GAAG;IAChC,KAAK,EAAE,KAAK,GAAG,MAAM,CAAA;IACrB,eAAe,EAAE,6BAA6B,CAAA;IAC9C,gBAAgB,EAAE,OAAO,gBAAgB,CAAA;IACzC,WAAW,EAAE,cAAc,CAAA;IAC3B,iEAAiE;IACjE,UAAU,EAAE,kBAAkB,CAAA;CACjC,CAAA;AAID,eAAO,MAAM,oBAAoB,EAAE,qBAMlC,CAAA;AAED,eAAO,MAAM,uBAAuB,sCAC0B,CAAA;AAE9D,MAAM,MAAM,wBAAwB,GAAG;IACnC,QAAQ,CAAC,EAAE,KAAK,CAAC,SAAS,CAAA;IAC1B;;;OAGG;IACH,KAAK,CAAC,EAAE,kBAAkB,CAAA;IAC1B;;;;OAIG;IACH,eAAe,CAAC,EAAE,6BAA6B,CAAA;IAC/C,iEAAiE;IACjE,gBAAgB,CAAC,EAAE,OAAO,gBAAgB,CAAA;IAC1C,sCAAsC;IACtC,WAAW,CAAC,EAAE,cAAc,CAAA;IAC5B;;;;OAIG;IACH,UAAU,CAAC,EAAE,sBAAsB,CAAA;CACtC,CAAA;AAED,wBAAgB,mBAAmB,CAAC,EAChC,QAAQ,EACR,KAAmB,EACnB,eAAiC,EACjC,gBAAmC,EACnC,WAAyB,EACzB,UAAU,GACb,EAAE,wBAAwB,2CAwC1B;yBA/Ce,mBAAmB;;;AAmDnC,OAAO,EAAE,YAAY,EAAE,CAAA;AAEvB,eAAe,mBAAmB,CAAA"}

package/lib/typescript/module/theme/breakpoint.d.ts

@@ -0,0 +1,27 @@
+import { type BreakpointType } from '@juspay/blend-design-system/node';
+/**
+ * Pure breakpoint resolution.
+ *
+ * Kept in its own leaf module — importing nothing from `react-native` — so it
+ * stays testable and reusable outside a React render. `useNativeBreakpoint`
+ * layers the `useWindowDimensions` subscription on top.
+ *
+ * (React Native's entrypoint ships Flow syntax that non-Metro bundlers cannot
+ * parse, so any module that value-imports it is unusable from a plain Node
+ * test runner. Splitting the logic out is the same pattern the web package
+ * uses for `shared/datetime/timeCore.ts`.)
+ */
+export type NativeBreakpoint = keyof BreakpointType;
+/**
+ * Resolve a viewport width to a Blend breakpoint label.
+ *
+ * Mirrors web's `useBreakPoints` exactly, including its quirk: **only**
+ * 320–1023 maps to `'sm'`; everything else — including widths below 320 —
+ * returns `'lg'`. Reproduced deliberately so a given width resolves to the
+ * same tokens on both platforms.
+ *
+ * Thresholds come from `BREAKPOINTS` in the web package rather than being
+ * duplicated, so retuning them stays a one-line change in one place.
+ */
+export declare function resolveBreakpoint(width: number, breakpoints?: BreakpointType): NativeBreakpoint;
+//# sourceMappingURL=breakpoint.d.ts.map

package/lib/typescript/module/theme/breakpoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"breakpoint.d.ts","sourceRoot":"","sources":["../../../../src/theme/breakpoint.ts"],"names":[],"mappings":"AAAA,OAAO,EAEH,KAAK,cAAc,EACtB,MAAM,kCAAkC,CAAA;AAEzC;;;;;;;;;;;GAWG;AAEH,MAAM,MAAM,gBAAgB,GAAG,MAAM,cAAc,CAAA;AAEnD;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAC7B,KAAK,EAAE,MAAM,EACb,WAAW,GAAE,cAA4B,GAC1C,gBAAgB,CAGlB"}