@cdx-ui/primitives 0.0.1-beta.64 → 0.0.1-beta.66

package/src/list-item/createListItemRoot.tsx

@@ -1,195 +0,0 @@
-import React, { forwardRef, useMemo } from 'react';
-import type { PressableProps } from 'react-native';
-import { composeEventHandlers, mergeRefs } from '@cdx-ui/utils';
-import { useFocus, useFocusRing } from '@react-native-aria/focus';
-import { useHover, usePress } from '@react-native-aria/interactions';
-import { dataAttributes } from '../utils/dataAttributes';
-import { ListItemProvider } from './context';
-import type { IListItemProps, IListItemPressablePassthrough } from './types';
-
-function listItemRootDataAttrs(
-  size: IListItemProps['size'],
-  showSeparator: boolean | undefined,
-  crossAlign: IListItemProps['crossAlign'],
-) {
-  return dataAttributes({
-    slot: 'list-item',
-    size: size ?? 'default',
-    separator: showSeparator ?? true,
-    crossAlign: crossAlign ?? 'center',
-  });
-}
-
-function rowStyleForCrossAlign(crossAlign: IListItemProps['crossAlign']) {
-  return {
-    flexDirection: 'row' as const,
-    alignSelf: 'stretch' as const,
-    alignItems: crossAlign === 'start' ? ('flex-start' as const) : ('center' as const),
-  };
-}
-
-export const createListItemRoot = <V, P>(
-  BaseView: React.ComponentType<V>,
-  BasePressable: React.ComponentType<P>,
-) =>
-  forwardRef(
-    (
-      {
-        asChild = false,
-        children,
-        onPress,
-        size = 'default',
-        showSeparator = true,
-        crossAlign = 'center',
-        isDisabled = false,
-        style,
-        ...restProps
-      }: IListItemProps,
-      ref: React.Ref<unknown>,
-    ) => {
-      const childOnPress = React.isValidElement(children)
-        ? ((children.props as { onPress?: unknown }).onPress as
-            | IListItemProps['onPress']
-            | undefined)
-        : undefined;
-
-      // asChild always wins when explicitly set with a valid element — even when the press
-      // surface is built internally by the child (e.g. `Link` adds its onPress via `useLink`,
-      // not as a JSX-level prop). The clone path below preserves the child's own press by
-      // *omitting* `onPress` when there is nothing to compose.
-      const asChildInteractive = asChild && React.isValidElement(children);
-      const isPressableRoot = !!onPress && !asChildInteractive;
-
-      const pressState = usePress({
-        isDisabled: !isPressableRoot || isDisabled,
-      });
-      const isPressed = pressState.isPressed;
-      const pressProps = pressState.pressProps as Pick<PressableProps, 'onPressIn' | 'onPressOut'>;
-      const { hoverProps, isHovered } = useHover();
-      const { isFocused, focusProps } = useFocus();
-      const { isFocusVisible, focusProps: focusRingProps } = useFocusRing() as {
-        isFocusVisible: boolean;
-        focusProps: typeof focusProps;
-      };
-
-      const slotAttrs = listItemRootDataAttrs(size, showSeparator, crossAlign);
-
-      const contextValue = useMemo(
-        () => ({
-          isPressed: isPressableRoot ? isPressed : false,
-          isHovered,
-          isDisabled,
-          crossAlign: crossAlign ?? 'center',
-        }),
-        [isPressableRoot, isPressed, isHovered, isDisabled, crossAlign],
-      );
-
-      if (asChildInteractive) {
-        const child = children as React.ReactElement<Record<string, unknown>>;
-
-        const childProps = child.props as { disabled?: boolean; isDisabled?: boolean };
-        const childDisabled = !!(childProps.isDisabled ?? childProps.disabled);
-        const resolvedDisabled = isDisabled || childDisabled;
-
-        const cloneProps: Record<string, unknown> = {
-          ...restProps,
-          ...slotAttrs,
-          ...dataAttributes({
-            disabled: resolvedDisabled,
-          }),
-          ...(resolvedDisabled && { accessibilityState: { disabled: true } }),
-          disabled: resolvedDisabled,
-          ref: mergeRefs(ref, child.props.ref as React.Ref<unknown>),
-          style: [rowStyleForCrossAlign(crossAlign), style, child.props.style],
-        };
-
-        // Only override the child's `onPress` when we have something to add (a parent handler)
-        // or need to suppress (disabled). Otherwise leave the child's own onPress alone — e.g.
-        // `Link` builds its navigation handler inside `useLink`, not as a JSX-level prop, and
-        // overriding here would shadow it.
-        if (resolvedDisabled) {
-          cloneProps.onPress = undefined;
-        } else if (onPress) {
-          cloneProps.onPress = composeEventHandlers(childOnPress, onPress);
-        }
-
-        return (
-          <ListItemProvider
-            value={{
-              isPressed: false,
-              isHovered: false,
-              isDisabled: resolvedDisabled,
-              crossAlign: crossAlign ?? 'center',
-            }}
-          >
-            {React.cloneElement(child, cloneProps)}
-          </ListItemProvider>
-        );
-      }
-
-      if (isPressableRoot) {
-        const interactionAttrs = dataAttributes({
-          active: isPressed,
-          hover: isHovered,
-          focus: isFocused,
-          focusVisible: isFocusVisible,
-          disabled: isDisabled,
-        });
-
-        const {
-          onPressIn: onPressInProp,
-          onPressOut: onPressOutProp,
-          onHoverIn: onHoverInProp,
-          onHoverOut: onHoverOutProp,
-          onFocus: onFocusProp,
-          onBlur: onBlurProp,
-        } = restProps as IListItemPressablePassthrough & {
-          onFocus?: (...args: unknown[]) => unknown;
-          onBlur?: (...args: unknown[]) => unknown;
-        };
-
-        return (
-          <ListItemProvider value={contextValue}>
-            <BasePressable
-              {...(restProps as P)}
-              {...slotAttrs}
-              {...interactionAttrs}
-              {...(isDisabled && { accessibilityState: { disabled: true } })}
-              disabled={isDisabled}
-              ref={ref as React.Ref<P>}
-              style={[rowStyleForCrossAlign(crossAlign), style]}
-              onPress={isDisabled ? undefined : onPress}
-              onPressIn={composeEventHandlers(onPressInProp, pressProps.onPressIn)}
-              onPressOut={composeEventHandlers(onPressOutProp, pressProps.onPressOut)}
-              onHoverIn={composeEventHandlers(onHoverInProp, hoverProps.onHoverIn)}
-              onHoverOut={composeEventHandlers(onHoverOutProp, hoverProps.onHoverOut)}
-              onFocus={composeEventHandlers(
-                composeEventHandlers(onFocusProp, focusProps.onFocus),
-                focusRingProps.onFocus,
-              )}
-              onBlur={composeEventHandlers(
-                composeEventHandlers(onBlurProp, focusProps.onBlur),
-                focusRingProps.onBlur,
-              )}
-            >
-              {children}
-            </BasePressable>
-          </ListItemProvider>
-        );
-      }
-
-      return (
-        <ListItemProvider value={contextValue}>
-          <BaseView
-            {...(restProps as V)}
-            {...slotAttrs}
-            {...(isDisabled ? dataAttributes({ disabled: true }) : undefined)}
-            ref={ref as React.Ref<V>}
-            style={[rowStyleForCrossAlign(crossAlign), style]}
-          >
-            {children}
-          </BaseView>
-        </ListItemProvider>
-      );
-    },
-  );

