@cdx-ui/components 0.0.1-beta.8 → 0.0.1-beta.80

package/src/components/Chip/styles.ts

@@ -1,52 +1,254 @@
+import { Platform } from 'react-native';
 import { cva, type VariantProps } from 'class-variance-authority';
+import { DISABLED_CURSOR, TRANSITION_COLORS } from '../../styles/primitives';
+
+const chipInteractiveRoot = [
+  TRANSITION_COLORS,
+  'data-[disabled=true]:opacity-[var(--opacity-disabled)]',
+  DISABLED_CURSOR,
+  Platform.select({
+    web: [
+      'outline-none',
+      'web:data-[focus-visible=true]:ring-2 web:data-[focus-visible=true]:ring-stroke-focus web:data-[focus-visible=true]:ring-offset-2',
+    ].join(' '),
+    default: '',
+  }),
+];
 
 export const chipRootVariants = cva(
-  ['flex-row items-center justify-center rounded-full px-2 py-1 gap-1.5 self-start'],
+  ['flex-row items-center justify-center self-start overflow-hidden', ...chipInteractiveRoot],
   {
     variants: {
+      variant: {
+        tint: [],
+        outline: ['bg-transparent', 'border'],
+      },
       color: {
-        default: 'bg-surface-neutral-tint',
-        error: 'bg-surface-danger-tint',
-        info: 'bg-surface-info-tint',
-        success: 'bg-surface-success-tint',
-        warning: 'bg-surface-warning-tint',
+        default: [],
+        action: [],
+        danger: [],
+        warning: [],
+        success: [],
+        info: [],
+      },
+      size: {
+        default: 'h-8 max-h-8 min-h-8 gap-1.5 px-3 rounded-lg',
+        small: 'h-6 max-h-6 min-h-6 gap-1 px-1.5 rounded-md',
+        xsmall: 'h-4 max-h-4 min-h-4 gap-0.5 px-1 rounded-sm',
       },
     },
+    compoundVariants: [
+      // ── tint × color ────────────────────────────────────────────────────
+      {
+        variant: 'tint',
+        color: 'default',
+        className: [
+          'bg-surface-neutral-tint',
+          Platform.select({
+            default: 'data-[active=true]:bg-surface-neutral-tint-active',
+            web: 'data-[hover=true]:bg-surface-neutral-tint-hover data-[active=true]:data-[hover=true]:bg-surface-neutral-tint-active',
+          }),
+        ],
+      },
+      {
+        variant: 'tint',
+        color: 'action',
+        className: [
+          'bg-surface-action-tint',
+          Platform.select({
+            default: 'data-[active=true]:bg-surface-action-tint-active',
+            web: 'data-[hover=true]:bg-surface-action-tint-hover data-[active=true]:data-[hover=true]:bg-surface-action-tint-active',
+          }),
+        ],
+      },
+      {
+        variant: 'tint',
+        color: 'danger',
+        className: [
+          'bg-surface-danger-tint',
+          Platform.select({
+            default: 'data-[active=true]:bg-surface-danger-tint-active',
+            web: 'data-[hover=true]:bg-surface-danger-tint-hover data-[active=true]:data-[hover=true]:bg-surface-danger-tint-active',
+          }),
+        ],
+      },
+      {
+        variant: 'tint',
+        color: 'warning',
+        className: [
+          'bg-surface-warning-tint',
+          Platform.select({
+            default: 'data-[active=true]:bg-surface-warning-tint-active',
+            web: 'data-[hover=true]:bg-surface-warning-tint-hover data-[active=true]:data-[hover=true]:bg-surface-warning-tint-active',
+          }),
+        ],
+      },
+      {
+        variant: 'tint',
+        color: 'success',
+        className: [
+          'bg-surface-success-tint',
+          Platform.select({
+            default: 'data-[active=true]:bg-surface-success-tint-active',
+            web: 'data-[hover=true]:bg-surface-success-tint-hover data-[active=true]:data-[hover=true]:bg-surface-success-tint-active',
+          }),
+        ],
+      },
+      {
+        variant: 'tint',
+        color: 'info',
+        className: [
+          'bg-surface-info-tint',
+          Platform.select({
+            default: 'data-[active=true]:bg-surface-info-tint-active',
+            web: 'data-[hover=true]:bg-surface-info-tint-hover data-[active=true]:data-[hover=true]:bg-surface-info-tint-active',
+          }),
+        ],
+      },
+
+      // ── outline × color ───────────────────────────────────────────────────
+      {
+        variant: 'outline',
+        color: 'default',
+        className: [
+          'border-stroke-primary',
+          Platform.select({
+            default: 'data-[active=true]:bg-surface-neutral-tint',
+            web: 'data-[hover=true]:bg-surface-neutral-tint-hover data-[active=true]:data-[hover=true]:bg-surface-neutral-tint-active',
+          }),
+        ],
+      },
+      {
+        variant: 'outline',
+        color: 'action',
+        className: [
+          'border-stroke-action',
+          Platform.select({
+            default: 'data-[active=true]:bg-surface-action-tint',
+            web: 'data-[hover=true]:bg-surface-action-tint-hover data-[active=true]:data-[hover=true]:bg-surface-action-tint-active',
+          }),
+        ],
+      },
+      {
+        variant: 'outline',
+        color: 'danger',
+        className: [
+          'border-stroke-danger',
+          Platform.select({
+            default: 'data-[active=true]:bg-surface-danger-tint',
+            web: 'data-[hover=true]:bg-surface-danger-tint-hover data-[active=true]:data-[hover=true]:bg-surface-danger-tint-active',
+          }),
+        ],
+      },
+      {
+        variant: 'outline',
+        color: 'warning',
+        className: [
+          'border-stroke-warning',
+          Platform.select({
+            default: 'data-[active=true]:bg-surface-warning-tint',
+            web: 'data-[hover=true]:bg-surface-warning-tint-hover data-[active=true]:data-[hover=true]:bg-surface-warning-tint-active',
+          }),
+        ],
+      },
+      {
+        variant: 'outline',
+        color: 'success',
+        className: [
+          'border-stroke-success',
+          Platform.select({
+            default: 'data-[active=true]:bg-surface-success-tint',
+            web: 'data-[hover=true]:bg-surface-success-tint-hover data-[active=true]:data-[hover=true]:bg-surface-success-tint-active',
+          }),
+        ],
+      },
+      {
+        variant: 'outline',
+        color: 'info',
+        className: [
+          'border-stroke-info',
+          Platform.select({
+            default: 'data-[active=true]:bg-surface-info-tint',
+            web: 'data-[hover=true]:bg-surface-info-tint-hover data-[active=true]:data-[hover=true]:bg-surface-info-tint-active',
+          }),
+        ],
+      },
+    ],
     defaultVariants: {
+      variant: 'tint',
       color: 'default',
+      size: 'default',
     },
   },
 );
 
