@box/blueprint-web 16.8.3 → 16.8.5

package/dist/lib-esm/utils/chunk.js

@@ -0,0 +1,17 @@
+/**
+ * Splits `array` into groups of length `size`. The final group holds the remaining
+ * elements. Mirrors `lodash/chunk`: a size below 1 yields an empty array.
+ */
+const chunk = (array, size = 1) => {
+  const chunkSize = Math.max(Math.trunc(size), 0);
+  if (!Array.isArray(array) || chunkSize < 1) {
+    return [];
+  }
+  const result = [];
+  for (let i = 0; i < array.length; i += chunkSize) {
+    result.push(array.slice(i, i + chunkSize));
+  }
+  return result;
+};
+
+export { chunk };

package/dist/lib-esm/utils/deepMerge.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Recursively merges own enumerable properties of the `sources` into `target`, mutating and
+ * returning `target`. Covers the plain-object usage of `lodash/merge` in this package:
+ * undefined source values are skipped and source objects are never mutated. React elements
+ * (and other `$$typeof`-tagged objects) are treated as opaque values rather than merged.
+ *
+ * `target` and the sources are constrained to objects: primitives cannot be mutated in place and
+ * would fail at runtime. A nullish `target` is returned unchanged (nothing is merged), so callers
+ * holding a possibly-undefined target (e.g. `Map.get()`) must narrow it before merging into it.
+ */
+export declare function deepMerge<TObject extends object, TSource extends object>(target: TObject, source: TSource): TObject & TSource;
+export declare function deepMerge<TObject extends object, TSource1 extends object, TSource2 extends object>(target: TObject, source1: TSource1, source2: TSource2): TObject & TSource1 & TSource2;
+export declare function deepMerge<TTarget extends null | undefined>(target: TTarget, ...sources: object[]): TTarget;

package/dist/lib-esm/utils/deepMerge.js

