@basic-ui/core 0.0.52 → 0.0.53

package/src/utils/create-subscription.ts

@@ -1,16 +1,16 @@
-export function createSubscription() {
-  const subscriptions: (() => void)[] = [];
-
-  function subscribe(fn: () => void) {
-    subscriptions.push(fn);
-    return () => {
-      subscriptions.splice(subscriptions.indexOf(fn), 1);
-    };
-  }
-
-  function notify() {
-    subscriptions.forEach((fn) => fn());
-  }
-
-  return { subscribe, notify };
-}
+export function createSubscription() {
+  const subscriptions: (() => void)[] = [];
+
+  function subscribe(fn: () => void) {
+    subscriptions.push(fn);
+    return () => {
+      subscriptions.splice(subscriptions.indexOf(fn), 1);
+    };
+  }
+
+  function notify() {
+    subscriptions.forEach((fn) => fn());
+  }
+
+  return { subscribe, notify };
+}

package/src/utils/get-circular-index.ts

@@ -1,7 +1,7 @@
-export function getCircularIndex(index: number, maxLength: number) {
-  if (maxLength < 0) {
-    return null;
-  }
-
-  return ((index % maxLength) + maxLength) % maxLength;
-}
+export function getCircularIndex(index: number, maxLength: number) {
+  if (maxLength < 0) {
+    return null;
+  }
+
+  return ((index % maxLength) + maxLength) % maxLength;
+}

package/src/utils/index.ts

@@ -1,10 +1,10 @@
-export * from './assign-ref';
-export * from './can-use-dom';
-export * from './context';
-export * from './get-circular-index';
-export * from './is-right-click';
-export * from './owner-document';
-export * from './polymorphic';
-export * from './rubber-band-clamp';
-export * from './use-stable-callback';
-export * from './wrap-event';
+export * from './assign-ref';
+export * from './can-use-dom';
+export * from './context';
+export * from './get-circular-index';
+export * from './is-right-click';
+export * from './owner-document';
+export * from './polymorphic';
+export * from './rubber-band-clamp';
+export * from './use-stable-callback';
+export * from './wrap-event';

package/src/utils/is-right-click.ts

@@ -1,14 +1,14 @@
-/**
- * Detects right clicks
- *
- * @param nativeEvent
- */
-export function isRightClick(
-  nativeEvent: MouseEvent | PointerEvent | TouchEvent
-) {
-  return 'which' in nativeEvent
-    ? nativeEvent.which === 3
-    : 'button' in nativeEvent
-    ? (nativeEvent as any).button === 2
-    : false;
-}
+/**
+ * Detects right clicks
+ *
+ * @param nativeEvent
+ */
+export function isRightClick(
+  nativeEvent: MouseEvent | PointerEvent | TouchEvent
+) {
+  return 'which' in nativeEvent
+    ? nativeEvent.which === 3
+    : 'button' in nativeEvent
+    ? (nativeEvent as any).button === 2
+    : false;
+}

package/src/utils/owner-document.ts

@@ -1,13 +1,13 @@
-import { canUseDOM } from './can-use-dom';
-
-/**
- * Get an element's owner document. Useful when components are used in iframes
- * or other environments like dev tools.
- *
- * @param element
- */
-export function getOwnerDocument<T extends Element>(
-  element: T | null | undefined
-) {
-  return canUseDOM() ? (element ? element.ownerDocument : document) : null;
-}
+import { canUseDOM } from './can-use-dom';
+
+/**
+ * Get an element's owner document. Useful when components are used in iframes
+ * or other environments like dev tools.
+ *
+ * @param element
+ */
+export function getOwnerDocument<T extends Element>(
+  element: T | null | undefined
+) {
+  return canUseDOM() ? (element ? element.ownerDocument : document) : null;
+}

package/src/utils/polymorphic.ts

