react-native-molecules 0.5.0-beta.2 → 0.5.0-beta.21

package/components/DatePicker/DatePickerActions.tsx

@@ -0,0 +1,73 @@
+import { useCallback } from 'react';
+import { View } from 'react-native';
+import { StyleSheet } from 'react-native-unistyles';
+
+import {
+    getRegisteredComponentStylesWithFallback,
+    getRegisteredComponentWithFallback,
+} from '../../core';
+import { Button } from '../Button';
+import { useDatePickerContext } from './context';
+
+export type DatePickerActionsProps = {
+    cancelLabel?: string;
+    confirmLabel?: string;
+    onCancel?: () => void;
+    onConfirm?: () => void;
+};
+
+function DatePickerActionsDefault({
+    cancelLabel = 'Cancel',
+    confirmLabel = 'OK',
+    onCancel,
+    onConfirm,
+}: DatePickerActionsProps) {
+    const { draft, commit, cancel } = useDatePickerContext();
+
+    const handleCancel = useCallback(() => {
+        onCancel?.();
+        cancel();
+    }, [onCancel, cancel]);
+
+    const handleConfirm = useCallback(() => {
+        onConfirm?.();
+        commit();
+    }, [onConfirm, commit]);
+
+    if (!draft) return null;
+
+    return (
+        <View style={datePickerActionsStyles.footer}>
+            <Button variant="text" onPress={handleCancel}>
+                <Button.Text>{cancelLabel}</Button.Text>
+            </Button>
+            <Button variant="text" onPress={handleConfirm}>
+                <Button.Text>{confirmLabel}</Button.Text>
+            </Button>
+        </View>
+    );
+}
+
+export default DatePickerActionsDefault;
+
+export const DatePickerActions = getRegisteredComponentWithFallback(
+    'DatePickerActions',
+    DatePickerActionsDefault,
+);
+
+const datePickerActionsStylesDefault = StyleSheet.create(theme => ({
+    footer: {
+        flexDirection: 'row',
+        alignItems: 'center',
+        justifyContent: 'flex-end',
+        columnGap: theme.spacings['2'],
+        paddingHorizontal: theme.spacings['4'],
+        paddingTop: theme.spacings['0'],
+        paddingBottom: theme.spacings['2'],
+    },
+}));
+
+const datePickerActionsStyles = getRegisteredComponentStylesWithFallback(
+    'DatePickerActions',
+    datePickerActionsStylesDefault,
+);

package/components/DatePicker/DatePickerModal.tsx