package/src/list-item/createListItemSectionHeader.tsx

@@ -1,53 +0,0 @@
-import React, { forwardRef } from 'react';
-import { View } from 'react-native';
-import { dataAttributes } from '../utils/dataAttributes';
-import type { IListItemSectionHeaderProps } from './types';
-
-const row = {
-  flexDirection: 'row' as const,
-  alignItems: 'center' as const,
-  justifyContent: 'space-between' as const,
-  gap: 8,
-};
-
-const labelCell = {
-  flex: 1,
-  minWidth: 0,
-  /** Keeps the label column from stretching to a taller trailing sibling (e.g. Chip). */
-  alignSelf: 'center' as const,
-};
-
-const trailingCell = {
-  flexShrink: 0,
-  /** Prevents the trailing slot from stretching vertically and “filling” the row. */
-  alignSelf: 'center' as const,
-};
-
-export const createListItemSectionHeader = <T,>(Base: React.ComponentType<T>) =>
-  forwardRef(
-    (
-      {
-        children,
-        trailing,
-        showDivider = true,
-        style,
-        accessibilityRole = 'header',
-        ...props
-      }: IListItemSectionHeaderProps,
-      ref: React.Ref<unknown>,
-    ) => (
-      <Base
-        {...(props as T)}
-        {...dataAttributes({
-          slot: 'list-section-header',
-          divider: showDivider,
-        })}
-        accessibilityRole={accessibilityRole}
-        ref={ref as React.Ref<T>}
-        style={[row, style]}
-      >
-        <View style={labelCell}>{children}</View>
-        {trailing ? <View style={trailingCell}>{trailing}</View> : null}
-      </Base>
-    ),
-  );

