@dxos/react-ui 0.8.4-main.fd6878d → 0.8.4-staging.60fe92afc8

package/src/translations.ts

@@ -0,0 +1,33 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+import { type Resource } from '@dxos/react-ui';
+
+export const translationKey = '@dxos/react-ui';
+
+export const translations = [
+  {
+    'en-US': {
+      [translationKey]: {
+        'toolbar-menu.label': 'Action menu',
+        'toolbar-drag-handle.label': 'Drag to rearrange',
+        'toolbar-close.label': 'Close',
+        'toolbar-delete.label': 'Delete',
+        'carousel-viewport.label': 'Carousel',
+        'carousel-prev.label': 'Previous slide',
+        'carousel-next.label': 'Next slide',
+        'carousel-indicators.label': 'Carousel slides',
+        'carousel-go-to.label': 'Go to slide {{index}}',
+        'date-picker.placeholder.single.label': 'Pick a date',
+        'date-picker.placeholder.range.label': 'Pick a date range',
+        'date-picker.placeholder.multiple.label': 'Pick dates',
+        'date-picker.clear.label': 'Clear',
+        'calendar.nav.previous.label': 'Previous month',
+        'calendar.nav.next.label': 'Next month',
+        'calendar.footer.today.label': 'Today',
+        'trigger-button.label': 'Open',
+      },
+    },
+  },
+] as const satisfies Resource[];

package/src/util/index.ts

@@ -2,5 +2,8 @@
 // Copyright 2023 DXOS.org
 //
 
-export * from './hasIosKeyboard';
-export type * from './ThemedClassName';
+export type { ThemedClassName } from '@dxos/ui-types';
+
+export * from './mobile';
+export * from './slots';
+export * from './usePx';

package/src/util/mobile.ts

@@ -0,0 +1,11 @@
+//
+// Copyright 2023 DXOS.org
+//
+
+/**
+ * Determines whether the on-screen keyboard will appear on `focus` outside of a click handler.
+ */
+export const hasIosKeyboard = () => {
+  // TODO(burdon): Better way to detect iOS keyboard?
+  return !!navigator.userAgent.match(/iP(ad|od|hone).+Safari/);
+};

package/src/util/slots.ts

