@react-hive/honey-layout 12.1.0 → 14.0.0

package/dist/types/data.types.d.ts

@@ -3,7 +3,7 @@
  */
 import type { RefObject } from 'react';
 import type { HoneyStyledFunction } from '@react-hive/honey-style';
-import type { KeysWithNonArrayValues, Nullable } from './utility.types';
+import type { Nullable } from './utility.types';
 import type { HoneyKeyboardEventCode } from './dom.types';
 export type HoneyEffectResultFn<Props extends object> = HoneyStyledFunction<Props>;
 export type HoneyEffect<Config = unknown, Props extends object = object> = (config: Config) => HoneyEffectResultFn<Props>;
@@ -86,35 +86,3 @@ export interface HoneyActiveOverlay {
      */
     notifyListeners: (targetEventType: HoneyOverlayEventType, keyCode: HoneyKeyboardEventCode, e: KeyboardEvent) => void;
 }
-/**
- * Represents an item that has been flattened from a hierarchical data structure, with additional
- * properties to support tracking its position and relationships within the hierarchy.
- *
- * This type is particularly useful for scenarios where nested data structures, such as trees or
- * lists with sub-items, need to be transformed into a flat structure while preserving the depth
- * and parent-child relationships.
- *
- * @template OriginItem - The type of the original item from the hierarchical structure.
- * @template NestedListKey - The key within `OriginItem` that contains nested items or lists.
- */
-export type HoneyFlattenedItem<OriginItem extends object, NestedListKey extends string> = Omit<OriginItem, NestedListKey> & {
-    /**
-     * The optional id of the parent item in the flattened structure. This establishes the parent-child
-     * relationship and allows the reconstruction of the original hierarchy if needed.
-     */
-    parentId: OriginItem[KeysWithNonArrayValues<OriginItem>] | undefined;
-    /**
-     * The depth level of the item in the flattened structure. This indicates how deep the item is nested
-     * within the hierarchy, starting from 0 for top-level items.
-     *
-     * @default 0
-     */
-    depthLevel: number;
-    /**
-     * The total number of nested items that are contained within the current item. This helps to keep
-     * track of the overall size of the nested structure for each item.
-     *
-     * @default 0
-     */
-    totalNestedItems: number;
-};

package/dist/types/utility.types.d.ts

@@ -5,70 +5,3 @@
  */
 export type TimeoutId = ReturnType<typeof setTimeout>;
 export type Nullable<T> = T | null;
-/**
- * Extracts the keys from a given type `T` whose values match the specified `Condition`.
- *
- * @template T - The object type from which to extract keys.
- * @template Condition - The condition that the type of the values must satisfy to be included.
- *
- * @example
- * ```ts
- * type Example = { a: string; b: number; c: boolean };
- * type StringKeys = ExtractKeys<Example, string>; // "a"
- * ```
- */
-type ExtractKeys<T, Condition> = {
-    [K in keyof T]: T[K] extends Condition ? K : never;
-}[keyof T];
-/**
- * Excludes the keys from a given type `T` whose values match the specified `Condition`.
- *
- * @template T - The object type from which to exclude keys.
- * @template Condition - The condition that the type of the values must satisfy to be excluded.
- *
- * @example
- * ```ts
- * type Example = { a: string; b: number; c: boolean };
- * type NonNumberKeys = ExcludeKeys<Example, number>; // "a" | "c"
- * ```
- */
-type ExcludeKeys<T, Condition> = {
-    [K in keyof T]: T[K] extends Condition ? never : K;
-}[keyof T];
-/**
- * Extracts the keys from a given type `T` where the values are `string`, `null`, or `undefined`.
- *
- * @template T - The object type from which to extract string-related keys.
- *
- * @example
- * ```ts
- * type Example = { a: string; b: number; c: string | null };
- * type StringKeys = KeysWithStringValues<Example>; // "a" | "c"
- * ```
- */
-export type KeysWithStringValues<T> = Extract<ExtractKeys<T, string | null | undefined>, string>;
-/**
- * Extracts the keys from a given type `T` where the values are arrays (`unknown[]`), `null`, or `undefined`.
- *
- * @template T - The object type from which to extract array-related keys.
- *
- * @example
- * ```ts
- * type Example = { a: string[]; b: number; c: number[] | null };
- * type ArrayKeys = KeysWithArrayValues<Example>; // "a" | "c"
- * ```
- */
-export type KeysWithArrayValues<T> = Extract<ExtractKeys<T, unknown[] | null | undefined>, string>;
-/**
- * Extracts the keys from a given type `T` where the values are **not** arrays (`unknown[]`), `null`, or `undefined`.
- *
- * @template T - The object type from which to extract non-array keys.
- *
- * @example
- * ```ts
- * type Example = { a: string; b: number; c: string[]; d: null };
- * type NonArrayKeys = KeysWithNonArrayValues<Example>; // "a" | "b"
- * ```
- */
-export type KeysWithNonArrayValues<T> = Extract<ExcludeKeys<T, unknown[] | null | undefined>, string>;
-export {};