@@ -0,0 +1,245 @@
+import type { ReactNode } from 'react';
+import { memo, useCallback, useMemo, useState } from 'react';
+import {
+    Platform,
+    StatusBar,
+    type StatusBarStyle,
+    StyleSheet,
+    useWindowDimensions,
+    View,
+} from 'react-native';
+
+import { getRegisteredComponentWithFallback } from '../../core';
+import { DateField } from '../DateField';
+import { IconButton } from '../IconButton';
+import { Modal, type ModalProps } from '../Modal';
+import { Portal } from '../Portal';
+import { Text } from '../Text';
+import { TextInput } from '../TextInput';
+import type { DatePickerContextType, DatePickerLocale, DatePickerValue } from './context';
+import {
+    DatePickerContext,
+    useDatePickerContext,
+    useOptionalDatePickerContext,
+    withDraftLayer,
+} from './context';
+import { DateCalendar } from './DateCalendar';
+import { DatePickerActions } from './DatePickerActions';
+import { DatePickerProvider } from './DatePickerProvider';
+import { datePickerModalStyles } from './utils';
+
+export type DatePickerModalProps = Omit<ModalProps, 'children' | 'isOpen' | 'onClose'> & {
+    children?: ReactNode;
+    isOpen?: boolean;
+    onClose?: () => void;
+    value?: DatePickerValue;
+    onChange?: (value: DatePickerValue) => void;
+    label?: string;
+    disableStatusBar?: boolean;
+    disableStatusBarPadding?: boolean;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    editIcon?: string;
+    calendarIcon?: string;
+    emptySummaryLabel?: string;
+    editingSummaryLabel?: string;
+    dateInputLabel?: string;
+    showCalendarAccessibilityLabel?: string;
+    enterDateManuallyAccessibilityLabel?: string;
+    locale?: DatePickerLocale;
+    headerLayout?: 'inline' | 'docked';
+    /** Override the surface default draft mode. Modal defaults to `true` (staged commit). */
+    draft?: boolean;
+};
+
+type BodyProps = Omit<DatePickerModalProps, 'isOpen' | 'onClose' | 'value' | 'onChange' | 'draft'>;
+
+function DatePickerModalBody({
+    children,
+    style,
+    label = 'Select date',
+    disableStatusBar,
+    disableStatusBarPadding,
+    confirmLabel = 'OK',
+    cancelLabel = 'Cancel',
+    editIcon = 'pencil',
+    calendarIcon = 'calendar',
+    emptySummaryLabel = 'Select date',
+    editingSummaryLabel = 'Enter dates',
+    dateInputLabel = 'Date',
+    showCalendarAccessibilityLabel = 'Show calendar',
+    enterDateManuallyAccessibilityLabel = 'Enter date manually',
+    headerLayout,
+    ...rest
+}: BodyProps) {
+    const ctx = useDatePickerContext();
+    const dimensions = useWindowDimensions();
+    const [editing, setEditing] = useState(false);
+
+    const { containerStyle, headerStyle, barStyle, modalStyle } = useMemo(() => {
+        const isHeaderBackgroundLight = true;
+        return {
+            containerStyle: [StyleSheet.absoluteFill, styles.container],
+            headerStyle: [
+                datePickerModalStyles.headlineContainer,
+                {
+                    paddingTop:
+                        disableStatusBarPadding || Platform.OS !== 'android'
+                            ? datePickerModalStyles.headlineContainer.paddingTop
+                            : (datePickerModalStyles.headlineContainer.paddingTop as number) +
+                              (StatusBar.currentHeight || 0),
+                },
+            ],
+            barStyle: (isHeaderBackgroundLight
+                ? 'dark-content'
+                : 'light-content') as StatusBarStyle,
+            modalStyle: [
+                datePickerModalStyles.content,
+                dimensions.width > 650 ? { maxHeight: 600 } : { borderRadius: 0 },
+                style,
+            ],
+        };
+    }, [dimensions.width, disableStatusBarPadding, style]);
+
+    const draft =
+        ctx.draftValue && typeof ctx.draftValue === 'object' && 'start' in ctx.draftValue
+            ? null
+            : ctx.draftValue;
+
+    const summaryLabel = useMemo(() => {
+        if (editing) return editingSummaryLabel;
+        if (!draft) return emptySummaryLabel;
+        return new Intl.DateTimeFormat(ctx.locale, {
+            weekday: 'short',
+            month: 'short',
+            day: 'numeric',
+        }).format(draft);
+    }, [ctx.locale, draft, editing, editingSummaryLabel, emptySummaryLabel]);
+
+    const body = editing ? (
+        <View style={datePickerModalStyles.inputContainer}>
+            <DateField autoFocus>
+                <TextInput.Label>{dateInputLabel}</TextInput.Label>
+            </DateField>
+        </View>
+    ) : (
+        children ?? <DateCalendar headerLayout={headerLayout} showOutsideDays={false} />
+    );
+
+    return (
+        <View style={containerStyle} pointerEvents="box-none">
+            <Portal>
+                <Modal
+                    {...rest}
+                    isOpen={ctx.open}
+                    onClose={ctx.cancel}
+                    style={modalStyle}
+                    elevation={0}>
+                    <>
+                        {disableStatusBar ? null : (
+                            <StatusBar translucent={true} barStyle={barStyle} />
+                        )}
+                        <View style={datePickerModalStyles.frame}>
+                            <View style={headerStyle}>
+                                <View style={datePickerModalStyles.headerCopy}>
+                                    <Text style={datePickerModalStyles.headline}>{label}</Text>
+                                    <Text
+                                        style={datePickerModalStyles.supporting}
+                                        numberOfLines={1}
+                                        adjustsFontSizeToFit={true}>
+                                        {summaryLabel}
+                                    </Text>
+                                </View>
+                                <IconButton
+                                    name={editing ? calendarIcon : editIcon}
+                                    accessibilityLabel={
+                                        editing
+                                            ? showCalendarAccessibilityLabel
+                                            : enterDateManuallyAccessibilityLabel
+                                    }
+                                    onPress={() => setEditing(prev => !prev)}
+                                    style={datePickerModalStyles.modeToggle}
+                                />
+                            </View>
+                            <View style={datePickerModalStyles.body}>{body}</View>
+                            <DatePickerActions
+                                cancelLabel={cancelLabel}
+                                confirmLabel={confirmLabel}
+                            />
+                        </View>
+                    </>
+                </Modal>
+            </Portal>
+        </View>
+    );
+}
+
+function DatePickerModalLayer({
+    base,
+    draft: draftProp,
+    ...rest
+}: BodyProps & {
+    base: DatePickerContextType;
+    draft: boolean | undefined;
+}) {
+    const effectiveDraft = draftProp ?? base.providerDraft ?? true;
+    const ctx = useMemo(() => withDraftLayer(base, effectiveDraft), [base, effectiveDraft]);
+    if (!base.open) return null;
+    return (
+        <DatePickerContext value={ctx}>
+            <DatePickerModalBody {...rest} />
+        </DatePickerContext>
+    );
+}
+
+function DatePickerModalAdapter({ draft, ...rest }: BodyProps & { draft: boolean | undefined }) {
+    const base = useDatePickerContext();
+    return <DatePickerModalLayer base={base} draft={draft} {...rest} />;
+}
+
+function DatePickerModalInner({
+    isOpen: isOpenProp,
+    onClose: onCloseProp,
+    value: valueProp,
+    onChange: onChangeProp,
+    locale,
+    draft: draftProp,
+    ...rest
+}: DatePickerModalProps) {
+    const outer = useOptionalDatePickerContext();
+
+    const onOpenChange = useCallback(
+        (next: boolean) => {
+            if (!next) onCloseProp?.();
+        },
+        [onCloseProp],
+    );
+
+    if (outer) {
+        return <DatePickerModalLayer base={outer} draft={draftProp} {...rest} />;
+    }
+
+    return (
+        <DatePickerProvider
+            value={valueProp}
+            onChange={onChangeProp}
+            open={isOpenProp}
+            locale={locale}
+            onOpenChange={onOpenChange}>
+            <DatePickerModalAdapter draft={draftProp} {...rest} />
+        </DatePickerProvider>
+    );
+}
+
+const styles = StyleSheet.create({
+    container: { backgroundColor: 'transparent' },
+});
+
+const DatePickerModalDefault = memo(DatePickerModalInner);
+
+export default DatePickerModalDefault;
+
+export const DatePickerModal = getRegisteredComponentWithFallback(
+    'DatePickerModal',
+    DatePickerModalDefault,
+);

