@react-hive/honey-layout 1.1.0 → 2.2.0

package/dist/utils.d.ts

@@ -77,45 +77,92 @@ export declare const getTransformationValues: (element: HTMLElement) => {
     translateY: number;
 };
 /**
- * Converts a nested list structure into a flat list, excluding the nested list key from the result and adding depth level, parent ID, and total nested items properties.
+ * 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.
  *
- * @template OriginItem - The type of the items in the list.
+ * 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.
  *
- * @param items - The array of items to be flattened. Can be undefined.
- * @param itemIdKey - The key in each item that uniquely identifies it.
- * @param nestedItemsKey - The key in each item that contains the nested list.
- * @param result - The 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 parent item.
- * @param depthLevel - Optional. The current depth level of the item in the nested structure. Defaults to 0.
+ * @template OriginItem - The type of the items in the flattened list.
+ * @template NestedListKey - The key within `OriginItem` that contains nested items or lists.
  *
- * @returns A flat array of items, excluding the nested list key and including `depthLevel`, `parentId`, and `totalNestedItems` properties.
- */
-export declare const flattenNestedList: <OriginItem extends object>(items: OriginItem[] | undefined, itemIdKey: KeysWithNonArrayValues<OriginItem>, nestedItemsKey: KeysWithArrayValues<OriginItem>, result?: HoneyFlattenedItem<OriginItem, typeof nestedItemsKey>[], parentId?: OriginItem[KeysWithNonArrayValues<OriginItem>] | undefined, depthLevel?: number) => HoneyFlattenedItem<OriginItem, typeof nestedItemsKey>[];
-/**
- * Filters flattened items based on the specified parent ID and an optional predicate.
+ * @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.
  *
- * @template OriginItem - The type of the items in the list.
- * @template NestedListKey - The key within `Item` that contains nested items or lists.
+ * @returns An array of flattened items that match the specified `parentId`, and if provided, the `predicate` function.
  *
- * @param flattenedItems - The array of flattened items to filter.
- * @param parentId - The parent ID to filter the items by.
- * @param predicate - Optional. A function to further filter the flattened items that match the parent ID.
+ * @example
+ * ```ts
+ * const filteredItems = filterFlattenedItems(flatList, 1, item => item.depthLevel > 1);
  *
- * @returns An array of flattened items that match the specified parent ID and predicate.
+ * // 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.
- * The search considers both parent and nested items and ensures that matching items and their parents are included in the result.
+ * 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 the item that contains nested items or lists.
+ * @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.
  *
- * @param flattenedItems - The array of flattened items to search through.
- * @param itemIdKey - The key used to identify each item uniquely.
- * @param valueKey - The key in each item that contains the searchable value.
- * @param searchQuery - The search query string used to match items.
+ * @example
+ * ```ts
+ * const searchResults = searchFlattenedItems(flatList, 'id', 'name', 'search term');
  *
- * @returns An array of matched flattened items, including their parents if applicable.
+ * // 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>[];

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@react-hive/honey-layout",
-  "version": "1.1.0",
+  "version": "2.2.0",
   "description": "",
   "keywords": [
     "react",
     "layout",
-    "theme"
+    "theme",
+    "responsive"
   ],
   "homepage": "https://react-honey-layout.netlify.app",
   "bugs": {
@@ -31,10 +32,10 @@
   ],
   "peerDependencies": {
     "@mdx-js/react": "3.0.1",
-    "react": "18.2.0",
-    "react-dom": "18.2.0",
-    "react-router-dom": "6.26.1",
-    "styled-components": "5.3.11",
+    "react": ">=18.0.0",
+    "react-dom": ">=18.0.0",
+    "react-router-dom": "6.26.2",
+    "styled-components": "6.1.13",
     "highlight.js": "11.10.0"
   },
   "dependencies": {
@@ -44,12 +45,11 @@
   },
   "devDependencies": {
     "@testing-library/react": "16.0.1",
-    "@types/jest": "29.5.12",
+    "@types/jest": "29.5.13",
     "@typescript-eslint/eslint-plugin": "7.18.0",
     "@typescript-eslint/parser": "7.18.0",
-    "@types/react": "18.2.79",
-    "@types/react-dom": "18.2.25",
-    "@types/styled-components": "5.1.34",
+    "@types/react": ">=18.0.0",
+    "@types/react-dom": ">=18.0.0",
     "@types/mdx": "2.0.13",
     "@types/lodash.merge": "4.6.9",
     "@types/lodash.debounce": "4.0.9",
@@ -65,9 +65,9 @@
     "jest-environment-jsdom": "29.7.0",
     "prettier": "3.3.3",
     "ts-jest": "29.2.5",
-    "typescript": "5.5.4",
-    "vite": "5.4.3",
-    "vite-plugin-dts": "4.1.0",
+    "typescript": "5.6.2",
+    "vite": "5.4.7",
+    "vite-plugin-dts": "4.2.2",
     "vite-plugin-checker": "0.8.0"
   },
   "jest": {