package/src/list-item/createListItemTitle.tsx

@@ -1,17 +0,0 @@
-import React, { forwardRef } from 'react';
-import { dataAttributes } from '../utils/dataAttributes';
-import type { IListItemTitleProps } from './types';
-
-export const createListItemTitle = <T,>(Base: React.ComponentType<T>) =>
-  forwardRef(({ children, style, ...props }: IListItemTitleProps, ref: React.Ref<unknown>) => (
-    <Base
-      {...(props as T)}
-      {...dataAttributes({
-        slot: 'list-item-title',
-      })}
-      ref={ref as React.Ref<T>}
-      style={style}
-    >
-      {children}
-    </Base>
-  ));

package/src/list-item/createListItemTrailingSlot.tsx

@@ -1,21 +0,0 @@
-import React, { forwardRef } from 'react';
-import { dataAttributes } from '../utils/dataAttributes';
-import type { IListItemTrailingSlotProps } from './types';
-
-const shrinkZero = { flexShrink: 0 as const };
-
-export const createListItemTrailingSlot = <T,>(Base: React.ComponentType<T>) =>
-  forwardRef(
-    ({ children, style, ...props }: IListItemTrailingSlotProps, ref: React.Ref<unknown>) => (
-      <Base
-        {...(props as T)}
-        {...dataAttributes({
-          slot: 'list-item-trailing',
-        })}
-        ref={ref as React.Ref<T>}
-        style={[shrinkZero, style]}
-      >
-        {children}
-      </Base>
-    ),
-  );

package/src/otp-input/createOtpInputCell.tsx

@@ -1,22 +0,0 @@
-import type React from 'react';
-import type { PropsWithChildren } from 'react';
-import { forwardRef } from 'react';
-import { useOtpInputContext } from './context';
-import type { IOtpInputCellProps } from './types';
-
-export const createOtpInputCell = <T,>(BaseCell: React.ComponentType<T>) =>
-  forwardRef<unknown, PropsWithChildren<IOtpInputCellProps & T>>(({ children, ...props }, ref) => {
-    const { isDisabled, isInvalid, isReadOnly } = useOtpInputContext();
-
-    return (
-      <BaseCell
-        ref={ref}
-        isDisabled={isDisabled}
-        isInvalid={isInvalid}
-        isReadOnly={isReadOnly}
-        {...(props as T)}
-      >
-        {children}
-      </BaseCell>
-    );
-  });

package/src/otp-input/createOtpInputField.tsx