-// TODO: letter-spacing values (tracking-wider) are not working on web, but the font-mono-medium is.
-export const chipLabelVariants = cva(['label-sm font-mono-medium'], {
+export const chipLabelVariants = cva(['font-sans-medium'], {
   variants: {
+    variant: {
+      tint: 'text-content-primary',
+      outline: 'text-content-primary',
+    },
     color: {
-      default: 'text-content-primary',
-      error: 'text-content-primary',
-      info: 'text-content-primary',
-      success: 'text-content-primary',
-      warning: 'text-content-primary',
+      default: [],
+      action: [],
+      danger: [],
+      warning: [],
+      success: [],
+      info: [],
+    },
+    size: {
+      default: 'body-md',
+      small: 'body-sm',
+      xsmall: 'body-xs',
     },
   },
+  compoundVariants: [
+    { variant: 'outline', color: 'action', className: 'text-content-action' },
+    { variant: 'outline', color: 'danger', className: 'text-content-danger' },
+    { variant: 'outline', color: 'warning', className: 'text-content-warning' },
+    { variant: 'outline', color: 'success', className: 'text-content-success' },
+    { variant: 'outline', color: 'info', className: 'text-content-info' },
+  ],
   defaultVariants: {
+    variant: 'tint',
     color: 'default',
+    size: 'default',
   },
 });
 
-export const chipIconVariants = cva(['size-4'], {
+export const chipIconVariants = cva(['shrink-0'], {
   variants: {
+    size: {
+      default: 'size-5 data-[icon=inline-start]:-ms-1.5 data-[icon=inline-end]:-me-1.5',
+      small: 'size-4 data-[icon=inline-start]:-ms-0.5 data-[icon=inline-end]:-me-0.5',
+      xsmall: 'size-2.5 data-[icon=inline-start]:-ms-px data-[icon=inline-end]:-me-px',
+    },
     color: {
       default: 'text-content-primary',
-      error: 'text-content-danger',
-      info: 'text-content-info',
-      success: 'text-content-success',
+      action: 'text-content-action',
+      danger: 'text-content-danger',
       warning: 'text-content-warning',
+      success: 'text-content-success',
+      info: 'text-content-info',
     },
   },
   defaultVariants: {
+    size: 'default',
     color: 'default',
   },
 });
 
-export type ChipVariants = VariantProps<typeof chipRootVariants>;
+export const chipAvatarVariants = cva(['shrink-0 rounded-full overflow-hidden'], {
+  variants: {
+    size: {
+      default: 'size-5 -ms-1.5',
+      small: 'size-4 -ms-0.5',
+      xsmall: 'size-2.5 -ms-px',
+    },
+  },
+  defaultVariants: {
+    size: 'default',
+  },
+});
+
+export type ChipVariantProps = VariantProps<typeof chipRootVariants>;

package/src/components/CurrencyInput/index.tsx

@@ -0,0 +1,192 @@
+import { forwardRef, useState } from 'react';
+import { type TextInput, type TextInputProps, type ViewProps } from 'react-native';
+import {
+  InputField as InputFieldPrimitive,
+  InputRoot as InputRootPrimitive,
+  dataAttributes,
+  type IInputFieldProps,
+} from '@cdx-ui/primitives';
+import { cn } from '@cdx-ui/utils';
+import {
+  type CurrencyInputVariantProps,
+  currencyInputFieldVariants,
+  currencyInputRootVariants,
+} from './styles';
+
+// Hoisted at module scope — Intl instantiation is expensive (parses locale data).
+const currencyFormatter = new Intl.NumberFormat('en-US', {
+  minimumFractionDigits: 2,
+  maximumFractionDigits: 2,
+});
+
+// Cap the accumulated cents to 15 digits so the integer stays below
+// Number.MAX_SAFE_INTEGER (16 digits). Past that, parsing loses precision and the
+// amount garbles or resets — 15 digits already allows up to $9,999,999,999,999.99.
+const MAX_DIGITS = 15;
+
+function centsToAmountDisplay(cents: number): string {
+  return currencyFormatter.format(cents / 100);
+}
+
+function valueToCents(value: number | undefined | null): number {
+  return Math.round((value ?? 0) * 100);
+}
+
+export interface CurrencyInputProps
+  extends
+    IInputFieldProps,
+    CurrencyInputVariantProps,
+    Pick<
+      TextInputProps,
+      'accessibilityLabel' | 'accessibilityHint' | 'testID' | 'onFocus' | 'onBlur'
+    > {
+  /** Current numeric value. Renders formatted zero when undefined or null. */
+  value?: number;
+  /** Called with the parsed number when the user changes the amount. */
+  onChangeValue?: (value: number) => void;
+  /** Currency symbol rendered as an inline prefix. Defaults to `"$"`. */
+  currencySymbol?: string;
+  className?: string;
+  style?: ViewProps['style'];
+}
+
+export const CurrencyInput = forwardRef<TextInput, CurrencyInputProps>(
+  (
+    {
+      value,
+      onChangeValue,
+      currencySymbol = '$',
+      size = 'default',
+      isDisabled,
+      isInvalid,
+      isReadOnly,
+      isRequired,
+      isFocused,
+      isHovered,
+      isFullWidth,
+      className,
+      style,
+      accessibilityLabel,
+      accessibilityHint,
+      testID,
+      onFocus,
+      onBlur,
+    },
+    ref,
+  ) => {
+    // null = display mode; number = active editing cents.
+    // Calculator-style cents accumulation: digits are always extracted from whatever
+    // the user types, interpreted as integer cents, then reformatted. The caret is
+    // kept at the end at all times so entry behaves like a banking amount pad — new
+    // digits append, backspace removes the rightmost digit.
+    const [editingCents, setEditingCents] = useState<number | null>(null);
+
+    // Controlled caret, pinned to the end of the formatted string. `undefined` in
+    // display mode so we never fight the platform when the field is not being edited.
+    const [selection, setSelection] = useState<{ start: number; end: number }>();
+
+    type FocusHandler = NonNullable<TextInputProps['onFocus']>;
+    type BlurHandler = NonNullable<TextInputProps['onBlur']>;
+    type SelectionChangeHandler = NonNullable<TextInputProps['onSelectionChange']>;
+
+    const displayCents = editingCents !== null ? editingCents : valueToCents(value);
+    const amountDisplay = centsToAmountDisplay(displayCents);
+    const fullDisplay = `${currencySymbol}${amountDisplay}`;
+    const isEmpty = displayCents === 0;
+
+    // Index just past the last character of the formatted string for a given cents.
+    // Computed from `cents` (not the render-closure `fullDisplay`) so the caret is
+    // correct in the same commit as a value change, even when a reformat adds or
+    // removes a grouping comma (e.g. 444.44 → 3,444.44) and changes the length.
+    const caretIndexFor = (cents: number) =>
+      `${currencySymbol}${centsToAmountDisplay(cents)}`.length;
+
+    const pinCaret = (end: number) => setSelection({ start: end, end });
+
+    const handleFocus: FocusHandler = (e) => {
+      // Initialise from the current value so existing amounts are preserved on focus.
+      const cents = valueToCents(value);
+      setEditingCents(cents);
+      pinCaret(caretIndexFor(cents));
+      onFocus?.(e);
+    };
+
+    const handleBlur: BlurHandler = (e) => {
+      setEditingCents(null);
+      setSelection(undefined);
+      onBlur?.(e);
+    };
+
+    const handleChangeText = (text: string) => {
+      // Extract only digit characters, interpret the resulting integer as cents.
+      // e.g. user typing '1' after '0.00' → digits '0001' → 1 cent → 0.01
+      // Backspace on '1.23' → '1.2' → digits '12' → 12 cents → 0.12
+      // Digits past the cap are dropped, so extra keystrokes are ignored rather
+      // than overflowing into an unsafe integer.
+      const digits = text.replace(/\D/g, '').slice(0, MAX_DIGITS);
+      const cents = parseInt(digits || '0', 10);
+      setEditingCents(cents);
+      pinCaret(caretIndexFor(cents));
+      onChangeValue?.(cents / 100);
+    };
+
+    const handleSelectionChange: SelectionChangeHandler = (e) => {
+      // Re-pin the caret to the end ONLY when it drifts to the LEFT of the end while
+      // editing — e.g. web hardware-keyboard arrow keys or a click/tap into the middle
+      // (native decimal-pad keyboards have no arrow keys, so those platforms rarely
+      // trigger this). Value-driven changes already pin the caret via
+      // `handleChangeText`/`handleFocus`.
+      //
+      // Crucially we do NOT touch the caret when it sits at or past the last-rendered
+      // end. While typing, the native caret momentarily lands one past our last render
+      // (the new value hasn't committed yet); re-pinning there would tug it back to the
+      // stale, one-shorter end and yank it one position left — the classic controlled-
+      // selection race. Ignoring forward positions sidesteps that entirely, and also
+      // prevents a feedback loop (the pin re-emits a selectionChange already at the end).
+      if (editingCents === null) {
+        return;
+      }
+      const end = fullDisplay.length;
+      const { selection: current } = e.nativeEvent;
+      if (current.end < end) {
+        pinCaret(end);
+      }
+    };
+
+    return (
+      <InputRootPrimitive
+        isDisabled={isDisabled}
+        isInvalid={isInvalid}
+        isReadOnly={isReadOnly}
+        isRequired={isRequired}
+        isFocused={isFocused}
+        isHovered={isHovered}
+        isFullWidth={isFullWidth}
+        className={cn(currencyInputRootVariants({ size }), className)}
+        style={style}
+        {...dataAttributes({ slot: 'currency-input' })}
+      >
+        <InputFieldPrimitive
+          ref={ref}
+          value={fullDisplay}
+          selection={selection}
+          onChangeText={handleChangeText}
+          onSelectionChange={handleSelectionChange}
+          keyboardType="decimal-pad"
+          accessibilityLabel={accessibilityLabel}
+          accessibilityHint={accessibilityHint}
+          accessibilityValue={{ text: fullDisplay }}
+          testID={testID}
+          onFocus={handleFocus}
+          onBlur={handleBlur}
+          className={cn(
+            currencyInputFieldVariants({ size }),
+            isEmpty ? 'text-content-tertiary' : 'text-content-primary',
+          )}
+        />
+      </InputRootPrimitive>
+    );
+  },
+);
+
+CurrencyInput.displayName = 'CurrencyInput';

package/src/components/CurrencyInput/styles.ts

@@ -0,0 +1,44 @@
+import { cva, type VariantProps } from 'class-variance-authority';
+import { DISABLED_CURSOR } from '../../styles/primitives';
+
+export const currencyInputRootVariants = cva(
+  [
+    'w-full items-center justify-center',
+    'data-[disabled=true]:opacity-[var(--opacity-disabled)]',
+    DISABLED_CURSOR,
+    'data-[readonly=true]:cursor-default',
+  ],
+  {
+    variants: {
+      size: {
+        default: 'py-1',
+        small: 'py-0.5',
+      },
+    },
+    defaultVariants: {
+      size: 'default',
+    },
+  },
+);
+
+export const currencyInputFieldVariants = cva(
+  [
+    'w-full bg-transparent p-0 text-center',
+    'placeholder:text-content-tertiary',
+    'web:outline-none',
+    'data-[invalid=true]:text-content-danger',
+  ],
+  {
+    variants: {
+      size: {
+        default: 'heading-xl',
+        small: 'heading-lg',
+      },
+    },
+    defaultVariants: {
+      size: 'default',
+    },
+  },
+);
+
+export type CurrencyInputVariantProps = VariantProps<typeof currencyInputRootVariants>;