@xaui/native 0.9.1-alpha.0 → 0.9.1-alpha.10

package/dist/system/index.cjs

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

package/dist/system/index.d.cts

@@ -0,0 +1,262 @@
+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;
+};
+/**
+ * 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;
+};
+/**
+ * A circle washing outwards from where the finger landed.
+ *
+ * It is a **one-shot, independent of how long the press lasts**: the wave runs its course
+ * and ends, the way a ripple in water does. Tying it to the press would leave a disc
+ * parked on the control for as long as a finger rests there.
+ *
+ * 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;
+};
+/**
+ * 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, "children" | "style" | "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;
+};
+
+/** 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 = {
+    /**
+     * 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`.
+     */
+    asChild?: boolean;
+};
+
+type PortalProps = {
+    children: ReactNode;
+};
+/**
+ * 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>
+ * ```
+ *
+ * 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 const Slot: react.ForwardRefExoticComponent<Omit<SlotProps, "ref"> & react.RefAttributes<unknown>>;
+
+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 };

package/dist/system/index.d.ts

@@ -0,0 +1,262 @@
+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-Dn9kj5Rs.js';
+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-Dn9kj5Rs.js';
+import * as react_native from 'react-native';
+import { StyleProp, ViewStyle } from 'react-native';
+import 'react-native-reanimated';
+import '../theme.type-C9bFJKFm.js';
+
+/**
+ * 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;
+};
+/**
+ * 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;
+};
+/**
+ * A circle washing outwards from where the finger landed.
+ *
+ * It is a **one-shot, independent of how long the press lasts**: the wave runs its course
+ * and ends, the way a ripple in water does. Tying it to the press would leave a disc
+ * parked on the control for as long as a finger rests there.
+ *
+ * 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;
+};
+/**
+ * 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, "children" | "style" | "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;
+};
+
+/** 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 = {
+    /**
+     * 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`.
+     */
+    asChild?: boolean;
+};
+
+type PortalProps = {
+    children: ReactNode;
+};
+/**
+ * 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>
+ * ```
+ *
+ * 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 const Slot: react.ForwardRefExoticComponent<Omit<SlotProps, "ref"> & react.RefAttributes<unknown>>;
+
+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 };

package/dist/system/index.js

@@ -0,0 +1,53 @@
+import {
+  Portal,
+  PortalContext,
+  PortalHost
+} from "../chunk-3TIDEII6.js";
+import {
+  HIGHLIGHT_OPACITY,
+  Icon,
+  IconContext,
+  PRESS_DURATION,
+  PRESS_SCALE,
+  PressableFeedback,
+  RELEASE_DURATION,
+  RIPPLE_COVERAGE,
+  RIPPLE_DURATION,
+  RIPPLE_OPACITY,
+  Slot,
+  childrenToString,
+  createRecipe,
+  createSlotContext,
+  mergeProps,
+  mergeRefs,
+  resolveAnimation,
+  resolveSlotAnimation,
+  useFeedback,
+  useIconContext
+} from "../chunk-66OVPWF4.js";
+import "../chunk-X2K2FX3W.js";
+export {
+  HIGHLIGHT_OPACITY,
+  Icon,
+  IconContext,
+  PRESS_DURATION,
+  PRESS_SCALE,
+  Portal,
+  PortalContext,
+  PortalHost,
+  PressableFeedback,
+  RELEASE_DURATION,
+  RIPPLE_COVERAGE,
+  RIPPLE_DURATION,
+  RIPPLE_OPACITY,
+  Slot,
+  childrenToString,
+  createRecipe,
+  createSlotContext,
+  mergeProps,
+  mergeRefs,
+  resolveAnimation,
+  resolveSlotAnimation,
+  useFeedback,
+  useIconContext
+};

package/dist/theme/index.cjs

@@ -9,13 +9,14 @@
 
 
 
+var _chunk2FEDC7U5cjs = require('../chunk-2FEDC7U5.cjs');
 
 
 
 
-var _chunkJDS6KGCMcjs = require('../chunk-JDS6KGCM.cjs');
 
 
+var _chunk3QBT3Q65cjs = require('../chunk-3QBT3Q65.cjs');
 
 
 
@@ -29,4 +30,7 @@ var _chunkJDS6KGCMcjs = require('../chunk-JDS6KGCM.cjs');
 
 
 
-exports.ThemeContext = _chunkJDS6KGCMcjs.ThemeContext; exports.XAUIProvider = _chunkJDS6KGCMcjs.XAUIProvider; exports.buildRadius = _chunkJDS6KGCMcjs.buildRadius; exports.buildShadows = _chunkJDS6KGCMcjs.buildShadows; exports.createTheme = _chunkJDS6KGCMcjs.createTheme; exports.defaultTheme = _chunkJDS6KGCMcjs.defaultTheme; exports.deriveColors = _chunkJDS6KGCMcjs.deriveColors; exports.palette = _chunkJDS6KGCMcjs.palette; exports.primitives = _chunkJDS6KGCMcjs.primitives; exports.sourceKeys = _chunkJDS6KGCMcjs.sourceKeys; exports.tokens = _chunkJDS6KGCMcjs.tokens; exports.useColorMode = _chunkJDS6KGCMcjs.useColorMode; exports.useThemeColor = _chunkJDS6KGCMcjs.useThemeColor; exports.useXAUITheme = _chunkJDS6KGCMcjs.useXAUITheme;
+
+
+
+exports.ThemeContext = _chunk3QBT3Q65cjs.ThemeContext; exports.XAUIProvider = _chunk2FEDC7U5cjs.XAUIProvider; exports.buildRadius = _chunk2FEDC7U5cjs.buildRadius; exports.buildShadows = _chunk2FEDC7U5cjs.buildShadows; exports.createTheme = _chunk2FEDC7U5cjs.createTheme; exports.defaultTheme = _chunk2FEDC7U5cjs.defaultTheme; exports.deriveColors = _chunk2FEDC7U5cjs.deriveColors; exports.deriveTint = _chunk3QBT3Q65cjs.deriveTint; exports.palette = _chunk2FEDC7U5cjs.palette; exports.primitives = _chunk2FEDC7U5cjs.primitives; exports.sourceKeys = _chunk2FEDC7U5cjs.sourceKeys; exports.tokens = _chunk2FEDC7U5cjs.tokens; exports.useColorMode = _chunk3QBT3Q65cjs.useColorMode; exports.useThemeColor = _chunk3QBT3Q65cjs.useThemeColor; exports.useXAUITheme = _chunk3QBT3Q65cjs.useXAUITheme;