@yahoo/uds 3.59.0-beta.1 → 3.59.0-beta.2

package/src/tokens/utils/entries.ts

@@ -1,14 +0,0 @@
-/**
- * Converts an object into an array of key-value pair entries.
- *
- * This function takes an object `item` and returns an array of its own enumerable
- * property `[key, value]` pairs, where `key` is a string. The generic type `T` represents
- * the type of the input object. The return type is an array of tuples, where each tuple
- * consists of a string key and a value corresponding to the type of values in `T`.
- */
-export function entries<T>(item: T) {
-  return Object.entries(item as Record<string, unknown>) as [
-    Extract<keyof T, string>,
-    T[keyof T],
-  ][];
-}

package/src/tokens/utils/fromEntries.ts

@@ -1,11 +0,0 @@
-/**
- * Converts an array of key-value pair entries into an object.
- *
- * This function takes an array of `[key, value]` pairs and converts it into an object
- * where each key is associated with its corresponding value. The generic types `T` and `K`
- * represent the types of the keys and values, respectively. The keys are constrained to
- * be strings.
- */
-export function fromEntries<T extends string, K>(item: [T, K][] | (readonly [T, K])[]) {
-  return Object.fromEntries(item) as Record<T, K>;
-}

package/src/tokens/utils/mapValues.ts

@@ -1,15 +0,0 @@
-type AnyObject = Record<string, unknown>;
-
-export function mapValues<
-  T extends AnyObject,
-  K extends (value: T[keyof T], key: keyof T, i: number) => unknown,
->(obj: T, callbackFn: K) {
-  return Object.keys(obj).reduce(
-    (acc, key: keyof T, i) => {
-      acc[key] = callbackFn(obj[key], key, i) as ReturnType<typeof callbackFn>;
-      return acc;
-    },
-
-    {} as { [key in keyof T]: ReturnType<K> },
-  );
-}

package/src/types.ts

@@ -1,2 +0,0 @@
-import type { Dispatch, SetStateAction } from 'react';
-export type SetState<T> = Dispatch<SetStateAction<T>>;

package/src/utils/assertUnreachable.ts

@@ -1,6 +0,0 @@
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-const assertUnreachable = (x: never): never => {
-  throw new Error("Didn't expect to get here");
-};
-
-export { assertUnreachable };

package/src/utils/composeRefs.ts

@@ -1,23 +0,0 @@
-type PossibleRef<T> = React.Ref<T> | undefined;
-
-/**
- * Set a given ref to a given value
- * This utility takes care of different types of refs: callback refs and RefObject(s)
- */
-function setRef<T>(ref: PossibleRef<T>, value: T) {
-  if (typeof ref === 'function') {
-    ref(value);
-  } else if (ref !== null && ref !== undefined) {
-    (ref as React.MutableRefObject<T>).current = value;
-  }
-}
-
-/**
- * A utility to compose multiple refs together
- * Accepts callback refs and RefObject(s)
- */
-function composeRefs<T>(...refs: PossibleRef<T>[]) {
-  return (node: T) => refs.forEach((ref) => setRef(ref, node));
-}
-
-export { composeRefs };

package/src/utils/createSlot.tsx