@@ -1,78 +1,78 @@
-/* eslint-disable @typescript-eslint/ban-types */
-// adapted from https://github.com/radix-ui/primitives/blob/2f139a832ba0cdfd445c937ebf63c2e79e0ef7ed/packages/react/polymorphic/src/polymorphic.ts
-// Would have liked to use it directly instead of copying but they are
-// (rightfully) treating it as an internal utility, so copy/paste it is to
-// prevent any needless churn if they make breaking changes. Big thanks to Jenna
-// for the heavy lifting! https://github.com/jjenzz
-
-import type * as React from 'react';
-
-// eslint-disable-next-line @typescript-eslint/ban-types
-export type Merge<P1 = {}, P2 = {}> = Omit<P1, keyof P2> & P2;
-
-/**
- * Infers the OwnProps if E is a ForwardRefExoticComponentWithAs
- */
-export type OwnProps<E> = E extends ForwardRefComponent<any, infer P> ? P : {};
-
-/**
- * Infers the JSX.IntrinsicElement if E is a ForwardRefExoticComponentWithAs
- */
-export type IntrinsicElement<E> = E extends ForwardRefComponent<infer I, any>
-  ? I
-  : never;
-
-type ForwardRefExoticComponent<E, OwnProps> = React.ForwardRefExoticComponent<
-  Merge<
-    E extends React.ElementType ? React.ComponentPropsWithRef<E> : never,
-    OwnProps & { as?: E; innerAs?: E }
-  >
->;
-
-export interface ForwardRefComponent<
-  IntrinsicElementString,
-  OwnProps = {}
-  /*
-   * Extends original type to ensure built in React types play nice with
-   * polymorphic components still e.g. `React.ElementRef` etc.
-   */
-> extends ForwardRefExoticComponent<IntrinsicElementString, OwnProps> {
-  /*
-   * When `as` prop is passed, use this overload. Merges original own props
-   * (without DOM props) and the inferred props from `as` element with the own
-   * props taking precendence.
-   *
-   * We explicitly avoid `React.ElementType` and manually narrow the prop types
-   * so that events are typed when using JSX.IntrinsicElements.
-   */
-  <As = IntrinsicElementString>(
-    props: As extends ''
-      ? {
-          as: keyof JSX.IntrinsicElements;
-          innerAs?: keyof JSX.IntrinsicElements;
-        }
-      : As extends React.ComponentType<infer P>
-      ? Merge<P, OwnProps & { as: As; innerAs?: As }>
-      : As extends keyof JSX.IntrinsicElements
-      ? Merge<JSX.IntrinsicElements[As], OwnProps & { as: As; innerAs?: As }>
-      : never
-  ): React.ReactElement | null;
-}
-
-export interface MemoComponent<IntrinsicElementString, OwnProps = {}>
-  extends React.MemoExoticComponent<
-    ForwardRefComponent<IntrinsicElementString, OwnProps>
-  > {
-  <As = IntrinsicElementString>(
-    props: As extends ''
-      ? {
-          as: keyof JSX.IntrinsicElements;
-          innerAs?: keyof JSX.IntrinsicElements;
-        }
-      : As extends React.ComponentType<infer P>
-      ? Merge<P, OwnProps & { as: As; innerAs?: As }>
-      : As extends keyof JSX.IntrinsicElements
-      ? Merge<JSX.IntrinsicElements[As], OwnProps & { as: As; innerAs?: As }>
-      : never
-  ): React.ReactElement | null;
-}
+/* eslint-disable @typescript-eslint/ban-types */
+// adapted from https://github.com/radix-ui/primitives/blob/2f139a832ba0cdfd445c937ebf63c2e79e0ef7ed/packages/react/polymorphic/src/polymorphic.ts
+// Would have liked to use it directly instead of copying but they are
+// (rightfully) treating it as an internal utility, so copy/paste it is to
+// prevent any needless churn if they make breaking changes. Big thanks to Jenna
+// for the heavy lifting! https://github.com/jjenzz
+
+import type * as React from 'react';
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+export type Merge<P1 = {}, P2 = {}> = Omit<P1, keyof P2> & P2;
+
+/**
+ * Infers the OwnProps if E is a ForwardRefExoticComponentWithAs
+ */
+export type OwnProps<E> = E extends ForwardRefComponent<any, infer P> ? P : {};
+
+/**
+ * Infers the JSX.IntrinsicElement if E is a ForwardRefExoticComponentWithAs
+ */
+export type IntrinsicElement<E> = E extends ForwardRefComponent<infer I, any>
+  ? I
+  : never;
+
+type ForwardRefExoticComponent<E, OwnProps> = React.ForwardRefExoticComponent<
+  Merge<
+    E extends React.ElementType ? React.ComponentPropsWithRef<E> : never,
+    OwnProps & { as?: E; innerAs?: E }
+  >
+>;
+
+export interface ForwardRefComponent<
+  IntrinsicElementString,
+  OwnProps = {}
+  /*
+   * Extends original type to ensure built in React types play nice with
+   * polymorphic components still e.g. `React.ElementRef` etc.
+   */
+> extends ForwardRefExoticComponent<IntrinsicElementString, OwnProps> {
+  /*
+   * When `as` prop is passed, use this overload. Merges original own props
+   * (without DOM props) and the inferred props from `as` element with the own
+   * props taking precendence.
+   *
+   * We explicitly avoid `React.ElementType` and manually narrow the prop types
+   * so that events are typed when using JSX.IntrinsicElements.
+   */
+  <As = IntrinsicElementString>(
+    props: As extends ''
+      ? {
+          as: keyof JSX.IntrinsicElements;
+          innerAs?: keyof JSX.IntrinsicElements;
+        }
+      : As extends React.ComponentType<infer P>
+      ? Merge<P, OwnProps & { as: As; innerAs?: As }>
+      : As extends keyof JSX.IntrinsicElements
+      ? Merge<JSX.IntrinsicElements[As], OwnProps & { as: As; innerAs?: As }>
+      : never
+  ): React.ReactElement | null;
+}
+
+export interface MemoComponent<IntrinsicElementString, OwnProps = {}>
+  extends React.MemoExoticComponent<
+    ForwardRefComponent<IntrinsicElementString, OwnProps>
+  > {
+  <As = IntrinsicElementString>(
+    props: As extends ''
+      ? {
+          as: keyof JSX.IntrinsicElements;
+          innerAs?: keyof JSX.IntrinsicElements;
+        }
+      : As extends React.ComponentType<infer P>
+      ? Merge<P, OwnProps & { as: As; innerAs?: As }>
+      : As extends keyof JSX.IntrinsicElements
+      ? Merge<JSX.IntrinsicElements[As], OwnProps & { as: As; innerAs?: As }>
+      : never
+  ): React.ReactElement | null;
+}