@@ -0,0 +1,129 @@
+//
+// Copyright 2022 DXOS.org
+//
+
+import {
+  Children,
+  createElement,
+  forwardRef,
+  type ForwardRefExoticComponent,
+  type ForwardedRef,
+  type HTMLAttributes,
+  isValidElement,
+  type ReactNode,
+  type RefAttributes,
+  type CSSProperties,
+} from 'react';
+
+import { log } from '@dxos/log';
+import { mx } from '@dxos/ui-theme';
+import { type ComposableProps, type SlottableProps, type ThemedClassName } from '@dxos/ui-types';
+
+/**
+ * Reconciles className properties from a parent slot.
+ * - `className` is set by the Slot merge mechanism.
+ * - `classNames` is the consumer-facing prop for theming overrides.
+ * Use `composableProps` to reconcile both into a single `className`.
+ */
+export const composableProps = <P extends HTMLElement = HTMLElement>(
+  { className, classNames, role, style, ...props }: ComposableProps,
+  { classNames: defaultClassNames, ...defaults }: ThemedClassName<Partial<HTMLAttributes<P>>> | undefined = {},
+) => ({
+  // Default props.
+  ...(defaults as object),
+
+  // Spread supplied props.
+  ...props,
+
+  // Prefer explicit role, then defaults role, then 'none'.
+  role: role ?? defaults.role ?? 'none',
+
+  // Merge styles.
+  style: { ...defaults.style, ...style } as CSSProperties,
+
+  // Compose classnames.
+  className: mx(defaultClassNames, className, classNames),
+});
+
+/** Symbol used to mark components created by `composable()` or `slottable()`. */
+const COMPOSABLE = Symbol.for('dxos.composable');
+
+/**
+ * Factory for slottable components.
+ * The implementation receives full `HTMLAttributes<E>` so it can destructure `role`, `style`, etc.
+ * Consumers see only `SlottableProps<P>` — a narrow type exposing `classNames`, `className`,
+ * `children`, `asChild`, and the custom props `P`.
+ *
+ * @example
+ * ```tsx
+ * const MyPanel = slottable<HTMLDivElement, { border?: boolean }>(
+ *   ({ children, asChild, border, ...props }, forwardedRef) => {
+ *     const Comp = asChild ? Slot : Primitive.div;
+ *     return (
+ *       <Comp {...composableProps(props, { classNames: border && 'border' })} ref={forwardedRef}>
+ *         {children}
+ *       </Comp>
+ *     );
+ *   },
+ * );
+ * ```
+ */
+export function slottable<E extends HTMLElement, P extends object = {}>(
+  render: (props: SlottableProps<P> & HTMLAttributes<E>, forwardedRef: ForwardedRef<E>) => ReactNode,
+): ForwardRefExoticComponent<SlottableProps<P> & RefAttributes<E>> {
+  const wrapped = (props: SlottableProps<P> & HTMLAttributes<E>, forwardedRef: ForwardedRef<E>) => {
+    let warn = false;
+    if (props.asChild) {
+      try {
+        const child = Children.only(props.children);
+        if (isValidElement(child) && typeof child.type !== 'string' && !(child.type as any)[COMPOSABLE]) {
+          warn = true;
+          log.warn('slot child is not composable; create it with composable() or slottable()', {
+            child: (child.type as any).displayName ?? (child.type as any).name,
+          });
+        }
+      } catch {
+        // Children.only throws if not exactly one child — Slot handles this.
+      }
+    }
+
+    const result = render(props, forwardedRef);
+    if (warn) {
+      return createElement('div', { role: 'none', className: 'dx-slot-warning' }, result);
+    }
+
+    return result;
+  };
+
+  const component = forwardRef(wrapped as any) as any;
+  (component as any)[COMPOSABLE] = true;
+  return component;
+}
+
+/**
+ * Factory for composable (leaf) components.
+ * The implementation receives full `HTMLAttributes<E>` so it can destructure `role`, `style`, etc.
+ * Consumers see only `ComposableProps<P>` — a narrow type exposing `classNames`, `className`,
+ * `children`, and the custom props `P`.
+ *
+ * For generic components, use `any` for the type parameter inside `composable` and
+ * cast the result to restore the generic signature for consumers.
+ *
+ * @example
+ * ```tsx
+ * const Leaf = composable<HTMLButtonElement>(({ children, ...props }, forwardedRef) => {
+ *   return (
+ *     <button {...composableProps(props, { classNames: 'btn' })} ref={forwardedRef}>
+ *       {children}
+ *     </button>
+ *   );
+ * });
+ * ```
+ */
+export function composable<E extends HTMLElement, P extends object = {}>(
+  render: (props: ComposableProps<P> & HTMLAttributes<E>, forwardedRef: ForwardedRef<E>) => ReactNode,
+): ForwardRefExoticComponent<ComposableProps<P> & RefAttributes<E>> {
+  const component = forwardRef(render as any) as any;
+  (component as any)[COMPOSABLE] = true;
+  return component;
+}

package/src/util/usePx.ts

@@ -0,0 +1,65 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import { useCallback, useEffect, useMemo, useState } from 'react';
+
+const getDocumentElementFontSize = () => parseFloat(getComputedStyle(document.documentElement).fontSize);
+
+/**
+ * React hook that converts rem values to pixels and updates when the root font size changes.
+ *
+ * @param rem The rem value to convert to pixels
+ * @returns The current pixel value equivalent of the rem input
+ */
+// TODO(burdon): Change to array.
+// TODO(burdon): Integrate with theme provider.
+export const usePx = (rem: number): number => {
+  const [fontSize, setFontSize] = useState(() => {
+    if (typeof document !== 'undefined') {
+      return getDocumentElementFontSize();
+    }
+
+    // Default fallback for SSR
+    return 16;
+  });
+
+  const updateFontSize = useCallback(() => {
+    setFontSize(getDocumentElementFontSize());
+  }, []);
+
+  useEffect(() => {
+    if (typeof document === 'undefined') {
+      return;
+    }
+
+    // Create a ResizeObserver to watch for font size changes on the document element
+    const resizeObserver = new ResizeObserver(updateFontSize);
+    resizeObserver.observe(document.documentElement);
+
+    // Also listen for viewport changes that might affect font size
+    const mediaQueryList = window.matchMedia('all');
+    const handleMediaChange = () => {
+      updateFontSize();
+    };
+
+    if (mediaQueryList.addEventListener) {
+      mediaQueryList.addEventListener('change', handleMediaChange);
+    } else {
+      // Fallback for older browsers
+      mediaQueryList.addListener(handleMediaChange);
+    }
+
+    return () => {
+      resizeObserver.disconnect();
+      if (mediaQueryList.removeEventListener) {
+        mediaQueryList.removeEventListener('change', handleMediaChange);
+      } else {
+        // Fallback for older browsers
+        mediaQueryList.removeListener(handleMediaChange);
+      }
+    };
+  }, []);
+
+  return useMemo(() => rem * fontSize, [fontSize]);
+};