@@ -1,131 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
-/**
- * Essentially @radix-ui/react-slot typed as a generic we can use with asChild
- * @link: https://www.radix-ui.com/primitives/docs/utilities/slot
- **/
-
-/* -------------------------------------------------------------------------- */
-/*                                    Slot                                    */
-/* -------------------------------------------------------------------------- */
-
-import { Children, cloneElement, forwardRef, isValidElement } from 'react';
-
-import { composeRefs } from './composeRefs';
-
-export function createSlot<T extends React.ComponentType<{ children?: any }>>() {
-  type SlotProps = React.ComponentPropsWithRef<T>;
-  // TODO: reenable react/prop-types. See https://github.com/DefinitelyTyped/DefinitelyTyped/pull/70361
-  const Slot = forwardRef<T, SlotProps>((props, forwardedRef) => {
-    const { children, ...slotProps } = props;
-    const childrenArray = Children.toArray(children);
-    const slottable = childrenArray.find(isSlottable);
-
-    if (slottable) {
-      // the new element to render is the one passed as a child of `Slottable`
-      const newElement = slottable.props.children as React.ReactNode;
-
-      const newChildren = childrenArray.map((child) => {
-        if (child === slottable) {
-          // because the new element will be the one rendered, we are only interested
-          // in grabbing its children (`newElement.props.children`)
-          if (Children.count(newElement) > 1) {
-            return Children.only(null);
-          }
-          return isValidElement(newElement) ? (newElement.props.children as React.ReactNode) : null;
-        } else {
-          return child;
-        }
-      });
-
-      return (
-        <SlotClone {...slotProps} ref={forwardedRef}>
-          {isValidElement(newElement) ? cloneElement(newElement, undefined, newChildren) : null}
-        </SlotClone>
-      );
-    }
-
-    return (
-      <SlotClone {...slotProps} ref={forwardedRef}>
-        {children}
-      </SlotClone>
-    );
-  });
-
-  Slot.displayName = 'Slot';
-
-  /* -------------------------------------------------------------------------- */
-  /*                                  SlotClone                                 */
-  /* -------------------------------------------------------------------------- */
-
-  interface SlotCloneProps {
-    children: React.ReactNode;
-  }
-
-  // eslint-disable-next-line react/no-multi-comp
-  const SlotClone = forwardRef<any, SlotCloneProps>((props: SlotCloneProps, forwardedRef) => {
-    const { children, ...slotProps } = props;
-
-    if (isValidElement(children)) {
-      return cloneElement(children, {
-        ...mergeProps(slotProps, children.props),
-        ref: forwardedRef
-          ? composeRefs(forwardedRef, (children as any).ref)
-          : (children as any).ref,
-      });
-    }
-
-    return Children.count(children) > 1 ? Children.only(null) : null;
-  });
-
-  SlotClone.displayName = 'SlotClone';
-
-  /* -------------------------------------------------------------------------- */
-  /*                                  Slottable                                 */
-  /* -------------------------------------------------------------------------- */
-
-  const Slottable = ({ children }: { children: React.ReactNode }) => {
-    return children;
-  };
-
-  /* ---------------------------------------------------------------------------------------------- */
-
-  type AnyProps = Record<string, any>;
-
-  function isSlottable(child: React.ReactNode): child is React.ReactElement {
-    return isValidElement(child) && child.type === Slottable;
-  }
-
-  function mergeProps(slotProps: AnyProps, childProps: AnyProps) {
-    // all child props should override
-    const overrideProps = { ...childProps };
-
-    for (const propName in childProps) {
-      const slotPropValue = slotProps[propName];
-      const childPropValue = childProps[propName];
-
-      const isHandler = /^on[A-Z]/.test(propName);
-      if (isHandler) {
-        // if the handler exists on both, we compose them
-        if (slotPropValue && childPropValue) {
-          overrideProps[propName] = (...args: unknown[]) => {
-            childPropValue(...args);
-            slotPropValue(...args);
-          };
-        }
-        // but if it exists only on the slot, we use only this one
-        else if (slotPropValue) {
-          overrideProps[propName] = slotPropValue;
-        }
-      }
-      // if it's `style`, we merge them
-      else if (propName === 'style') {
-        overrideProps[propName] = { ...slotPropValue, ...childPropValue };
-      }
-    }
-
-    return { ...slotProps, ...overrideProps };
-  }
-
-  return Slot as unknown as T;
-}

package/src/utils/entries.ts

@@ -1,6 +0,0 @@
-export function entries<T>(item: T) {
-  return Object.entries(item as Record<string, unknown>) as [
-    Extract<keyof T, string>,
-    T[keyof T],
-  ][];
-}

package/src/utils/falsyToString.ts

@@ -1,3 +0,0 @@
-export function falsyToString<T>(value: T) {
-  return typeof value === 'boolean' ? `${value}` : value === 0 ? '0' : value;
-}

package/src/utils/getMotionVar.ts

@@ -1,18 +0,0 @@
-import type {
-  MotionSpringConfigOptions,
-  MotionVariant,
-  MotionVariantSpeed,
-} from '@yahoo/uds/tokens';
-import { MOTION_PREFIX } from '@yahoo/uds/tokens';
-
-export interface GetMotionVarParams {
-  variant: MotionVariant;
-  speed: MotionVariantSpeed;
-  control: MotionSpringConfigOptions;
-}
-
-export function getMotionVar({ variant, speed, control }: GetMotionVarParams) {
-  const cssVar = [`--${MOTION_PREFIX}`, variant, speed, control].join('-');
-
-  return `${cssVar}` as const;
-}

package/src/utils/intersperse.ts