package/src/utils/rubber-band-clamp.ts

@@ -1,25 +1,25 @@
-// https://twitter.com/chpwn/status/285540192096497664
-// iOS constant = 0.55
-export function rubberBand(
-  distance: number,
-  dimension: number,
-  constant = 0.15
-) {
-  return (distance * dimension * constant) / (dimension + constant * distance);
-}
-
-export function rubberBandClamp(
-  min: number,
-  max: number,
-  delta: number,
-  constant = 0.15
-) {
-  if (delta < min) {
-    return -rubberBand(min - delta, max - min, constant) + min;
-  }
-  if (delta > max) {
-    return rubberBand(delta - max, max - min, constant) + max;
-  }
-
-  return delta;
-}
+// https://twitter.com/chpwn/status/285540192096497664
+// iOS constant = 0.55
+export function rubberBand(
+  distance: number,
+  dimension: number,
+  constant = 0.15
+) {
+  return (distance * dimension * constant) / (dimension + constant * distance);
+}
+
+export function rubberBandClamp(
+  min: number,
+  max: number,
+  delta: number,
+  constant = 0.15
+) {
+  if (delta < min) {
+    return -rubberBand(min - delta, max - min, constant) + min;
+  }
+  if (delta > max) {
+    return rubberBand(delta - max, max - min, constant) + max;
+  }
+
+  return delta;
+}

package/src/utils/use-stable-callback.ts