package/components/DatePicker/DatePickerPopover.tsx

@@ -0,0 +1,79 @@
+import type { ReactNode, RefObject } from 'react';
+import { memo, useMemo } from 'react';
+import { View } from 'react-native';
+import { StyleSheet } from 'react-native-unistyles';
+
+import { getRegisteredComponentWithFallback } from '../../core';
+import { Popover, type PopoverProps } from '../Popover';
+import { DatePickerContext, useOptionalDatePickerContext, withDraftLayer } from './context';
+import { DatePickerActions } from './DatePickerActions';
+
+export type DatePickerPopoverProps = Omit<
+    PopoverProps,
+    'children' | 'triggerRef' | 'isOpen' | 'onClose'
+> & {
+    children: ReactNode;
+    triggerRef?: RefObject<any>;
+    isOpen?: boolean;
+    onClose?: () => void;
+    /** Override the surface default draft mode. Popover defaults to `false` (auto-save). */
+    draft?: boolean;
+};
+
+function DatePickerPopoverInner({
+    children,
+    triggerRef: triggerRefProp,
+    isOpen: isOpenProp,
+    onClose: onCloseProp,
+    draft: draftProp,
+    ...rest
+}: DatePickerPopoverProps) {
+    const base = useOptionalDatePickerContext();
+
+    const effectiveDraft = draftProp ?? base?.providerDraft ?? false;
+    const ctx = useMemo(
+        () => (base ? withDraftLayer(base, effectiveDraft) : null),
+        [base, effectiveDraft],
+    );
+
+    const triggerRef = triggerRefProp ?? ctx?.triggerRef;
+    const isOpen = isOpenProp ?? ctx?.open ?? false;
+    const onClose = onCloseProp ?? (() => ctx?.setOpen(false));
+
+    if (!triggerRef || !ctx) return null;
+
+    return (
+        <DatePickerContext value={ctx}>
+            <Popover
+                align="end"
+                position="bottom"
+                offset={20}
+                {...rest}
+                style={[styles.popover, rest.style]}
+                triggerRef={triggerRef}
+                isOpen={isOpen}
+                onClose={onClose}>
+                <View>
+                    {children}
+                    <DatePickerActions />
+                </View>
+            </Popover>
+        </DatePickerContext>
+    );
+}
+
+const styles = StyleSheet.create(theme => ({
+    popover: {
+        borderRadius: theme.shapes.corner.large,
+        overflow: 'hidden',
+    },
+}));
+
+const DatePickerPopoverDefault = memo(DatePickerPopoverInner);
+
+export default DatePickerPopoverDefault;
+
+export const DatePickerPopover = getRegisteredComponentWithFallback(
+    'DatePickerPopover',
+    DatePickerPopoverDefault,
+);