@@ -1,45 +0,0 @@
-import { isFunction } from 'lodash';
-import type { ReactNode } from 'react';
-import { Children, cloneElement, isValidElement } from 'react';
-
-/**
- * Given an array of items, place an item between each of the original values with either a constant
- * value or the result of a function which knows the index it is being inserted before.
- *
- * @example
- * const ANIMALS = ["Lions", "Tigers", "Bears"];
- * const animalesInterspersedWithAmpersands = intersperse(ANIMALS, "&");
- * // ["Lions", "&", "Tigers", "&", "Bears"]
- * console.log(animalesInterspersedWithAmpersands.join(" ") + '. OH MY!');
- */
-export const intersperse = <T>(list: Array<T>, inter: T | ((index: number) => T)) => {
-  const interFn: (index: number) => T = isFunction(inter) ? inter : () => inter;
-  return list.flatMap((item, i) => (i !== 0 ? [interFn(i), item] : [item]));
-};
-
-/**
- * Given ReactNode, if it is a list of children nodes, place a new React node between each of the
- * original nodes with either a constant ReactElement or the result of a function which knows the
- * index it is being inserted before.
- *
- * @example
- * const SplitParagraphsWithHorizontalRule = ({ paragraphs }: { paragraphs: string[] }) => {
- *   const paragraphNodes =  paragraphs.map((str) => <p>{str}</p>);
- *
- *   return (<div>
- *     {intersperseReactChildren(paragraphNodes, <hr />)}
- *   </div>);
- * }
- */
-export const intersperseReactChildren = (
-  children: ReactNode,
-  inter: ReactNode | ((index: number) => ReactNode),
-) => {
-  return intersperse(Children.toArray(children), (i) => {
-    const node = isFunction(inter) ? inter(i) : inter;
-
-    return isValidElement(node)
-      ? cloneElement(node, { ...node.props, key: node.key ?? `interspersed-${i}` })
-      : null;
-  });
-};

package/src/utils/mapValues.ts

@@ -1,15 +0,0 @@
-type AnyObject = Record<string, unknown>;
-
-export function mapValues<
-  T extends AnyObject,
-  K extends (value: T[keyof T], key: keyof T, i: number) => unknown,
->(obj: T, callbackFn: K) {
-  return Object.keys(obj).reduce(
-    (acc, key: keyof T, i) => {
-      acc[key] = callbackFn(obj[key], key, i) as ReturnType<typeof callbackFn>;
-      return acc;
-    },
-
-    {} as { [key in keyof T]: ReturnType<K> },
-  );
-}

package/src/utils/mergeSlotProps.ts

@@ -1,70 +0,0 @@
-import { cx } from '../styles/styler';
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const mergeSlotProp = <T extends Partial<Record<string, any>>>(
-  slotProp: T | undefined,
-  newSlotProp: T | undefined,
-  onConflict: 'overwriteOriginal' | 'keepOriginal' = 'overwriteOriginal',
-): T => {
-  const allKeys = Array.from(
-    new Set([...Object.keys(slotProp ?? {}), ...Object.keys(newSlotProp ?? {})]),
-  );
-
-  return Object.fromEntries(
-    allKeys.map((key) => {
-      const originalValue = slotProp?.[key];
-      const newValue = newSlotProp?.[key];
-
-      if (originalValue && !newValue) {
-        return [key, originalValue] as const;
-      }
-
-      if (newValue && !originalValue) {
-        return [key, newValue] as const;
-      }
-
-      if (key === 'className') {
-        return [key, cx(originalValue, newValue)] as const;
-      }
-
-      if (onConflict === 'keepOriginal') {
-        return [key, originalValue] as const;
-      }
-
-      // else overwriteOriginal
-      return [key, newValue] as const;
-    }),
-  ) as T;
-};
-
-const mergeSlotProps = <
-  T1 extends {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    [K in keyof T1]?: Record<string, any>;
-  },
-  T2 extends {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    [K in keyof T2]?: Record<string, any>;
-  },
->(
-  slotProps: T1 | undefined,
-  newProps: T2,
-  onConflict: 'overwriteOriginal' | 'keepOriginal' = 'overwriteOriginal',
-): (T1 & T2) | undefined => {
-  if (!slotProps) {
-    return newProps as T1 & T2;
-  }
-
-  const allKeys = Array.from(new Set([...Object.keys(slotProps), ...Object.keys(newProps)]));
-
-  return Object.fromEntries(
-    allKeys.map((key) => {
-      const originalValue = slotProps[key as keyof T1];
-      const newValue = newProps[key as keyof T2];
-
-      return [key, mergeSlotProp(originalValue, newValue, onConflict)] as const;
-    }),
-  ) as T1 & T2;
-};
-
-export { mergeSlotProp, mergeSlotProps };