@xaui/native 0.9.1-alpha.1 → 0.9.1-alpha.11

package/dist/system/index.cjs

@@ -1,7 +1,53 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunkKFCORXWWcjs = require('../chunk-KFCORXWW.cjs');
-require('../chunk-M7P46XKI.cjs');
 
 
-exports.createRecipe = _chunkKFCORXWWcjs.createRecipe;
+var _chunkLMUPNKPHcjs = require('../chunk-LMUPNKPH.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkE2UGZJBTcjs = require('../chunk-E2UGZJBT.cjs');
+require('../chunk-3QBT3Q65.cjs');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.HIGHLIGHT_OPACITY = _chunkE2UGZJBTcjs.HIGHLIGHT_OPACITY; exports.Icon = _chunkE2UGZJBTcjs.Icon; exports.IconContext = _chunkE2UGZJBTcjs.IconContext; exports.PRESS_DURATION = _chunkE2UGZJBTcjs.PRESS_DURATION; exports.PRESS_SCALE = _chunkE2UGZJBTcjs.PRESS_SCALE; exports.Portal = _chunkLMUPNKPHcjs.Portal; exports.PortalContext = _chunkLMUPNKPHcjs.PortalContext; exports.PortalHost = _chunkLMUPNKPHcjs.PortalHost; exports.PressableFeedback = _chunkE2UGZJBTcjs.PressableFeedback; exports.RELEASE_DURATION = _chunkE2UGZJBTcjs.RELEASE_DURATION; exports.RIPPLE_COVERAGE = _chunkE2UGZJBTcjs.RIPPLE_COVERAGE; exports.RIPPLE_DURATION = _chunkE2UGZJBTcjs.RIPPLE_DURATION; exports.RIPPLE_OPACITY = _chunkE2UGZJBTcjs.RIPPLE_OPACITY; exports.Slot = _chunkE2UGZJBTcjs.Slot; exports.childrenToString = _chunkE2UGZJBTcjs.childrenToString; exports.createRecipe = _chunkE2UGZJBTcjs.createRecipe; exports.createSlotContext = _chunkE2UGZJBTcjs.createSlotContext; exports.mergeProps = _chunkE2UGZJBTcjs.mergeProps; exports.mergeRefs = _chunkE2UGZJBTcjs.mergeRefs; exports.resolveAnimation = _chunkE2UGZJBTcjs.resolveAnimation; exports.resolveSlotAnimation = _chunkE2UGZJBTcjs.resolveSlotAnimation; exports.useFeedback = _chunkE2UGZJBTcjs.useFeedback; exports.useIconContext = _chunkE2UGZJBTcjs.useIconContext;

package/dist/system/index.d.cts

@@ -1,83 +1,265 @@
-import { g as XAUITheme, X as XAUIColors } from '../theme.type-B3ODSLbB.cjs';
-import { ViewStyle, TextStyle } from 'react-native';
-
-/**
- * A slot is a view or a text node, and a recipe writes one object per slot, so the two
- * RN style shapes are merged rather than discriminated per slot.
- */
-type SlotStyle = ViewStyle & TextStyle;
-type SlotStyles<Slot extends string> = Partial<Record<Slot, SlotStyle>>;
-/** The roles a variant consumes. The variant names tokens; `paint` says where they land. */
-type VariantRole = 'bg' | 'bgPressed' | 'fg' | 'border';
-/** Token names per role — no colour value ever appears in a recipe. */
-type VariantTokens = Partial<Record<VariantRole, keyof XAUIColors>>;
-/** The same roles resolved: theme colours, or the slices of a raw `color`. */
-type VariantColors = Partial<Record<VariantRole, string>>;
-/**
- * `disabled` is applied last of the three: a control that is both pressed and disabled
- * has to read disabled.
- */
-type StateName = 'focused' | 'pressed' | 'disabled';
-type States = Partial<Record<StateName, boolean>>;
-/** Reads the theme and the variant's resolved colours; returns one style per slot. */
-type StyleFn<Slot extends string> = (theme: XAUITheme, colors: VariantColors) => SlotStyles<Slot>;
-/** Named axes of finite token values — `{ size: { sm: fn, md: fn } }`. */
-type Axes<Slot extends string> = Record<string, Record<string, StyleFn<Slot>>>;
-/** One value per axis, plus the variant. Missing keys fall back to `defaultVariants`. */
-type Selection<Variant extends string, A extends Axes<string>> = {
-    variant?: Variant;
-} & {
-    [Axis in keyof A]?: Extract<keyof A[Axis], string>;
-};
-type CompoundVariant<Slot extends string, Variant extends string, A extends Axes<Slot>> = {
-    when: Selection<Variant, A>;
-    style: StyleFn<Slot>;
+import * as react from 'react';
+import { Ref, ReactNode, Provider, RefCallback } from 'react';
+import { b as IconProps, a as IconContextValue, S as SlotAnimation, F as FeedbackContext, c as AnimationProp, R as ResolvedAnimation, d as FeedbackVariant } from '../create-recipe-BjSP0zL_.cjs';
+export { A as AnimationConfig, h as Axes, C as CompoundVariant, I as IconComponentProps, P as PressableFeedbackProps, f as Recipe, i as RecipeConfig, g as ResolveArgs, j as ResolvedSelection, k as ResolvedStyles, l as Selection, m as SlotStyle, n as SlotStyles, o as StateName, p as States, q as StyleFn, T as TintArgs, V as VariantColors, r as VariantRole, s as VariantTokens, e as createRecipe } from '../create-recipe-BjSP0zL_.cjs';
+import * as react_native from 'react-native';
+import { StyleProp, ViewStyle } from 'react-native';
+import 'react-native-reanimated';
+import '../theme.type-C9bFJKFm.cjs';
+
+/**
+ * The gap nobody else closes: an icon is a third-party component, so a slot context does
+ * not reach it and every call site ends up computing the colour by hand.
+ *
+ * ```tsx
+ * <Button variant="danger">
+ *   <Button.Icon as={TrashIcon} />   {/* colour and size inherited, nothing to pass *\/}
+ *   <Button.Label>Supprimer</Button.Label>
+ * </Button>
+ * ```
+ *
+ * Three accepted forms — a component through `as`, a raw SVG as children, or an image
+ * through `source` — and the resolution is the same for all three: an explicit prop, else
+ * what the surrounding slot published, else the theme.
+ */
+declare function Icon({ as: Component, children, source, size, color, style, }: IconProps): react.JSX.Element;
+declare namespace Icon {
+    var displayName: string;
+}
+
+/**
+ * Not a `createSlotContext`: that one throws outside its parent, and an `Icon` has to
+ * work on its own as much as inside a `Button`. An empty context is the honest default —
+ * nothing inherited, so the theme decides.
+ */
+declare const IconContext: react.Context<IconContextValue>;
+declare function useIconContext(): IconContextValue;
+
+type PressableFeedbackHighlightProps = {
+    style?: StyleProp<ViewStyle>;
+    /** Overrides the blanket `animation` on the root, for this overlay only. */
+    animation?: SlotAnimation;
 };
-type RecipeConfig<Slot extends string, Variant extends string, A extends Axes<Slot>> = {
-    /** Every slot the component publishes. Slots a recipe never styles resolve to `{}`. */
-    slots: readonly Slot[];
-    base?: StyleFn<Slot>;
-    variantTokens?: Record<Variant, VariantTokens>;
-    /** Where the variant's colours land — written once, and it holds for every variant. */
-    paint?: StyleFn<Slot>;
-    variants?: A;
-    compoundVariants?: ReadonlyArray<CompoundVariant<Slot, Variant, A>>;
-    states?: Partial<Record<StateName, StyleFn<Slot>>>;
-    defaultVariants?: Selection<Variant, A>;
+/**
+ * The press wash: one flat overlay fading in under the finger.
+ *
+ * It is a **neutral** wash, not the variant's pressed colour. A component picks one or
+ * the other — this overlay, or a `pressed` state in its recipe swapping `bg` for
+ * `bgPressed` — never both, or a pressed button darkens twice.
+ */
+declare function PressableFeedbackHighlight({ style, animation: override, }: PressableFeedbackHighlightProps): react.JSX.Element;
+declare namespace PressableFeedbackHighlight {
+    var displayName: string;
+}
+
+type PressableFeedbackRippleProps = {
+    style?: StyleProp<ViewStyle>;
+    /** Overrides the blanket `animation` on the root, for this overlay only. */
+    animation?: SlotAnimation;
 };
-/** Stable references: the same object for the same tokens, for the app's lifetime. */
-type ResolvedStyles<Slot extends string> = Readonly<Record<Slot, SlotStyle>>;
-/** A selection with `defaultVariants` already folded in, keyed by axis name. */
-type ResolvedSelection = Readonly<Record<string, string | undefined>>;
-
-type ResolveArgs<Variant extends string, A extends Axes<string>> = {
-    theme: XAUITheme;
-    selection?: Selection<Variant, A>;
-    states?: States;
+/**
+ * A circle washing outwards from where the finger landed.
+ *
+ * **Two animations, not one, and that is the whole shape of it.** The circle *expands*
+ * once per touch, from the point of contact to past the far corner. Its *opacity* follows
+ * the finger — up on press, held while the press lasts, out on release. Driving both from
+ * one curve is what makes a ripple read wrong: tie opacity to the expansion and the wave
+ * is invisible under the finger and brightest once it covers everything, which is a flash
+ * of the whole control rather than a wave leaving the touch point.
+ *
+ * It needs the root to clip — `PressableFeedback` sets `overflow: 'hidden'` when it
+ * mounts one — and it renders nothing on the static branch: a ripple that cannot expand
+ * is a coloured disc sitting on the control, which reads as a defect rather than as
+ * reduced motion.
+ */
+declare function PressableFeedbackRipple({ style, animation: override, }: PressableFeedbackRippleProps): react.JSX.Element | null;
+declare namespace PressableFeedbackRipple {
+    var displayName: string;
+}
+
+declare const useFeedback: () => FeedbackContext;
+
+/**
+ * The values the v0 tree shipped with (`Animated.spring` to `0.975`, `bounciness: 0`,
+ * over roughly 100ms). Kept identical on purpose: the touch feedback is the part of a
+ * library users feel rather than read, and changing its timing in a rewrite would be a
+ * regression nobody asked for. `bounciness: 0` is why a duration replaces the spring —
+ * a spring with no bounce is a curve.
+ */
+declare const PRESS_SCALE = 0.975;
+declare const PRESS_DURATION = 100;
+declare const RELEASE_DURATION = 150;
+/** How far the wash and the ripple go at full press. */
+declare const HIGHLIGHT_OPACITY = 0.08;
+declare const RIPPLE_OPACITY = 0.12;
+declare const RIPPLE_DURATION = 350;
+/**
+ * The circle's radius as a multiple of the control's diagonal. Above 1 it covers from
+ * any point on the control, so where the finger landed never enters the calculation.
+ */
+declare const RIPPLE_COVERAGE = 1.25;
+/**
+ * One shape out of four accepted ones, so the components read a record instead of
+ * re-deciding what `'disable-all'` meant.
+ *
+ * `inheritedDisableAll` comes from an ancestor that asked for it, and it wins: a list
+ * that switched its rows' animations off cannot be overridden by a row.
+ */
+declare function resolveAnimation(animation: AnimationProp | undefined, inheritedDisableAll?: boolean): ResolvedAnimation;
+type ResolvedSlotAnimation = {
+    enabled: boolean;
+    duration: number;
+    opacity: number;
 };
-type TintArgs<Variant extends string, A extends Axes<string>> = ResolveArgs<Variant, A> & {
-    color: string;
+/**
+ * A slot's own `animation` over the root's blanket one, with the root winning when it
+ * switched everything off — `animation="disable-all"` on an ancestor cannot be undone by
+ * an overlay that asks nicely.
+ */
+declare function resolveSlotAnimation(override: SlotAnimation | undefined, enabledByRoot: boolean, defaultOpacity: number, defaultDuration?: number): ResolvedSlotAnimation;
+
+declare const PressableFeedback: react.ForwardRefExoticComponent<Omit<react_native.PressableProps, "style" | "children" | "disabled"> & {
+    isPressed?: boolean;
+    isDisabled?: boolean;
+    asChild?: boolean;
+    feedbackVariant?: FeedbackVariant;
+    animation?: AnimationProp;
+    style?: react_native.StyleProp<react_native.ViewStyle>;
+    children?: react.ReactNode;
+} & react.RefAttributes<react_native.View>> & {
+    Highlight: typeof PressableFeedbackHighlight;
+    Ripple: typeof PressableFeedbackRipple;
 };
-type Recipe<Slot extends string, Variant extends string, A extends Axes<Slot>> = {
-    readonly slots: readonly Slot[];
-    /** The cached pass: stable `StyleSheet` references, keyed by tokens alone. */
-    resolve(args: ResolveArgs<Variant, A>): ResolvedStyles<Slot>;
+
+/** Anything React accepts as a ref, plus the absence of one. */
+type PossibleRef<T> = Ref<T> | undefined;
+/**
+ * The props `mergeProps` knows how to combine. Deliberately loose: it merges whatever a
+ * root hands to whatever child it was given, and neither side is knowable from here.
+ */
+type MergeableProps = Record<string, unknown>;
+type AsChildProps = {
     /**
-     * The tint pass: the same functions run again with `color`'s slices in place of the
-     * theme's tokens. Uncached and allocating, and only ever called when `color` is set.
+     * Merge this component's props into its single child instead of rendering an element
+     * of its own — a navigation `Link` as a `Button`, a bespoke trigger as a `Select`.
      */
-    tint(args: TintArgs<Variant, A>): SlotStyles<Slot>;
+    asChild?: boolean;
+};
+
+type PortalProps = {
+    children: ReactNode;
 };
 /**
- * A component's style, declared once. Resolution splits in two because the two halves
- * have different lifetimes: everything keyed by a finite token is cached forever, and
- * an arbitrary `color` is recomputed per render — which is what keeps the cache bounded
- * by the number of token combinations rather than by the palette users invent.
+ * Renders its children into the nearest `PortalHost` instead of where it sits. What
+ * `Dialog`, `Sheet`, `Drawer` and `Snackbar` are built on: an overlay has to escape the
+ * clipping and stacking of whatever container happened to hold the trigger.
+ *
+ * Both halves run in layout effects rather than effects, which is deliberate: the content
+ * lands in the same commit as the trigger's, so an overlay neither shows one frame late
+ * nor survives one frame past the unmount that closed it. The unpublish sits in its own
+ * effect so that it does not depend on `children` — a re-publish then keeps the portal's
+ * place in the host's order instead of dropping it and re-adding it at the end.
+ */
+declare function Portal({ children }: PortalProps): null;
+declare namespace Portal {
+    var displayName: string;
+}
+
+type PortalMethods = {
+    addPortal: (key: string, element: ReactNode) => void;
+    removePortal: (key: string) => void;
+};
+/**
+ * `null` outside a host, and `Portal` treats that as "render nothing" rather than
+ * throwing: an app that forgot `PortalHost` should lose its overlays, not crash on the
+ * first `Dialog`.
+ */
+declare const PortalContext: react.Context<PortalMethods | null>;
+
+type PortalHostProps = {
+    children: ReactNode;
+};
+/**
+ * Where every `Portal` in the tree below renders. Mounted once, at the root of the app,
+ * above navigation — an overlay that renders inside a screen is clipped by it.
+ */
+declare function PortalHost({ children }: PortalHostProps): react.JSX.Element;
+declare namespace PortalHost {
+    var displayName: string;
+}
+
+/**
+ * R3: the string a root should wrap in its default text slot, or `null` when it should
+ * render its children as they are.
+ *
+ * The whole tree is stringified recursively rather than the first child inspected. That
+ * is what makes `<Button>{count} items</Button>` work — children there are the array
+ * `[3, ' items']`, and an `isValidElement` check on the first entry would call it an
+ * element-free tree only by accident, while a check for "is the first child a string"
+ * would miss it outright.
+ *
+ * `null` for an empty result as much as for a tree containing an element: in both cases
+ * there is nothing to wrap, and a root's fallback — render the children — is right for
+ * both. It also keeps `<Button>{false}</Button>` from mounting an empty text node.
+ */
+declare function childrenToString(children: ReactNode): string | null;
+
+/**
+ * A context a slot cannot read by accident. Every compound gets one, and it carries
+ * **resolved** values — style references the root already computed, not tokens for the
+ * slot to resolve again (R5).
+ *
+ * ```ts
+ * const [ButtonProvider, useButton] = createSlotContext<ButtonContext>('Button')
+ * ```
+ *
+ * The tuple is what lets each compound name its own hook, which R10 requires it to
+ * export. `name` gives both halves of the error, so there is one place to spell it.
+ */
+declare function createSlotContext<T>(name: string): readonly [Provider<T | null>, () => T];
+
+/**
+ * Merges a root's own props into the child it renders through `asChild` (R12). Four
+ * rules, and the child wins wherever they do not apply — it is the more specific intent:
+ *
+ * - **Event handlers compose.** Both run, ours first: the component's own behaviour (the
+ *   press state that drives its styles) happens before the child's side effect (the
+ *   navigation). Replacing one with the other is the bug this exists to prevent.
+ * - **Styles stack**, ours under the child's, so the child can override.
+ * - **`ref`s merge** through `mergeRefs`. React 19 passes `ref` as an ordinary prop, so
+ *   it arrives here rather than beside the props, and dropping it would sever the root's
+ *   handle on the node.
+ * - **Everything else: the child's value wins**, and ours fills in what it left unset.
+ */
+declare function mergeProps(ours: MergeableProps, theirs: MergeableProps): MergeableProps;
+
+/**
+ * One callback that feeds several refs — what lets a root keep its own handle on a node
+ * while still honouring the ref its caller passed (R9), and what `asChild` needs to
+ * forward a ref into the child it merges into (R12).
+ *
+ * It returns nothing on purpose. React 19 reads a ref callback's return value as a
+ * cleanup function while React 18 ignores it, and this package supports both; letting
+ * a merged cleanup through would behave differently on each. React calls every ref with
+ * `null` on unmount anyway, which this forwards.
+ */
+declare function mergeRefs<T>(...refs: Array<PossibleRef<T>>): RefCallback<T>;
+
+type SlotProps = MergeableProps & {
+    children?: ReactNode;
+};
+/**
+ * The render branch behind `asChild` (R12). A root picks it instead of its own element:
+ *
+ * ```tsx
+ * const Root = asChild ? Slot : Pressable
+ * return <Root ref={ref} {...rootProps}>{children}</Root>
+ * ```
  *
- *     const styles = buttonRecipe.resolve({ theme, selection: { variant, size }, states })
- *     const tint = color ? buttonRecipe.tint({ theme, color, selection, states }) : undefined
- *     <View style={[styles.root, tint?.root, style]} />
+ * One line per root, which is the point — forty-seven roots each hand-rolling a
+ * `cloneElement` and a ref merge would drift, and R12 has to hold uniformly from the
+ * first component or the ref signature of the whole core changes later.
  */
-declare function createRecipe<Slot extends string, Variant extends string, const A extends Axes<Slot>>(config: RecipeConfig<Slot, Variant, A>): Recipe<Slot, Variant, A>;
+declare const Slot: react.ForwardRefExoticComponent<Omit<SlotProps, "ref"> & react.RefAttributes<unknown>>;
 
-export { type Axes, type CompoundVariant, type Recipe, type RecipeConfig, type ResolveArgs, type ResolvedSelection, type ResolvedStyles, type Selection, type SlotStyle, type SlotStyles, type StateName, type States, type StyleFn, type TintArgs, type VariantColors, type VariantRole, type VariantTokens, createRecipe };
+export { AnimationProp, type AsChildProps, FeedbackContext, FeedbackVariant, HIGHLIGHT_OPACITY, Icon, IconContext, IconContextValue, IconProps, type MergeableProps, PRESS_DURATION, PRESS_SCALE, Portal, PortalContext, PortalHost, type PortalHostProps, type PortalMethods, type PortalProps, type PossibleRef, PressableFeedback, type PressableFeedbackHighlightProps, type PressableFeedbackRippleProps, RELEASE_DURATION, RIPPLE_COVERAGE, RIPPLE_DURATION, RIPPLE_OPACITY, ResolvedAnimation, Slot, SlotAnimation, type SlotProps, childrenToString, createSlotContext, mergeProps, mergeRefs, resolveAnimation, resolveSlotAnimation, useFeedback, useIconContext };