package/components/DatePicker/DatePickerProvider.tsx

@@ -0,0 +1,158 @@
+import type { ReactNode } from 'react';
+import { memo, useCallback, useMemo, useRef, useState } from 'react';
+
+import { getRegisteredComponentWithFallback } from '../../core';
+import { useControlledValue } from '../../hooks';
+import type { ValidRangeType } from '../DatePickerInline';
+import type {
+    DatePickerContextType,
+    DatePickerLocale,
+    DatePickerMode,
+    DatePickerValue,
+    RangeValue,
+} from './context';
+import { DatePickerContext, withDraftLayer } from './context';
+
+const DATE_FORMAT_BY_MODE: Record<DatePickerMode, string> = {
+    date: 'dd/MM/yyyy',
+    time: 'HH:mm',
+    datetime: 'dd/MM/yyyy HH:mm',
+    range: 'dd/MM/yyyy',
+};
+
+const emptyRange: RangeValue = { start: null, end: null };
+
+const nullValueFor = (mode: DatePickerMode): DatePickerValue =>
+    mode === 'range' ? emptyRange : null;
+
+export type DatePickerProviderProps = {
+    mode?: DatePickerMode;
+    value?: DatePickerValue;
+    defaultValue?: DatePickerValue;
+    onChange?: (value: DatePickerValue) => void;
+
+    draft?: boolean;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+
+    locale?: DatePickerLocale;
+    validRange?: ValidRangeType;
+    is24Hour?: boolean;
+    dateFormat?: string;
+    disabled?: boolean;
+
+    children: ReactNode;
+};
+
+function DatePickerProviderInner({
+    mode = 'date',
+    value: valueProp,
+    defaultValue,
+    onChange,
+    draft: draftProp,
+    open: openProp,
+    defaultOpen = false,
+    onOpenChange,
+    locale,
+    validRange,
+    is24Hour = false,
+    dateFormat,
+    disabled,
+    children,
+}: DatePickerProviderProps) {
+    const triggerRef = useRef<any>(null);
+
+    const [value, setCommittedValue] = useControlledValue<DatePickerValue>({
+        value: valueProp,
+        defaultValue: defaultValue ?? nullValueFor(mode),
+        onChange,
+    });
+
+    const [open, setOpen] = useControlledValue<boolean>({
+        value: openProp,
+        defaultValue: defaultOpen,
+        onChange: onOpenChange,
+    });
+
+    const [draftBuffer, setDraftBuffer] = useState<DatePickerValue>(value);
+
+    const prevOpenRef = useRef(open);
+    const prevValueRef = useRef(value);
+
+    if (open && !prevOpenRef.current && draftBuffer !== value) {
+        setDraftBuffer(value);
+    }
+    if (prevValueRef.current !== value && draftBuffer !== value) {
+        setDraftBuffer(value);
+    }
+    prevOpenRef.current = open;
+    prevValueRef.current = value;
+
+    const commitValue = useCallback(
+        (next: DatePickerValue) => {
+            setCommittedValue(next);
+            setDraftBuffer(next);
+        },
+        [setCommittedValue],
+    );
+
+    const resolvedFormat = dateFormat ?? DATE_FORMAT_BY_MODE[mode];
+    const defaultDraft = draftProp ?? true;
+
+    const ctx = useMemo<DatePickerContextType>(() => {
+        const base: DatePickerContextType = {
+            mode,
+            value,
+            draftBuffer,
+            setCommittedValue,
+            setDraftBuffer,
+            providerDraft: draftProp,
+
+            // Placeholders — withDraftLayer rebuilds these.
+            draft: defaultDraft,
+            draftValue: value,
+            setValue: () => {},
+            commit: () => {},
+            cancel: () => {},
+
+            commitValue,
+
+            open,
+            setOpen,
+            triggerRef,
+            locale,
+            validRange,
+            is24Hour,
+            dateFormat: resolvedFormat,
+            disabled,
+        };
+        return withDraftLayer(base, defaultDraft);
+    }, [
+        mode,
+        value,
+        draftBuffer,
+        setCommittedValue,
+        draftProp,
+        defaultDraft,
+        commitValue,
+        open,
+        setOpen,
+        locale,
+        validRange,
+        is24Hour,
+        resolvedFormat,
+        disabled,
+    ]);
+
+    return <DatePickerContext value={ctx}>{children}</DatePickerContext>;
+}
+
+const DatePickerProviderDefault = memo(DatePickerProviderInner);
+
+export default DatePickerProviderDefault;
+
+export const DatePickerProvider = getRegisteredComponentWithFallback(
+    'DatePickerProvider',
+    DatePickerProviderDefault,
+);