@@ -1,98 +0,0 @@
-import type React from 'react';
-import { forwardRef, useMemo } from 'react';
-import { Platform, type TextInput, type TextInputKeyPressEvent } from 'react-native';
-import { mergeRefs } from '@cdx-ui/utils';
-import { useOtpCellIndexContext, useOtpInputContext } from './context';
-import type { IOtpInputFieldProps } from './types';
-
-export const createOtpInputField = <T,>(BaseField: React.ComponentType<T>) =>
-  forwardRef<TextInput, IOtpInputFieldProps & Omit<T, keyof IOtpInputFieldProps>>((props, ref) => {
-    const { cellIndex } = useOtpCellIndexContext();
-    const {
-      value,
-      cellCount,
-      isDisabled,
-      isReadOnly,
-      smsOtpAutofill,
-      getCellProps,
-      cellTestIdPrefix,
-      rootAccessibilityLabel,
-      setFieldRef,
-      handleFieldChange,
-      handleFieldKeyPress,
-    } = useOtpInputContext();
-
-    const char = cellIndex < value.length ? (value[cellIndex] ?? '') : '';
-    const extra = getCellProps?.(cellIndex) ?? {};
-
-    const accessibilityLabel = useMemo(() => {
-      const fromExtra = extra.accessibilityLabel;
-      if (typeof fromExtra === 'string' && fromExtra !== '') {
-        return fromExtra;
-      }
-      if (rootAccessibilityLabel) {
-        return `${rootAccessibilityLabel}, ${String(cellIndex + 1)} of ${String(cellCount)}`;
-      }
-      return `OTP digit ${String(cellIndex + 1)} of ${String(cellCount)}`;
-    }, [cellCount, cellIndex, extra.accessibilityLabel, rootAccessibilityLabel]);
-
-    const autofillProps = useMemo(() => {
-      if (!smsOtpAutofill || cellIndex !== 0) {
-        return {};
-      }
-      return Platform.select<Record<string, unknown>>({
-        web: { autoComplete: 'one-time-code' },
-        ios: { textContentType: 'oneTimeCode' },
-        android: { autoComplete: 'sms-otp' },
-        default: {},
-      });
-    }, [cellIndex, smsOtpAutofill]);
-
-    const editable = !(isDisabled || isReadOnly);
-
-    const { style: extraStyle, accessibilityLabel: _omitExtraA11y, ...extraRest } = extra;
-    void _omitExtraA11y;
-    const {
-      style: incomingStyle,
-      value: _omitValue,
-      defaultValue: _omitDefault,
-      onChangeText: _omitOnChange,
-      ...incomingRest
-    } = props as IOtpInputFieldProps;
-    void _omitValue;
-    void _omitDefault;
-    void _omitOnChange;
-
-    // Default digit OTP (`number-pad`). Root `getCellProps` is spread after and may override `keyboardType`.
-    return (
-      <BaseField
-        ref={mergeRefs(ref, (el: TextInput | null) => {
-          setFieldRef(cellIndex, el);
-        })}
-        accessibilityLabel={accessibilityLabel}
-        aria-label={accessibilityLabel}
-        accessible
-        autoFocus={cellIndex === 0 && editable && value.length === 0}
-        editable={editable}
-        keyboardType="number-pad"
-        returnKeyType="done"
-        selectTextOnFocus
-        testID={
-          cellTestIdPrefix
-            ? `${cellTestIdPrefix}:${String(cellIndex)}:textField:changeText`
-            : undefined
-        }
-        value={char}
-        onChangeText={(text: string) => {
-          handleFieldChange(cellIndex, text);
-        }}
-        onKeyPress={(e: TextInputKeyPressEvent) => {
-          handleFieldKeyPress(cellIndex, e.nativeEvent.key);
-        }}
-        {...autofillProps}
-        {...(extraRest as object)}
-        {...(incomingRest as T)}
-        style={[extraStyle, incomingStyle]}
-      />
-    );
-  });

package/src/otp-input/createOtpInputRoot.tsx