package/dist/utils/index.d.ts

@@ -1,2 +1 @@
 export * from './feedback';
-export * from './data-utils';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@react-hive/honey-layout",
-  "version": "12.1.0",
+  "version": "14.0.0",
   "description": "",
   "keywords": [
     "react",
@@ -41,14 +41,14 @@
     "!dist/**/jest*"
   ],
   "peerDependencies": {
-    "@react-hive/honey-style": "^2.0.0",
+    "@react-hive/honey-style": "^3.0.0",
     "react": "^19.0.0",
     "react-dom": "^19.0.0"
   },
   "dependencies": {
-    "@floating-ui/dom": "1.7.4",
-    "@floating-ui/react": "0.27.16",
-    "@react-hive/honey-utils": "3.21.0",
+    "@floating-ui/dom": "1.7.5",
+    "@floating-ui/react": "0.27.17",
+    "@react-hive/honey-utils": "3.23.0",
     "csstype": "3.2.3",
     "highlight.js": "11.11.1",
     "lodash.merge": "4.6.2",
@@ -65,28 +65,28 @@
     "@types/lodash.merge": "4.6.9",
     "@types/lodash.throttle": "4.1.9",
     "@types/mdx": "2.0.13",
-    "@types/node": "22.19.3",
-    "@types/react": "^19.2.7",
+    "@types/node": "22.19.11",
+    "@types/react": "^19.2.13",
     "@types/react-dom": "^19.2.3",
     "copy-webpack-plugin": "13.0.1",
     "css-loader": "7.1.2",
     "eslint": "9.39.2",
     "eslint-plugin-react": "7.37.5",
-    "html-webpack-plugin": "5.6.5",
+    "html-webpack-plugin": "5.6.6",
     "husky": "9.1.7",
     "jest": "29.7.0",
     "jest-environment-jsdom": "29.7.0",
-    "prettier": "3.7.4",
+    "prettier": "3.8.1",
     "style-loader": "4.0.0",
     "ts-jest": "29.4.6",
     "ts-loader": "9.5.4",
     "ts-node": "10.9.2",
     "tsx": "4.21.0",
     "typescript": "5.9.3",
-    "typescript-eslint": "8.52.0",
-    "webpack": "5.104.1",
+    "typescript-eslint": "8.55.0",
+    "webpack": "5.105.1",
     "webpack-cli": "6.0.1",
-    "webpack-dev-server": "5.2.2"
+    "webpack-dev-server": "5.2.3"
   },
   "jest": {
     "preset": "ts-jest",

package/dist/utils/data-utils.d.ts

@@ -1,91 +0,0 @@
-import type { HoneyFlattenedItem, KeysWithArrayValues, KeysWithNonArrayValues, KeysWithStringValues } from '../types';
-/**
- * Recursively converts a nested list structure into a flat list. It excludes the nested list key from the result
- * while adding hierarchical metadata, such as `depthLevel`, `parentId`, and `totalNestedItems` to each flattened item.
- *
- * This function is useful for flattening deeply nested tree-like structures (e.g., categories, folders)
- * while preserving their relationships and depth levels in the hierarchy.
- *
- * @template OriginItem - The type of the items in the nested list.
- *
- * @param items - The array of items to be flattened. If undefined, it returns an empty array.
- * @param itemIdKey - The key in each item that uniquely identifies it (e.g., 'id').
- * @param nestedItemsKey - The key in each item that contains the nested items or list (e.g., 'children').
- * @param flattenedItemsResult - An array that accumulates the flattened items. Defaults to an empty array.
- * @param parentId - Optional. The ID of the parent item in the flattened structure. Defaults to undefined for top-level items.
- * @param depthLevel - Optional. The current depth level of the item in the nested structure. Defaults to 0 for top-level items.
- *
- * @returns A flat array of items, where the nested list key is removed, and each item includes:
- * - `parentId`: ID of its parent item in the flattened structure (undefined for top-level items).
- * - `depthLevel`: The depth level of the item in the hierarchy, with 0 being the top-level.
- * - `totalNestedItems`: The total number of direct child items within the current item (defaults to 0 for leaf nodes).
- *
- * @example
- * ```ts
- * const nestedData = [
- *   { id: 1, name: 'Item 1', children: [{ id: 2, name: 'Item 1.1' }] },
- *   { id: 3, name: 'Item 2', children: [] },
- * ];
- *
- * const flatList = flattenNestedList(nestedData, 'id', 'children');
- *
- * // Output:
- * // [
- * //   { id: 1, name: 'Item 1', parentId: undefined, depthLevel: 0, totalNestedItems: 1 },
- * //   { id: 2, name: 'Item 1.1', parentId: 1, depthLevel: 1, totalNestedItems: 0 },
- * //   { id: 3, name: 'Item 2', parentId: undefined, depthLevel: 0, totalNestedItems: 0 }
- * // ]
- * ```
- */
-export declare const flattenNestedList: <OriginItem extends object>(items: OriginItem[] | undefined, itemIdKey: KeysWithNonArrayValues<OriginItem>, nestedItemsKey: KeysWithArrayValues<OriginItem>, flattenedItemsResult?: HoneyFlattenedItem<OriginItem, typeof nestedItemsKey>[], parentId?: OriginItem[KeysWithNonArrayValues<OriginItem>] | undefined, depthLevel?: number) => HoneyFlattenedItem<OriginItem, typeof nestedItemsKey>[];
-/**
- * Filters a list of flattened items based on a specified parent ID and an optional predicate function.
- *
- * This utility is useful for extracting items that share the same parent in a flattened hierarchical
- * structure, such as categories or tree-like data. Optionally, it allows further filtering through a
- * custom predicate function.
- *
- * @template OriginItem - The type of the items in the flattened list.
- * @template NestedListKey - The key within `OriginItem` that contains nested items or lists.
- *
- * @param flattenedItems - The array of flattened items to filter, which contains items with hierarchical metadata.
- * @param parentId - The parent ID to filter the items by. Only items with this parent ID will be included in the result.
- * @param predicate - Optional. A custom function to apply additional filtering logic on items that match the parent ID.
- *
- * @returns An array of flattened items that match the specified `parentId`, and if provided, the `predicate` function.
- *
- * @example
- * ```ts
- * const filteredItems = filterFlattenedItems(flatList, 1, item => item.depthLevel > 1);
- *
- * // This would return items with `parentId` equal to 1, and where `depthLevel` is greater than 1.
- * ```
- */
-export declare const filterFlattenedItems: <OriginItem extends object, NestedListKey extends string>(flattenedItems: HoneyFlattenedItem<OriginItem, NestedListKey>[], parentId: OriginItem[KeysWithNonArrayValues<OriginItem>], predicate?: (flattenedItem: HoneyFlattenedItem<OriginItem, NestedListKey>) => boolean) => HoneyFlattenedItem<OriginItem, NestedListKey>[];
-/**
- * Searches through a list of flattened items to find matches based on a search query.
- * This function considers both the items themselves and their parents in the hierarchy, ensuring that
- * any matching items and their respective parents are included in the result.
- *
- * The search is case-insensitive and can handle partial matches, making it useful for dynamic filtering
- * of hierarchical data such as categories or trees.
- *
- * @template OriginItem - The type of the original item.
- * @template NestedListKey - The key within `OriginItem` that contains nested items or lists.
- *
- * @param flattenedItems - The array of flattened items to search through, which may include hierarchical metadata.
- * @param itemIdKey - The key used to uniquely identify each item (e.g., 'id').
- * @param valueKey - The key in each item that contains the value to be searched (e.g., 'name').
- * @param searchQuery - The query string used to filter items. Supports partial matches.
- *
- * @returns An array of matched flattened items, including their parent items if applicable.
- *
- * @example
- * ```ts
- * const searchResults = searchFlattenedItems(flatList, 'id', 'name', 'search term');
- *
- * // This will return items where the 'name' field matches the search term,
- * // including any relevant parent items in the hierarchy.
- * ```
- */
-export declare const searchFlattenedItems: <OriginItem extends object, NestedListKey extends string>(flattenedItems: HoneyFlattenedItem<OriginItem, NestedListKey>[], itemIdKey: KeysWithNonArrayValues<OriginItem>, valueKey: KeysWithStringValues<OriginItem>, searchQuery: string) => HoneyFlattenedItem<OriginItem, NestedListKey>[];