package/components/DatePicker/DatePickerTrigger.tsx

@@ -0,0 +1,23 @@
+import type { ReactElement } from 'react';
+import { memo, useCallback } from 'react';
+
+import { getRegisteredComponentWithFallback } from '../../core';
+import { Slot } from '../Slot';
+import { useDatePickerContext } from './context';
+
+const DatePickerTriggerDefault = memo(({ children }: { children: ReactElement }) => {
+    const { open, setOpen, disabled, triggerRef } = useDatePickerContext();
+
+    const onPress = useCallback(() => setOpen(!open), [open, setOpen]);
+
+    return (
+        <Slot ref={triggerRef} onPress={onPress} disabled={disabled}>
+            {children}
+        </Slot>
+    );
+});
+
+export const DatePickerTrigger = getRegisteredComponentWithFallback(
+    'DatePickerTrigger',
+    DatePickerTriggerDefault,
+);

package/components/DatePicker/context.tsx

@@ -0,0 +1,83 @@
+import type { RefObject } from 'react';
+import { createContext, useContext } from 'react';
+
+import type { ValidRangeType } from '../DatePickerInline';
+import { registerPortalContext } from '../Portal';
+
+export type DatePickerMode = 'date' | 'time' | 'datetime' | 'range';
+export type DatePickerLocale = Intl.LocalesArgument;
+
+export type DateValue = Date | null;
+export type RangeValue = { start: Date | null; end: Date | null };
+export type DatePickerValue = DateValue | RangeValue;
+
+export type DatePickerContextType = {
+    mode: DatePickerMode;
+
+    // Raw state shared across layers.
+    value: DatePickerValue;
+    draftBuffer: DatePickerValue;
+    setCommittedValue: (value: DatePickerValue) => void;
+    setDraftBuffer: (value: DatePickerValue) => void;
+
+    // User's explicit `draft` prop on <DatePicker.Provider>. Undefined if not passed.
+    providerDraft: boolean | undefined;
+
+    // Resolved for this layer — surfaces override these via withDraftLayer.
+    draft: boolean;
+    draftValue: DatePickerValue;
+    setValue: (value: DatePickerValue) => void;
+    commit: () => void;
+    cancel: () => void;
+
+    // Bypass setter for typed-entry fields — always commits, ignores draft.
+    commitValue: (value: DatePickerValue) => void;
+
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    triggerRef: RefObject<any>;
+    locale?: DatePickerLocale;
+    validRange?: ValidRangeType;
+    is24Hour: boolean;
+    dateFormat: string;
+    disabled?: boolean;
+};
+
+/** Rebuilds draft-derived fields on top of a base context for a specific layer's draft mode. */
+export function withDraftLayer(base: DatePickerContextType, draft: boolean): DatePickerContextType {
+    return {
+        ...base,
+        draft,
+        draftValue: draft ? base.draftBuffer : base.value,
+        setValue: next => {
+            if (draft) base.setDraftBuffer(next);
+            else base.setCommittedValue(next);
+        },
+        commit: () => {
+            if (draft) base.setCommittedValue(base.draftBuffer);
+            base.setOpen(false);
+        },
+        cancel: () => {
+            base.setDraftBuffer(base.value);
+            base.setOpen(false);
+        },
+    };
+}
+
+export const DatePickerContext = createContext<DatePickerContextType | null>(null);
+
+export function useDatePickerContext(): DatePickerContextType {
+    const ctx = useContext(DatePickerContext);
+    if (!ctx) {
+        throw new Error(
+            'useDatePickerContext must be used within a <DatePickerProvider>. Wrap your date/time components with <DatePickerProvider>.',
+        );
+    }
+    return ctx;
+}
+
+export function useOptionalDatePickerContext(): DatePickerContextType | null {
+    return useContext(DatePickerContext);
+}
+
+registerPortalContext(DatePickerContext);