@@ -1,179 +0,0 @@
-import type React from 'react';
-import { forwardRef, useCallback, useEffect, useLayoutEffect, useMemo, useRef } from 'react';
-import type { TextInput } from 'react-native';
-import { useFormControlContext } from '@cdx-ui/utils';
-import { applyOtpInputChange } from './utils/applyValueChange';
-import { OtpCellIndexProvider, OtpInputProvider } from './context';
-import { filterAllowedCharacters, filterByRegExp, filterDigits } from './utils/filterValue';
-import type { IOtpInputRootProps } from './types';
-
-export const createOtpInputRoot = <RootProps,>(
-  BaseRoot: React.ComponentType<RootProps>,
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- slot components are generic across design systems
-  OtpCell: React.ComponentType<any>,
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  OtpField: React.ComponentType<any>,
-) =>
-  forwardRef<unknown, IOtpInputRootProps & RootProps>(
-    (
-      {
-        cellCount,
-        value,
-        onChangeText,
-        onComplete,
-        isDisabled: isDisabledProp,
-        isInvalid: isInvalidProp,
-        isReadOnly: isReadOnlyProp,
-        smsOtpAutofill = true,
-        filterInput,
-        allowedCharacters,
-        characterPattern,
-        getCellProps,
-        cellTestIdPrefix,
-        accessibilityLabel: rootAccessibilityLabel,
-        ...rest
-      },
-      ref,
-    ) => {
-      const form = useFormControlContext();
-      const isDisabled = isDisabledProp ?? form.isDisabled ?? false;
-      const isInvalid = isInvalidProp ?? form.isInvalid ?? false;
-      const isReadOnly = isReadOnlyProp ?? form.isReadOnly ?? false;
-
-      const fieldRefs = useRef<(TextInput | null)[]>([]);
-      const focusAfterApply = useRef<number | null>(null);
-      const prevLenRef = useRef(value.length);
-      const prevValueRef = useRef(value);
-
-      const filter = useMemo(() => {
-        if (filterInput) {
-          return filterInput;
-        }
-        if (allowedCharacters !== undefined) {
-          return filterAllowedCharacters(allowedCharacters);
-        }
-        if (characterPattern !== undefined) {
-          return filterByRegExp(characterPattern);
-        }
-        return filterDigits;
-      }, [filterInput, allowedCharacters, characterPattern]);
-
-      const setFieldRef = useCallback((index: number, el: TextInput | null) => {
-        fieldRefs.current[index] = el;
-      }, []);
-
-      const focusCell = useCallback(
-        (index: number) => {
-          const safe = Math.max(0, Math.min(index, cellCount - 1));
-          fieldRefs.current[safe]?.focus();
-        },
-        [cellCount],
-      );
-
-      const handleFieldChange = useCallback(
-        (index: number, text: string) => {
-          const { nextValue, focusIndex } = applyOtpInputChange(
-            value,
-            index,
-            text,
-            cellCount,
-            filter,
-          );
-          if (nextValue !== value) {
-            onChangeText(nextValue);
-          }
-          focusAfterApply.current = focusIndex;
-        },
-        [cellCount, filter, onChangeText, value],
-      );
-
-      const handleFieldKeyPress = useCallback(
-        (index: number, key: string) => {
-          if (key !== 'Backspace') {
-            return;
-          }
-          const char = index < value.length ? value[index] : '';
-          if (!char && index > 0) {
-            focusCell(index - 1);
-          }
-        },
-        [focusCell, value],
-      );
-
-      useLayoutEffect(() => {
-        if (focusAfterApply.current !== null) {
-          const i = focusAfterApply.current;
-          focusAfterApply.current = null;
-          fieldRefs.current[i]?.focus();
-        }
-      });
-
-      useEffect(() => {
-        const prevLen = prevLenRef.current;
-        const prevVal = prevValueRef.current;
-        const isFull = value.length === cellCount;
-        const becameFullByLength = isFull && prevLen < cellCount;
-        const correctedWhileFull = isFull && prevLen === cellCount && prevVal !== value;
-
-        if (becameFullByLength || correctedWhileFull) {
-          onComplete?.();
-        }
-        prevLenRef.current = value.length;
-        prevValueRef.current = value;
-      }, [cellCount, onComplete, value]);
-
-      const contextValue = useMemo(
-        () => ({
-          cellCount,
-          value,
-          isDisabled,
-          isInvalid,
-          isReadOnly,
-          smsOtpAutofill,
-          filter,
-          getCellProps,
-          cellTestIdPrefix,
-          rootAccessibilityLabel,
-          setFieldRef,
-          handleFieldChange,
-          handleFieldKeyPress,
-        }),
-        [
-          cellCount,
-          value,
-          isDisabled,
-          isInvalid,
-          isReadOnly,
-          smsOtpAutofill,
-          filter,
-          getCellProps,
-          cellTestIdPrefix,
-          rootAccessibilityLabel,
-          setFieldRef,
-          handleFieldChange,
-          handleFieldKeyPress,
-        ],
-      );
-
-      // Hermes drops outer-scope closure vars from its environment record when
-      // they are only referenced inside a nested callback (Array.from). Using a
-      // for-loop keeps OtpCell/OtpField references in the render function's own
-      // scope, avoiding the Hermes closure-capture bug.
-      const cells: React.ReactElement[] = [];
-      for (let i = 0; i < cellCount; i++) {
-        cells.push(
-          <OtpCellIndexProvider key={i} value={{ cellIndex: i }}>
-            <OtpCell>
-              <OtpField />
-            </OtpCell>
-          </OtpCellIndexProvider>,
-        );
-      }
-
-      return (
-        <BaseRoot ref={ref as React.Ref<unknown>} {...(rest as RootProps)}>
-          <OtpInputProvider value={contextValue}>{cells}</OtpInputProvider>
-        </BaseRoot>
-      );
-    },
-  );