@@ -1,58 +1,58 @@
-/* eslint-disable react-hooks/rules-of-hooks */
-import { useRef, useEffect, useCallback, useLayoutEffect } from 'react';
-import type * as React from 'react';
-
-const useEnhancedEffect =
-  typeof window !== 'undefined' ? useLayoutEffect : useEffect;
-
-/**
- * Converts a callback to a ref to avoid triggering re-renders when passed as a
- * prop and exposed as a stable function to avoid executing effects when
- * passed as a dependency.
- */
-function createStableCallbackHook<T extends (...args: any[]) => any>(
-  useEffectHook: (
-    effect: React.EffectCallback,
-    deps?: React.DependencyList | undefined
-  ) => void,
-  callback: T | null | undefined
-): T {
-  const callbackRef = useRef(callback);
-  useEffectHook(() => {
-    callbackRef.current = callback;
-  });
-
-  // eslint-disable-next-line react-hooks/exhaustive-deps
-  return useCallback(
-    ((...args) => {
-      callbackRef.current && callbackRef.current(...args);
-    }) as T,
-    []
-  );
-}
-
-/**
- * Converts a callback to a ref to avoid triggering re-renders when passed as a
- * prop and exposed as a stable function to avoid executing effects when passed
- * as a dependency.
- */
-export function useStableCallback<T extends (...args: any[]) => any>(
-  callback: T | null | undefined
-): T {
-  return createStableCallbackHook(useEffect, callback);
-}
-
-/**
- * Converts a callback to a ref to avoid triggering re-renders when passed as a
- * prop and exposed as a stable function to avoid executing effects when passed
- * as a dependency.
- *
- * Use this over `useStableCallback` when you want the callback to be cached in
- * `useLayoutEffect` instead of `useEffect` to deal with timing issues only when
- * needed.
- */
-export function useStableLayoutCallback<T extends (...args: any[]) => any>(
-  callback: T | null | undefined
-): T {
-  return createStableCallbackHook(useEnhancedEffect, callback);
-}
+/* eslint-disable react-hooks/rules-of-hooks */
+import { useRef, useEffect, useCallback, useLayoutEffect } from 'react';
+import type * as React from 'react';
+
+const useEnhancedEffect =
+  typeof window !== 'undefined' ? useLayoutEffect : useEffect;
+
+/**
+ * Converts a callback to a ref to avoid triggering re-renders when passed as a
+ * prop and exposed as a stable function to avoid executing effects when
+ * passed as a dependency.
+ */
+function createStableCallbackHook<T extends (...args: any[]) => any>(
+  useEffectHook: (
+    effect: React.EffectCallback,
+    deps?: React.DependencyList | undefined
+  ) => void,
+  callback: T | null | undefined
+): T {
+  const callbackRef = useRef(callback);
+  useEffectHook(() => {
+    callbackRef.current = callback;
+  });
+
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  return useCallback(
+    ((...args) => {
+      callbackRef.current && callbackRef.current(...args);
+    }) as T,
+    []
+  );
+}
+
+/**
+ * Converts a callback to a ref to avoid triggering re-renders when passed as a
+ * prop and exposed as a stable function to avoid executing effects when passed
+ * as a dependency.
+ */
+export function useStableCallback<T extends (...args: any[]) => any>(
+  callback: T | null | undefined
+): T {
+  return createStableCallbackHook(useEffect, callback);
+}
+
+/**
+ * Converts a callback to a ref to avoid triggering re-renders when passed as a
+ * prop and exposed as a stable function to avoid executing effects when passed
+ * as a dependency.
+ *
+ * Use this over `useStableCallback` when you want the callback to be cached in
+ * `useLayoutEffect` instead of `useEffect` to deal with timing issues only when
+ * needed.
+ */
+export function useStableLayoutCallback<T extends (...args: any[]) => any>(
+  callback: T | null | undefined
+): T {
+  return createStableCallbackHook(useEnhancedEffect, callback);
+}

package/src/utils/wrap-event.ts

@@ -1,22 +1,22 @@
-import type { SyntheticEvent } from 'react';
-
-export type CustomEventHandler<
-  E extends SyntheticEvent<any> | Event,
-  H extends unknown[]
-> = (e: E, ...args: H) => void;
-
-export function wrapEvent<
-  EventType extends SyntheticEvent<any> | Event,
-  H extends unknown[]
->(
-  theirHandler: CustomEventHandler<EventType, H> | undefined,
-  ourHandler: CustomEventHandler<EventType, H>
-): CustomEventHandler<EventType, H> {
-  return (event: EventType, ...otherArgs: H) => {
-    const ret = theirHandler && theirHandler(event, ...otherArgs);
-    if (!event || !event.defaultPrevented) {
-      return ourHandler(event, ...otherArgs);
-    }
-    return ret;
-  };
-}
+import type { SyntheticEvent } from 'react';
+
+export type CustomEventHandler<
+  E extends SyntheticEvent<any> | Event,
+  H extends unknown[]
+> = (e: E, ...args: H) => void;
+
+export function wrapEvent<
+  EventType extends SyntheticEvent<any> | Event,
+  H extends unknown[]
+>(
+  theirHandler: CustomEventHandler<EventType, H> | undefined,
+  ourHandler: CustomEventHandler<EventType, H>
+): CustomEventHandler<EventType, H> {
+  return (event: EventType, ...otherArgs: H) => {
+    const ret = theirHandler && theirHandler(event, ...otherArgs);
+    if (!event || !event.defaultPrevented) {
+      return ourHandler(event, ...otherArgs);
+    }
+    return ret;
+  };
+}