@@ -0,0 +1,70 @@
+// Keys that can mutate an object's prototype chain (prototype pollution). Sources passed to
+// deepMerge are not guaranteed to be trusted (e.g. caller-provided notification props), so these
+// are never copied or merged onto the target.
+const UNSAFE_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+const isUnsafeKey = key => UNSAFE_KEYS.has(key);
+const isPlainObject = value => {
+  if (typeof value !== 'object' || value === null) {
+    return false;
+  }
+  // Never recurse into React elements (or other tagged objects): treat them as opaque values.
+  if ('$$typeof' in value) {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+};
+const cloneDeep = value => {
+  if (Array.isArray(value)) {
+    return value.map(cloneDeep);
+  }
+  if (isPlainObject(value)) {
+    const output = {};
+    for (const key of Object.keys(value)) {
+      if (isUnsafeKey(key)) {
+        continue; // eslint-disable-line no-continue
+      }
+      output[key] = cloneDeep(value[key]);
+    }
+    return output;
+  }
+  return value;
+};
+const mergeInto = (target, source) => {
+  for (const key of Object.keys(source)) {
+    // Skip prototype-polluting keys before touching the target.
+    if (isUnsafeKey(key)) {
+      continue; // eslint-disable-line no-continue
+    }
+    const sourceValue = source[key];
+    // Matches lodash/merge: undefined source values never overwrite an existing value.
+    if (sourceValue === undefined) {
+      continue; // eslint-disable-line no-continue
+    }
+    const targetValue = target[key];
+    if (isPlainObject(sourceValue)) {
+      if (isPlainObject(targetValue)) {
+        mergeInto(targetValue, sourceValue);
+      } else {
+        // Clone so the merged result never shares references with (and cannot mutate) a source.
+        target[key] = cloneDeep(sourceValue);
+      }
+    } else {
+      target[key] = sourceValue;
+    }
+  }
+};
+// eslint-disable-next-line @typescript-eslint/no-explicit-any, no-redeclare -- overload implementation
+function deepMerge(target, ...sources) {
+  if (target == null) {
+    return target;
+  }
+  for (const source of sources) {
+    if (source != null) {
+      mergeInto(target, source);
+    }
+  }
+  return target;
+}
+
+export { deepMerge };

package/dist/lib-esm/utils/isDefined.js

@@ -1,8 +1,6 @@
-import isUndefined from 'lodash/isUndefined';
-
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 const isDefined = value => {
-  return !isUndefined(value);
+  return value !== undefined;
 };
 
 export { isDefined };

package/dist/lib-esm/utils/mapValues.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Creates a new object with the same keys as `object`, running each own enumerable
+ * value through `iteratee`. Mirrors `lodash/mapValues`: a nullish input yields `{}`.
+ * The iteratee value is intentionally `any` to match lodash's permissive typing so that
+ * existing call sites compile unchanged under `strictFunctionTypes`.
+ */
+export declare const mapValues: <T extends object, R>(object: T | null | undefined, iteratee: (value: any, key: string, collection: T) => R) => { [K in keyof T]: R; };

package/dist/lib-esm/utils/mapValues.js

@@ -0,0 +1,20 @@
+/**
+ * Creates a new object with the same keys as `object`, running each own enumerable
+ * value through `iteratee`. Mirrors `lodash/mapValues`: a nullish input yields `{}`.
+ * The iteratee value is intentionally `any` to match lodash's permissive typing so that
+ * existing call sites compile unchanged under `strictFunctionTypes`.
+ */
+const mapValues = (object,
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+iteratee) => {
+  const result = {};
+  if (object == null) {
+    return result;
+  }
+  for (const key of Object.keys(object)) {
+    result[key] = iteratee(object[key], key, object);
+  }
+  return result;
+};
+
+export { mapValues };

package/dist/lib-esm/utils/noop.d.ts

@@ -0,0 +1 @@
+export declare const noop: () => void;

package/dist/lib-esm/utils/noop.js

@@ -0,0 +1,5 @@
+const noop = () => {
+  // Intentionally does nothing. Local replacement for `lodash/noop`.
+};
+
+export { noop };

package/dist/lib-esm/utils/omit.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns a shallow copy of `object` without the given top-level `keys`.
+ * Covers the flat-key usage of `lodash/omit` in this package (no deep paths). Keys that
+ * are not present on `object` are ignored, mirroring lodash's permissive behavior.
+ */
+export declare const omit: <T extends object>(object: T | null | undefined, keys: readonly PropertyKey[]) => Partial<T>;

package/dist/lib-esm/utils/omit.js

@@ -0,0 +1,20 @@
+/**
+ * Returns a shallow copy of `object` without the given top-level `keys`.
+ * Covers the flat-key usage of `lodash/omit` in this package (no deep paths). Keys that
+ * are not present on `object` are ignored, mirroring lodash's permissive behavior.
+ */
+const omit = (object, keys) => {
+  const result = {};
+  if (object == null) {
+    return result;
+  }
+  const excluded = new Set(keys);
+  for (const key of Object.keys(object)) {
+    if (!excluded.has(key)) {
+      result[key] = object[key];
+    }
+  }
+  return result;
+};
+
+export { omit };

package/dist/lib-esm/utils/scroll-context.js

@@ -1,6 +1,6 @@
 import { jsx } from 'react/jsx-runtime';
-import noop from 'lodash/noop';
 import { useContext, createContext, useState, useCallback, useMemo } from 'react';
+import { noop } from './noop.js';
 
 const ScrollContext = /*#__PURE__*/createContext({
   isScrolledUnderFooter: false,

package/dist/lib-esm/utils/throttle.d.ts

@@ -0,0 +1,11 @@
+export interface ThrottledFunction<Args extends unknown[]> {
+    (...args: Args): void;
+    cancel(): void;
+}
+/**
+ * Leading + trailing edge throttle, matching the default behavior of `lodash/throttle`
+ * for the subset of the API used in this package. The wrapped function is invoked
+ * immediately on the first call, then at most once per `wait` ms, and once more on the
+ * trailing edge with the most recent arguments.
+ */
+export declare const throttle: <Args extends unknown[]>(func: (...args: Args) => void, wait?: number) => ThrottledFunction<Args>;

package/dist/lib-esm/utils/throttle.js

@@ -0,0 +1,51 @@
+/**
+ * Leading + trailing edge throttle, matching the default behavior of `lodash/throttle`
+ * for the subset of the API used in this package. The wrapped function is invoked
+ * immediately on the first call, then at most once per `wait` ms, and once more on the
+ * trailing edge with the most recent arguments.
+ */
+const throttle = (func, wait = 0) => {
+  let lastInvokeTime;
+  let timeout;
+  let trailingArgs;
+  const invoke = (time, args) => {
+    lastInvokeTime = time;
+    func(...args);
+  };
+  const throttled = (...args) => {
+    const now = Date.now();
+    if (lastInvokeTime === undefined) {
+      invoke(now, args);
+      return;
+    }
+    const remaining = wait - (now - lastInvokeTime);
+    trailingArgs = args;
+    if (remaining <= 0) {
+      if (timeout) {
+        clearTimeout(timeout);
+        timeout = undefined;
+      }
+      invoke(now, args);
+      trailingArgs = undefined;
+    } else if (!timeout) {
+      timeout = setTimeout(() => {
+        timeout = undefined;
+        if (trailingArgs) {
+          invoke(Date.now(), trailingArgs);
+          trailingArgs = undefined;
+        }
+      }, remaining);
+    }
+  };
+  throttled.cancel = () => {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+    timeout = undefined;
+    lastInvokeTime = undefined;
+    trailingArgs = undefined;
+  };
+  return throttled;
+};
+
+export { throttle };

package/dist/lib-esm/utils/useIsEllipsized.js

@@ -1,5 +1,5 @@
-import noop from 'lodash/noop';
 import { useState, useEffect } from 'react';
+import { noop } from './noop.js';
 
 const useIsEllipsized = ref => {
   const [isEllipsized, setIsEllipsized] = useState(false);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@box/blueprint-web",
-    "version": "16.8.3",
+    "version": "16.8.5",
     "type": "module",
     "license": "SEE LICENSE IN LICENSE",
     "publishConfig": {
@@ -47,7 +47,7 @@
     "dependencies": {
         "@ariakit/react": "0.4.21",
         "@ariakit/react-core": "0.4.21",
-        "@box/blueprint-web-assets": "^5.5.1",
+        "@box/blueprint-web-assets": "^5.5.3",
         "@internationalized/date": "^3.12.0",
         "@radix-ui/react-accordion": "1.1.2",
         "@radix-ui/react-checkbox": "1.0.4",
@@ -71,16 +71,16 @@
         "@react-aria/utils": "3.33.1",
         "clsx": "^1.2.1",
         "color": "2.0.1",
-        "lodash": "^4.17.15",
         "react-aria": "3.47.0",
         "react-aria-components": "1.16.0",
         "type-fest": "^3.2.0"
     },
     "devDependencies": {
-        "@box/storybook-utils": "^1.1.25",
+        "@box/storybook-utils": "^1.1.27",
         "@figma/code-connect": "1.4.4",
         "@types/react": "^18.0.0",
         "@types/react-dom": "^18.0.0",
+        "lodash": "^4.17.15",
         "react": "^18.3.0",
         "react-dom": "^18.3.0",
         "react-stately": "^3.45.0",