package/src/otp-input/index.tsx

@@ -1,34 +0,0 @@
-import type React from 'react';
-import { createOtpInputCell } from './createOtpInputCell';
-import { createOtpInputField } from './createOtpInputField';
-import { createOtpInputRoot } from './createOtpInputRoot';
-import type { IOtpInputComponentType } from './types';
-
-export { applyOtpInputChange } from './utils/applyValueChange';
-export { filterAllowedCharacters, filterByRegExp, filterDigits } from './utils/filterValue';
-export type * from './types';
-
-export function createOtpInput<
-  RootProps,
-  CellProps,
-  FieldProps,
-  RootRef = unknown,
-  FieldRef = unknown,
->(BaseComponents: {
-  Root: React.ComponentType<RootProps>;
-  Cell: React.ComponentType<CellProps>;
-  Field: React.ComponentType<FieldProps>;
-}) {
-  const Cell = createOtpInputCell(BaseComponents.Cell);
-  const Field = createOtpInputField(BaseComponents.Field);
-  const Root = createOtpInputRoot(BaseComponents.Root, Cell, Field);
-
-  Root.displayName = 'OtpInputPrimitive';
-  Cell.displayName = 'OtpInputPrimitive.Cell';
-  Field.displayName = 'OtpInputPrimitive.Field';
-
-  return Object.assign(Root, {
-    Cell,
-    Field,
-  }) as IOtpInputComponentType<RootProps, CellProps, FieldProps, RootRef, FieldRef>;
-}

package/src/progress/createProgressIndicator.tsx

@@ -1,35 +0,0 @@
-import type React from 'react';
-import { forwardRef, useMemo, type PropsWithoutRef } from 'react';
-import type { ViewStyle } from 'react-native';
-import { dataAttributes } from '../utils/dataAttributes';
-import { useProgressContext } from './context';
-
-type PercentString = `${number}%`;
-
-export const createProgressIndicator = <T, R = unknown>(BaseIndicator: React.ComponentType<T>) =>
-  forwardRef<R, PropsWithoutRef<T>>((props, ref) => {
-    const { style, ...rest } = props as PropsWithoutRef<T> & { style?: object };
-    const { percent, state, max, value } = useProgressContext();
-
-    const filledStyle = useMemo((): ViewStyle => {
-      const pct = `${String(percent)}%` as PercentString;
-      return { width: pct, height: '100%' };
-    }, [percent]);
-
-    const dataAttrs = dataAttributes({
-      state,
-      value: value === null ? undefined : String(value),
-      max: String(max),
-    });
-
-    return (
-      <BaseIndicator
-        ref={ref as React.Ref<R>}
-        {...({
-          ...rest,
-          ...dataAttrs,
-          style: [filledStyle, style],
-        } as T)}
-      />
-    );
-  });

package/src/progress/index.ts

@@ -1,28 +0,0 @@
-import type React from 'react';
-import { createProgressIndicator } from './createProgressIndicator';
-import { createProgressRoot } from './createProgressRoot';
-import type { IProgressComponentType } from './types';
-
-export type { IProgressProps, IProgressComponentType, ProgressDataState } from './types';
-export type { ProgressContextValue } from './context';
-export { useProgressContext } from './context';
-
-export function createProgress<
-  RootProps,
-  IndicatorProps,
-  RootRef = unknown,
-  IndicatorRef = unknown,
->(components: {
-  Root: React.ComponentType<RootProps>;
-  Indicator: React.ComponentType<IndicatorProps>;
-}) {
-  const Progress = createProgressRoot<RootProps, RootRef>(components.Root);
-  const Indicator = createProgressIndicator<IndicatorProps, IndicatorRef>(components.Indicator);
-
-  Progress.displayName = 'ProgressPrimitive';
-  Indicator.displayName = 'ProgressPrimitive.Indicator';
-
-  return Object.assign(Progress, {
-    Indicator,
-  }) as IProgressComponentType<RootProps, IndicatorProps, RootRef, IndicatorRef>;
-}