@rio-cloud/rio-uikit 2.0.0-beta.1 → 2.0.0-beta.2

package/components/assetTree/treeReducer.js

@@ -1,34 +1,38 @@
-import invariant from 'tiny-invariant';
-export const assetCounted = (payload) => ({ type: 'assetCounted', payload });
-export const allCheckedChanged = (payload) => ({ type: 'allCheckedChanged', payload });
-export const searchValueChanged = (payload) => ({ type: 'searchValueChanged', payload });
-export const flatItemsChanged = (payload) => ({ type: 'flatItemsChanged', payload });
-export const groupedItemsChanged = (payload) => ({ type: 'groupedItemsChanged', payload });
-export const typeFilterChanged = (payload) => ({ type: 'typeFilterChanged', payload });
-export const visibleTypeCountersChanged = (payload) => ({
-    type: 'visibleTypeCountersChanged',
-    payload,
-});
-export const emptyGroupsChanged = (payload) => ({ type: 'emptyGroupsChanged', payload });
-export const treeReducer = (state, action) => {
-    switch (action.type) {
-        case 'assetCounted':
-            return { ...state, assetCounts: action.payload };
-        case 'allCheckedChanged':
-            return { ...state, allChecked: action.payload };
-        case 'searchValueChanged':
-            return { ...state, searchValue: action.payload, allChecked: false };
-        case 'flatItemsChanged':
-            return { ...state, flatItems: action.payload };
-        case 'groupedItemsChanged':
-            return { ...state, groupedItems: action.payload };
-        case 'typeFilterChanged':
-            return { ...state, typeFilter: action.payload };
-        case 'visibleTypeCountersChanged':
-            return { ...state, visibleTypeCounters: action.payload };
-        case 'emptyGroupsChanged':
-            return { ...state, emptyGroups: action.payload };
-        default:
-            invariant(false, 'Unknown action type in tree reducer');
-    }
+import t from "tiny-invariant";
+const n = (e) => ({ type: "assetCounted", payload: e }), r = (e) => ({ type: "allCheckedChanged", payload: e }), d = (e) => ({ type: "searchValueChanged", payload: e }), p = (e) => ({ type: "flatItemsChanged", payload: e }), l = (e) => ({ type: "groupedItemsChanged", payload: e }), C = (e) => ({ type: "typeFilterChanged", payload: e }), h = (e) => ({
+  type: "visibleTypeCountersChanged",
+  payload: e
+}), u = (e) => ({ type: "emptyGroupsChanged", payload: e }), o = (e, a) => {
+  switch (a.type) {
+    case "assetCounted":
+      return { ...e, assetCounts: a.payload };
+    case "allCheckedChanged":
+      return { ...e, allChecked: a.payload };
+    case "searchValueChanged":
+      return { ...e, searchValue: a.payload, allChecked: !1 };
+    case "flatItemsChanged":
+      return { ...e, flatItems: a.payload };
+    case "groupedItemsChanged":
+      return { ...e, groupedItems: a.payload };
+    case "typeFilterChanged":
+      return { ...e, typeFilter: a.payload };
+    case "visibleTypeCountersChanged":
+      return { ...e, visibleTypeCounters: a.payload };
+    case "emptyGroupsChanged":
+      return { ...e, emptyGroups: a.payload };
+    default:
+      t(!1, "Unknown action type in tree reducer");
+  }
 };
+export {
+  r as allCheckedChanged,
+  n as assetCounted,
+  u as emptyGroupsChanged,
+  p as flatItemsChanged,
+  l as groupedItemsChanged,
+  d as searchValueChanged,
+  o as treeReducer,
+  C as typeFilterChanged,
+  h as visibleTypeCountersChanged
+};
+//# sourceMappingURL=treeReducer.js.map

package/components/assetTree/treeReducer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"treeReducer.js","sources":["../../../src/components/assetTree/treeReducer.ts"],"sourcesContent":["import invariant from 'tiny-invariant';\n\nimport type { GroupedItems, TreeItem, TreeGroup } from './Tree';\nimport type { TreeSummaryCounts, AssetType } from './TreeSummary';\n\nexport type State = {\n    groupedItems: GroupedItems;\n    flatItems: TreeItem[];\n    allChecked: boolean;\n    searchValue: string;\n    assetCounts: TreeSummaryCounts;\n    typeFilter: string[];\n    visibleTypeCounters: AssetType[];\n    emptyGroups: TreeGroup[];\n};\n\ntype Action =\n    | { type: 'assetCounted'; payload: TreeSummaryCounts }\n    | { type: 'allCheckedChanged'; payload: boolean }\n    | { type: 'searchValueChanged'; payload: string }\n    | { type: 'flatItemsChanged'; payload: TreeItem[] }\n    | { type: 'groupedItemsChanged'; payload: GroupedItems }\n    | { type: 'typeFilterChanged'; payload: string[] }\n    | { type: 'visibleTypeCountersChanged'; payload: AssetType[] } // Adjust the type based on the actual structure\n    | { type: 'emptyGroupsChanged'; payload: TreeGroup[] };\n\nexport const assetCounted = (payload: TreeSummaryCounts): Action => ({ type: 'assetCounted', payload });\nexport const allCheckedChanged = (payload: boolean): Action => ({ type: 'allCheckedChanged', payload });\nexport const searchValueChanged = (payload: string): Action => ({ type: 'searchValueChanged', payload });\nexport const flatItemsChanged = (payload: TreeItem[]): Action => ({ type: 'flatItemsChanged', payload });\nexport const groupedItemsChanged = (payload: GroupedItems): Action => ({ type: 'groupedItemsChanged', payload });\nexport const typeFilterChanged = (payload: string[]): Action => ({ type: 'typeFilterChanged', payload });\nexport const visibleTypeCountersChanged = (payload: AssetType[]): Action => ({\n    type: 'visibleTypeCountersChanged',\n    payload,\n});\nexport const emptyGroupsChanged = (payload: TreeGroup[]): Action => ({ type: 'emptyGroupsChanged', payload });\n\nexport const treeReducer = (state: State, action: Action): State => {\n    switch (action.type) {\n        case 'assetCounted':\n            return { ...state, assetCounts: action.payload };\n        case 'allCheckedChanged':\n            return { ...state, allChecked: action.payload };\n        case 'searchValueChanged':\n            return { ...state, searchValue: action.payload, allChecked: false };\n        case 'flatItemsChanged':\n            return { ...state, flatItems: action.payload };\n        case 'groupedItemsChanged':\n            return { ...state, groupedItems: action.payload };\n        case 'typeFilterChanged':\n            return { ...state, typeFilter: action.payload };\n        case 'visibleTypeCountersChanged':\n            return { ...state, visibleTypeCounters: action.payload };\n        case 'emptyGroupsChanged':\n            return { ...state, emptyGroups: action.payload };\n        default:\n            invariant(false, 'Unknown action type in tree reducer');\n    }\n};\n"],"names":["assetCounted","payload","allCheckedChanged","searchValueChanged","flatItemsChanged","groupedItemsChanged","typeFilterChanged","visibleTypeCountersChanged","emptyGroupsChanged","treeReducer","state","action","invariant"],"mappings":";AA0BO,MAAMA,IAAe,CAACC,OAAwC,EAAE,MAAM,gBAAgB,SAAAA,EAAA,IAChFC,IAAoB,CAACD,OAA8B,EAAE,MAAM,qBAAqB,SAAAA,EAAA,IAChFE,IAAqB,CAACF,OAA6B,EAAE,MAAM,sBAAsB,SAAAA,EAAA,IACjFG,IAAmB,CAACH,OAAiC,EAAE,MAAM,oBAAoB,SAAAA,EAAA,IACjFI,IAAsB,CAACJ,OAAmC,EAAE,MAAM,uBAAuB,SAAAA,EAAA,IACzFK,IAAoB,CAACL,OAA+B,EAAE,MAAM,qBAAqB,SAAAA,EAAA,IACjFM,IAA6B,CAACN,OAAkC;AAAA,EACzE,MAAM;AAAA,EACN,SAAAA;AACJ,IACaO,IAAqB,CAACP,OAAkC,EAAE,MAAM,sBAAsB,SAAAA,EAAA,IAEtFQ,IAAc,CAACC,GAAcC,MAA0B;AAChE,UAAQA,EAAO,MAAA;AAAA,IACX,KAAK;AACD,aAAO,EAAE,GAAGD,GAAO,aAAaC,EAAO,QAAA;AAAA,IAC3C,KAAK;AACD,aAAO,EAAE,GAAGD,GAAO,YAAYC,EAAO,QAAA;AAAA,IAC1C,KAAK;AACD,aAAO,EAAE,GAAGD,GAAO,aAAaC,EAAO,SAAS,YAAY,GAAA;AAAA,IAChE,KAAK;AACD,aAAO,EAAE,GAAGD,GAAO,WAAWC,EAAO,QAAA;AAAA,IACzC,KAAK;AACD,aAAO,EAAE,GAAGD,GAAO,cAAcC,EAAO,QAAA;AAAA,IAC5C,KAAK;AACD,aAAO,EAAE,GAAGD,GAAO,YAAYC,EAAO,QAAA;AAAA,IAC1C,KAAK;AACD,aAAO,EAAE,GAAGD,GAAO,qBAAqBC,EAAO,QAAA;AAAA,IACnD,KAAK;AACD,aAAO,EAAE,GAAGD,GAAO,aAAaC,EAAO,QAAA;AAAA,IAC3C;AACI,MAAAC,EAAU,IAAO,qCAAqC;AAAA,EAAA;AAElE;"}

package/components/assetTree/treeUtils.d.ts

@@ -1,4 +1,4 @@
-import type { TreeItem, TreeGroup, GroupedItems } from './Tree';
+import { TreeItem, TreeGroup, GroupedItems } from './Tree';
 export declare const notEqual: (a: any, b: any) => boolean;
 export declare const notEmpty: (value?: any) => boolean;
 export declare const filterOutByItemId: (list: string[]) => (item: TreeItem | TreeGroup) => boolean;
@@ -6,7 +6,7 @@ export declare const containsItemById: (list: string[]) => (item: TreeGroup) =>
 export declare const getListIds: (list: TreeItem[] | TreeGroup[]) => string[];
 export declare const getTypeCounts: (items: TreeItem[]) => Record<string, number>;
 export declare const getSubTypeCounts: (items: TreeItem[]) => Record<string, number>;
-export declare const debounceFn: <T extends (...args: any[]) => any>(fn: T) => import("es-toolkit/compat").DebouncedFunc<T>;
+export declare const debounceFn: <T extends (...args: any[]) => any>(fn: T) => import('es-toolkit/compat').DebouncedFunc<T>;
 export declare const getFullName: (item: TreeItem) => string;
 export declare const getFlatItems: (items: TreeItem[], searchValue: string) => TreeItem[];
 export declare const filterEmptyGroups: (groups: GroupedItems) => GroupedItems;

package/components/assetTree/treeUtils.js

@@ -1,110 +1,74 @@
-import { countBy, debounce, filter, isEmpty, isObject, mapValues, negate } from 'es-toolkit/compat';
-import { isEqual } from 'es-toolkit/predicate';
-import { orderBy } from 'es-toolkit/array';
-import { searchNormalized } from "../../utils/searchNormalized.js";
-const SEARCH_DEBOUNCE = 100;
-export const notEqual = negate(isEqual);
-export const notEmpty = negate(isEmpty);
-export const filterOutByItemId = (list) => (item) => !list.includes(item.id);
-export const containsItemById = (list) => (item) => list.includes(item.id);
-export const getListIds = (list) => list.map(listItem => listItem.id);
-export const getTypeCounts = (items) => countBy(items, item => item.type);
-export const getSubTypeCounts = (items) => countBy(items, item => item.subType);
-// biome-ignore lint/suspicious/noExplicitAny: we don't know the type
-export const debounceFn = (fn) => debounce(fn, SEARCH_DEBOUNCE);
-const isNameObject = (item) => isObject(item.name);
-export const getFullName = (item) => `${item.name.firstName} ${item.name.lastName}`;
-const getName = (item) => (isNameObject(item) ? getFullName(item) : item.name);
-const orderTreeItemsByName = (items) => orderBy(items, [
-    (item) => isNameObject(item)
-        ? item.name.lastName.toLowerCase()
-        : (item.name?.toLowerCase() ?? ''),
-], ['asc']);
-const orderGroupedItemsByName = (groups) => {
-    const groupArray = Object.values(groups);
-    const sortedArray = orderBy(groupArray, [
-        (group) => (typeof group.name === 'string' ? group.name.toLowerCase() : String(group.name)) ?? '',
-    ], ['asc']);
-    const sortedGroups = {};
-    for (const group of sortedArray) {
-        sortedGroups[group.id] = group;
-    }
-    return sortedGroups;
-};
-// TODO: extend to use provided external search function instead?
-const filterByName = (searchValue) => (item) => {
-    if (searchValue) {
-        return searchNormalized(getName(item), searchValue);
-    }
-    return true;
-};
-export const getFlatItems = (items, searchValue) => filter(orderTreeItemsByName(items), filterByName(searchValue));
-export const filterEmptyGroups = (groups) => {
-    const result = {};
-    Object.values(groups).forEach(group => {
-        if (notEmpty(group.items)) {
-            result[group.id] = group;
-        }
-    });
-    return result;
-};
-export const filterAssetByType = (items, types = []) => filter(items, (asset) => types.includes(asset.type));
-export const excludeFromList = (list, itemId) => list.filter(item => item !== itemId);
-export const sortGroupsByName = (groups) => {
-    const fixedGroups = {};
-    const sortableGroups = {};
-    mapValues(groups, (group) => {
-        if (group.position === 'last') {
-            fixedGroups[group.id] = { ...group };
-        }
-        else {
-            sortableGroups[group.id] = { ...group };
-        }
-    });
-    const sortedGroups = orderGroupedItemsByName(sortableGroups);
-    return isEmpty(fixedGroups) ? sortedGroups : { ...sortedGroups, ...fixedGroups };
-};
-export const sortGroupItemsByName = (groups) => {
-    return mapValues(groups, (group) => ({
-        ...group,
-        items: orderTreeItemsByName(group.items),
-    }));
-};
-export const getMappedItemsToGroups = (groups, items) => {
-    const mappedGroups = {};
-    // build an object for listing the groups by id
-    groups.forEach(group => {
-        mappedGroups[group.id] = {
-            ...group,
-            items: [],
-        };
-    });
-    items.forEach(item => {
-        // add items to the respective group
-        const groupIds = item.groupIds || [];
-        groupIds.forEach(groupId => {
-            const mappedGroup = mappedGroups[groupId];
-            if (mappedGroup) {
-                mappedGroup.items.push(item);
-            }
-        });
+import { negate as c, isEmpty as a, countBy as i, debounce as y, filter as m, mapValues as d, isObject as I } from "es-toolkit/compat";
+import { isEqual as N } from "es-toolkit/predicate";
+import { orderBy as u } from "es-toolkit/array";
+import { searchNormalized as E } from "../../utils/searchNormalized.js";
+const h = 100, F = c(N), B = c(a), S = (t) => (e) => !t.includes(e.id), j = (t) => (e) => t.includes(e.id), x = (t) => t.map((e) => e.id), A = (t) => i(t, (e) => e.type), v = (t) => i(t, (e) => e.subType), R = (t) => y(t, h), p = (t) => I(t.name), G = (t) => `${t.name.firstName} ${t.name.lastName}`, b = (t) => p(t) ? G(t) : t.name, l = (t) => u(
+  t,
+  [
+    (e) => p(e) ? e.name.lastName.toLowerCase() : e.name?.toLowerCase() ?? ""
+  ],
+  ["asc"]
+), g = (t) => {
+  const e = Object.values(t), s = u(
+    e,
+    [
+      (o) => (typeof o.name == "string" ? o.name.toLowerCase() : String(o.name)) ?? ""
+    ],
+    ["asc"]
+  ), r = {};
+  for (const o of s)
+    r[o.id] = o;
+  return r;
+}, C = (t) => (e) => t ? E(b(e), t) : !0, $ = (t, e) => m(l(t), C(e)), q = (t) => {
+  const e = {};
+  return Object.values(t).forEach((s) => {
+    B(s.items) && (e[s.id] = s);
+  }), e;
+}, z = (t, e = []) => m(t, (s) => e.includes(s.type)), D = (t, e) => t.filter((s) => s !== e), H = (t) => {
+  const e = {}, s = {};
+  d(t, (o) => {
+    o.position === "last" ? e[o.id] = { ...o } : s[o.id] = { ...o };
+  });
+  const r = g(s);
+  return a(e) ? r : { ...r, ...e };
+}, M = (t) => d(t, (e) => ({
+  ...e,
+  items: l(e.items)
+})), P = (t, e) => {
+  const s = {};
+  return t.forEach((r) => {
+    s[r.id] = {
+      ...r,
+      items: []
+    };
+  }), e.forEach((r) => {
+    (r.groupIds || []).forEach((f) => {
+      const n = s[f];
+      n && n.items.push(r);
     });
-    return mappedGroups;
-};
-export const addOrRemoveFromList = (list, item) => {
-    const listSet = new Set(list);
-    if (listSet.has(item)) {
-        listSet.delete(item);
-    }
-    else {
-        listSet.add(item);
-    }
-    return [...listSet];
-};
-// Add prefix `rioglyph-` if icon is given and does not start with the prefix
-export const withRioglyphPrefix = (name) => {
-    if (!name) {
-        return null;
-    }
-    return name.startsWith('rioglyph-') ? name : `rioglyph-${name}`;
+  }), s;
+}, U = (t, e) => {
+  const s = new Set(t);
+  return s.has(e) ? s.delete(e) : s.add(e), [...s];
+}, W = (t) => t ? t.startsWith("rioglyph-") ? t : `rioglyph-${t}` : null;
+export {
+  U as addOrRemoveFromList,
+  j as containsItemById,
+  R as debounceFn,
+  D as excludeFromList,
+  z as filterAssetByType,
+  q as filterEmptyGroups,
+  S as filterOutByItemId,
+  $ as getFlatItems,
+  G as getFullName,
+  x as getListIds,
+  P as getMappedItemsToGroups,
+  v as getSubTypeCounts,
+  A as getTypeCounts,
+  B as notEmpty,
+  F as notEqual,
+  M as sortGroupItemsByName,
+  H as sortGroupsByName,
+  W as withRioglyphPrefix
 };
+//# sourceMappingURL=treeUtils.js.map

package/components/assetTree/treeUtils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"treeUtils.js","sources":["../../../src/components/assetTree/treeUtils.ts"],"sourcesContent":["import { countBy, debounce, filter, isEmpty, isObject, mapValues, negate } from 'es-toolkit/compat';\nimport { isEqual } from 'es-toolkit/predicate';\nimport { orderBy } from 'es-toolkit/array';\n\nimport { searchNormalized } from '../../utils/searchNormalized';\nimport type { TreeItem, TreeGroup, TreeItemName, GroupedItems, GroupedItem } from './Tree';\n\nconst SEARCH_DEBOUNCE = 100;\n\nexport const notEqual = negate(isEqual);\nexport const notEmpty = negate(isEmpty);\n\nexport const filterOutByItemId = (list: string[]) => (item: TreeItem | TreeGroup) => !list.includes(item.id);\n\nexport const containsItemById = (list: string[]) => (item: TreeGroup) => list.includes(item.id);\n\nexport const getListIds = (list: TreeItem[] | TreeGroup[]) => list.map(listItem => listItem.id);\n\nexport const getTypeCounts = (items: TreeItem[]) => countBy(items, item => item.type);\nexport const getSubTypeCounts = (items: TreeItem[]) => countBy(items, item => item.subType);\n\n// biome-ignore lint/suspicious/noExplicitAny: we don't know the type\nexport const debounceFn = <T extends (...args: any[]) => any>(fn: T) => debounce(fn, SEARCH_DEBOUNCE);\n\nconst isNameObject = (item: TreeItem) => isObject(item.name);\n\nexport const getFullName = (item: TreeItem) =>\n    `${(item.name as TreeItemName).firstName} ${(item.name as TreeItemName).lastName}`;\n\nconst getName = (item: TreeItem) => (isNameObject(item) ? getFullName(item) : (item.name as string));\n\nconst orderTreeItemsByName = (items: TreeItem[]) =>\n    orderBy(\n        items,\n        [\n            (item: TreeItem) =>\n                isNameObject(item)\n                    ? (item.name as TreeItemName).lastName.toLowerCase()\n                    : ((item.name as string)?.toLowerCase() ?? ''),\n        ],\n        ['asc']\n    ) as TreeItem[];\n\nconst orderGroupedItemsByName = (groups: GroupedItems) => {\n    const groupArray = Object.values(groups);\n    const sortedArray = orderBy(\n        groupArray,\n        [\n            (group: GroupedItem) =>\n                (typeof group.name === 'string' ? group.name.toLowerCase() : String(group.name)) ?? '',\n        ],\n        ['asc']\n    ) as GroupedItem[];\n    const sortedGroups: GroupedItems = {};\n    for (const group of sortedArray) {\n        sortedGroups[group.id] = group;\n    }\n    return sortedGroups;\n};\n\n// TODO: extend to use provided external search function instead?\nconst filterByName =\n    (searchValue: string) =>\n    (item: TreeItem): boolean => {\n        if (searchValue) {\n            return searchNormalized(getName(item), searchValue);\n        }\n        return true;\n    };\n\nexport const getFlatItems = (items: TreeItem[], searchValue: string): TreeItem[] =>\n    filter(orderTreeItemsByName(items), filterByName(searchValue));\n\nexport const filterEmptyGroups = (groups: GroupedItems): GroupedItems => {\n    const result: GroupedItems = {};\n    Object.values(groups).forEach(group => {\n        if (notEmpty(group.items)) {\n            result[group.id] = group;\n        }\n    });\n    return result;\n};\n\nexport const filterAssetByType = (items: TreeItem[], types: string[] = []) =>\n    filter(items, (asset: TreeItem) => types.includes(asset.type));\n\nexport const excludeFromList = <T>(list: T[], itemId: T): T[] => list.filter(item => item !== itemId);\n\nexport const sortGroupsByName = (groups: GroupedItems) => {\n    const fixedGroups: GroupedItems = {};\n    const sortableGroups: GroupedItems = {};\n\n    mapValues(groups, (group: GroupedItem) => {\n        if (group.position === 'last') {\n            fixedGroups[group.id] = { ...group };\n        } else {\n            sortableGroups[group.id] = { ...group };\n        }\n    });\n\n    const sortedGroups = orderGroupedItemsByName(sortableGroups);\n\n    return isEmpty(fixedGroups) ? sortedGroups : { ...sortedGroups, ...fixedGroups };\n};\n\nexport const sortGroupItemsByName = (groups: GroupedItems): GroupedItems => {\n    return mapValues(groups, (group: GroupedItem) => ({\n        ...group,\n        items: orderTreeItemsByName(group.items) as TreeItem[],\n    }));\n};\n\nexport const getMappedItemsToGroups = (groups: TreeGroup[], items: TreeItem[]): GroupedItems => {\n    const mappedGroups: GroupedItems = {};\n\n    // build an object for listing the groups by id\n    groups.forEach(group => {\n        mappedGroups[group.id] = {\n            ...group,\n            items: [],\n        };\n    });\n\n    items.forEach(item => {\n        // add items to the respective group\n        const groupIds = item.groupIds || [];\n        groupIds.forEach(groupId => {\n            const mappedGroup = mappedGroups[groupId];\n            if (mappedGroup) {\n                mappedGroup.items.push(item);\n            }\n        });\n    });\n\n    return mappedGroups;\n};\n\nexport const addOrRemoveFromList = <T>(list: T[], item: T): T[] => {\n    const listSet = new Set(list);\n    if (listSet.has(item)) {\n        listSet.delete(item);\n    } else {\n        listSet.add(item);\n    }\n    return [...listSet];\n};\n\n// Add prefix `rioglyph-` if icon is given and does not start with the prefix\nexport const withRioglyphPrefix = (name?: string | null): string | null => {\n    if (!name) {\n        return null;\n    }\n    return name.startsWith('rioglyph-') ? name : `rioglyph-${name}`;\n};\n"],"names":["SEARCH_DEBOUNCE","notEqual","negate","isEqual","notEmpty","isEmpty","filterOutByItemId","list","item","containsItemById","getListIds","listItem","getTypeCounts","items","countBy","getSubTypeCounts","debounceFn","fn","debounce","isNameObject","isObject","getFullName","getName","orderTreeItemsByName","orderBy","orderGroupedItemsByName","groups","groupArray","sortedArray","group","sortedGroups","filterByName","searchValue","searchNormalized","getFlatItems","filter","filterEmptyGroups","result","filterAssetByType","types","asset","excludeFromList","itemId","sortGroupsByName","fixedGroups","sortableGroups","mapValues","sortGroupItemsByName","getMappedItemsToGroups","mappedGroups","groupId","mappedGroup","addOrRemoveFromList","listSet","withRioglyphPrefix","name"],"mappings":"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"}

package/components/assetTree/useTreeExpansion.js

@@ -1,25 +1,18 @@
-import { useState } from 'react';
-import { isEqual } from 'es-toolkit/compat';
-export const useTreeExpansion = (expandedGroups, onExpandGroupsChange) => {
-    const [internalExpandedGroups, setInternalExpandedGroups] = useState(expandedGroups);
-    const [previousExpandedGroups, setPreviousExpandedGroups] = useState(expandedGroups);
-    // Sync with external prop changes and update expanded groups from outside in case
-    if (!isEqual(expandedGroups, previousExpandedGroups)) {
-        setInternalExpandedGroups(expandedGroups);
-        setPreviousExpandedGroups(expandedGroups);
+import { useState as s } from "react";
+import { isEqual as E } from "es-toolkit/compat";
+const d = (e, i) => {
+  const [t, o] = s(e), [l, a] = s(e);
+  return E(e, l) || (o(e), a(e)), {
+    internalExpandedGroups: t,
+    handleToggleNode: (n) => {
+      if (!t)
+        return;
+      const r = t.includes(n) ? t.filter((u) => u !== n) : [...t, n];
+      o(r), i?.(r);
     }
-    const handleToggleNode = (nodeId) => {
-        if (!internalExpandedGroups) {
-            return;
-        }
-        const newExpandedNodes = internalExpandedGroups.includes(nodeId)
-            ? internalExpandedGroups.filter(item => item !== nodeId)
-            : [...internalExpandedGroups, nodeId];
-        setInternalExpandedGroups(newExpandedNodes);
-        onExpandGroupsChange?.(newExpandedNodes);
-    };
-    return {
-        internalExpandedGroups,
-        handleToggleNode,
-    };
+  };
 };
+export {
+  d as useTreeExpansion
+};
+//# sourceMappingURL=useTreeExpansion.js.map

package/components/assetTree/useTreeExpansion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTreeExpansion.js","sources":["../../../src/components/assetTree/useTreeExpansion.ts"],"sourcesContent":["import { useState } from 'react';\nimport { isEqual } from 'es-toolkit/compat';\n\nexport const useTreeExpansion = (expandedGroups?: string[], onExpandGroupsChange?: (groups: string[]) => void) => {\n    const [internalExpandedGroups, setInternalExpandedGroups] = useState(expandedGroups);\n    const [previousExpandedGroups, setPreviousExpandedGroups] = useState(expandedGroups);\n\n    // Sync with external prop changes and update expanded groups from outside in case\n    if (!isEqual(expandedGroups, previousExpandedGroups)) {\n        setInternalExpandedGroups(expandedGroups);\n        setPreviousExpandedGroups(expandedGroups);\n    }\n\n    const handleToggleNode = (nodeId: string) => {\n        if (!internalExpandedGroups) {\n            return;\n        }\n\n        const newExpandedNodes = internalExpandedGroups.includes(nodeId)\n            ? internalExpandedGroups.filter(item => item !== nodeId)\n            : [...internalExpandedGroups, nodeId];\n\n        setInternalExpandedGroups(newExpandedNodes);\n        onExpandGroupsChange?.(newExpandedNodes);\n    };\n\n    return {\n        internalExpandedGroups,\n        handleToggleNode,\n    };\n};\n"],"names":["useTreeExpansion","expandedGroups","onExpandGroupsChange","internalExpandedGroups","setInternalExpandedGroups","useState","previousExpandedGroups","setPreviousExpandedGroups","isEqual","nodeId","newExpandedNodes","item"],"mappings":";;AAGO,MAAMA,IAAmB,CAACC,GAA2BC,MAAsD;AAC9G,QAAM,CAACC,GAAwBC,CAAyB,IAAIC,EAASJ,CAAc,GAC7E,CAACK,GAAwBC,CAAyB,IAAIF,EAASJ,CAAc;AAGnF,SAAKO,EAAQP,GAAgBK,CAAsB,MAC/CF,EAA0BH,CAAc,GACxCM,EAA0BN,CAAc,IAgBrC;AAAA,IACH,wBAAAE;AAAA,IACA,kBAfqB,CAACM,MAAmB;AACzC,UAAI,CAACN;AACD;AAGJ,YAAMO,IAAmBP,EAAuB,SAASM,CAAM,IACzDN,EAAuB,OAAO,CAAAQ,MAAQA,MAASF,CAAM,IACrD,CAAC,GAAGN,GAAwBM,CAAM;AAExC,MAAAL,EAA0BM,CAAgB,GAC1CR,IAAuBQ,CAAgB;AAAA,IAC3C;AAAA,EAII;AAER;"}

package/components/assetTree/useTreeHeight.js

@@ -1,60 +1,26 @@
-import { useEffect, useState } from 'react';
-const DEFAULT_TREE_ROOT_HEIGHT = 300;
-export const useTreeHeight = (treeRef, scrollHeight) => {
-    const [containerHeight, setContainerHeight] = useState(350);
-    // Enhanced height calculation with multiple fallback strategies
-    useEffect(() => {
-        const calculateHeight = () => {
-            if (!treeRef.current) {
-                return DEFAULT_TREE_ROOT_HEIGHT;
-            }
-            const parentElement = treeRef.current;
-            const treeHeaderElement = parentElement.querySelector('.TreeHeader');
-            if (scrollHeight) {
-                // Use scrollHeight prop if provided
-                return scrollHeight;
-            }
-            const treeRoot = treeRef.current.querySelector('.TreeRoot');
-            return treeRoot?.clientHeight ?? DEFAULT_TREE_ROOT_HEIGHT;
-        };
-        const updateHeight = () => {
-            const newHeight = calculateHeight();
-            setContainerHeight(newHeight);
-        };
-        // Debounce height updates to avoid excessive recalculations
-        let timeoutId;
-        const debouncedUpdate = () => {
-            clearTimeout(timeoutId);
-            timeoutId = setTimeout(updateHeight, 16); // ~60fps
-        };
-        // Initial calculation with small delay to ensure DOM is ready
-        const initialTimeout = setTimeout(updateHeight, 50);
-        // Set up observers
-        const resizeObserver = new ResizeObserver(debouncedUpdate);
-        const mutationObserver = new MutationObserver(debouncedUpdate);
-        if (treeRef.current) {
-            // Watch parent for size changes
-            resizeObserver.observe(treeRef.current);
-            if (treeRef.current.parentElement) {
-                resizeObserver.observe(treeRef.current.parentElement);
-            }
-            // Watch for DOM changes that might affect layout
-            mutationObserver.observe(treeRef.current, {
-                childList: true,
-                subtree: true,
-                attributes: true,
-                attributeFilter: ['style', 'class'],
-            });
-        }
-        // Window resize listener
-        window.addEventListener('resize', debouncedUpdate);
-        return () => {
-            clearTimeout(initialTimeout);
-            clearTimeout(timeoutId);
-            resizeObserver.disconnect();
-            mutationObserver.disconnect();
-            window.removeEventListener('resize', debouncedUpdate);
-        };
-    }, [scrollHeight, treeRef]); // Re-run if scrollHeight prop changes or treeRef changes
-    return containerHeight;
+import { useState as T, useEffect as b } from "react";
+const c = 300, p = (e, r) => {
+  const [a, m] = T(350);
+  return b(() => {
+    const l = () => e.current ? (e.current.querySelector(".TreeHeader"), r || (e.current.querySelector(".TreeRoot")?.clientHeight ?? c)) : c, i = () => {
+      const u = l();
+      m(u);
+    };
+    let n;
+    const t = () => {
+      clearTimeout(n), n = setTimeout(i, 16);
+    }, d = setTimeout(i, 50), o = new ResizeObserver(t), s = new MutationObserver(t);
+    return e.current && (o.observe(e.current), e.current.parentElement && o.observe(e.current.parentElement), s.observe(e.current, {
+      childList: !0,
+      subtree: !0,
+      attributes: !0,
+      attributeFilter: ["style", "class"]
+    })), window.addEventListener("resize", t), () => {
+      clearTimeout(d), clearTimeout(n), o.disconnect(), s.disconnect(), window.removeEventListener("resize", t);
+    };
+  }, [r, e]), a;
 };
+export {
+  p as useTreeHeight
+};
+//# sourceMappingURL=useTreeHeight.js.map

package/components/assetTree/useTreeHeight.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTreeHeight.js","sources":["../../../src/components/assetTree/useTreeHeight.ts"],"sourcesContent":["import { useEffect, useState } from 'react';\n\nconst DEFAULT_TREE_ROOT_HEIGHT = 300;\n\nexport const useTreeHeight = (treeRef: React.RefObject<HTMLDivElement>, scrollHeight?: number) => {\n    const [containerHeight, setContainerHeight] = useState<number>(350);\n\n    // Enhanced height calculation with multiple fallback strategies\n    useEffect(() => {\n        const calculateHeight = () => {\n            if (!treeRef.current) {\n                return DEFAULT_TREE_ROOT_HEIGHT;\n            }\n\n            const parentElement = treeRef.current;\n            const treeHeaderElement = parentElement.querySelector('.TreeHeader');\n\n            if (scrollHeight) {\n                // Use scrollHeight prop if provided\n                return scrollHeight;\n            }\n\n            const treeRoot = treeRef.current.querySelector('.TreeRoot');\n            return treeRoot?.clientHeight ?? DEFAULT_TREE_ROOT_HEIGHT;\n        };\n\n        const updateHeight = () => {\n            const newHeight = calculateHeight();\n            setContainerHeight(newHeight);\n        };\n\n        // Debounce height updates to avoid excessive recalculations\n        let timeoutId: NodeJS.Timeout;\n        const debouncedUpdate = () => {\n            clearTimeout(timeoutId);\n            timeoutId = setTimeout(updateHeight, 16); // ~60fps\n        };\n\n        // Initial calculation with small delay to ensure DOM is ready\n        const initialTimeout = setTimeout(updateHeight, 50);\n\n        // Set up observers\n        const resizeObserver = new ResizeObserver(debouncedUpdate);\n        const mutationObserver = new MutationObserver(debouncedUpdate);\n\n        if (treeRef.current) {\n            // Watch parent for size changes\n            resizeObserver.observe(treeRef.current);\n            if (treeRef.current.parentElement) {\n                resizeObserver.observe(treeRef.current.parentElement);\n            }\n\n            // Watch for DOM changes that might affect layout\n            mutationObserver.observe(treeRef.current, {\n                childList: true,\n                subtree: true,\n                attributes: true,\n                attributeFilter: ['style', 'class'],\n            });\n        }\n\n        // Window resize listener\n        window.addEventListener('resize', debouncedUpdate);\n\n        return () => {\n            clearTimeout(initialTimeout);\n            clearTimeout(timeoutId);\n            resizeObserver.disconnect();\n            mutationObserver.disconnect();\n            window.removeEventListener('resize', debouncedUpdate);\n        };\n    }, [scrollHeight, treeRef]); // Re-run if scrollHeight prop changes or treeRef changes\n\n    return containerHeight;\n};\n"],"names":["DEFAULT_TREE_ROOT_HEIGHT","useTreeHeight","treeRef","scrollHeight","containerHeight","setContainerHeight","useState","useEffect","calculateHeight","updateHeight","newHeight","timeoutId","debouncedUpdate","initialTimeout","resizeObserver","mutationObserver"],"mappings":";AAEA,MAAMA,IAA2B,KAEpBC,IAAgB,CAACC,GAA0CC,MAA0B;AAC9F,QAAM,CAACC,GAAiBC,CAAkB,IAAIC,EAAiB,GAAG;AAGlE,SAAAC,EAAU,MAAM;AACZ,UAAMC,IAAkB,MACfN,EAAQ,WAISA,EAAQ,QACU,cAAc,aAAa,GAE/DC,MAKaD,EAAQ,QAAQ,cAAc,WAAW,GACzC,gBAAgBF,MAZtBA,GAeTS,IAAe,MAAM;AACvB,YAAMC,IAAYF,EAAA;AAClB,MAAAH,EAAmBK,CAAS;AAAA,IAChC;AAGA,QAAIC;AACJ,UAAMC,IAAkB,MAAM;AAC1B,mBAAaD,CAAS,GACtBA,IAAY,WAAWF,GAAc,EAAE;AAAA,IAC3C,GAGMI,IAAiB,WAAWJ,GAAc,EAAE,GAG5CK,IAAiB,IAAI,eAAeF,CAAe,GACnDG,IAAmB,IAAI,iBAAiBH,CAAe;AAE7D,WAAIV,EAAQ,YAERY,EAAe,QAAQZ,EAAQ,OAAO,GAClCA,EAAQ,QAAQ,iBAChBY,EAAe,QAAQZ,EAAQ,QAAQ,aAAa,GAIxDa,EAAiB,QAAQb,EAAQ,SAAS;AAAA,MACtC,WAAW;AAAA,MACX,SAAS;AAAA,MACT,YAAY;AAAA,MACZ,iBAAiB,CAAC,SAAS,OAAO;AAAA,IAAA,CACrC,IAIL,OAAO,iBAAiB,UAAUU,CAAe,GAE1C,MAAM;AACT,mBAAaC,CAAc,GAC3B,aAAaF,CAAS,GACtBG,EAAe,WAAA,GACfC,EAAiB,WAAA,GACjB,OAAO,oBAAoB,UAAUH,CAAe;AAAA,IACxD;AAAA,EACJ,GAAG,CAACT,GAAcD,CAAO,CAAC,GAEnBE;AACX;"}

package/components/assetTree/useTreeScrollPosition.js

@@ -1,19 +1,13 @@
-import { useCallback, useRef } from 'react';
-export const useTreeScrollPosition = (virtualizer, scrollElementRef) => {
-    const scrollOffsetRef = useRef(0);
-    const scrollToTop = useCallback(() => {
-        if (scrollElementRef.current) {
-            requestAnimationFrame(() => {
-                // Reset scroll position to top
-                scrollElementRef.current.scrollTop(0);
-                // Also reset the stored scroll offset
-                scrollOffsetRef.current = 0;
-                // Force virtualizer to sync
-                if (virtualizer) {
-                    virtualizer.scrollToOffset(0);
-                }
-            });
-        }
-    }, [scrollElementRef, virtualizer]);
-    return { scrollToTop };
+import { useRef as c, useCallback as t } from "react";
+const f = (o, r) => {
+  const s = c(0);
+  return { scrollToTop: t(() => {
+    r.current && requestAnimationFrame(() => {
+      r.current.scrollTop(0), s.current = 0, o && o.scrollToOffset(0);
+    });
+  }, [r, o]) };
 };
+export {
+  f as useTreeScrollPosition
+};
+//# sourceMappingURL=useTreeScrollPosition.js.map

package/components/assetTree/useTreeScrollPosition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTreeScrollPosition.js","sources":["../../../src/components/assetTree/useTreeScrollPosition.ts"],"sourcesContent":["import { useCallback, useRef } from 'react';\n\nexport const useTreeScrollPosition = (virtualizer: any, scrollElementRef: React.RefObject<any>) => {\n    const scrollOffsetRef = useRef<number>(0);\n\n    const scrollToTop = useCallback(() => {\n        if (scrollElementRef.current) {\n            requestAnimationFrame(() => {\n                // Reset scroll position to top\n                scrollElementRef.current.scrollTop(0);\n\n                // Also reset the stored scroll offset\n                scrollOffsetRef.current = 0;\n\n                // Force virtualizer to sync\n                if (virtualizer) {\n                    virtualizer.scrollToOffset(0);\n                }\n            });\n        }\n    }, [scrollElementRef, virtualizer]);\n\n    return { scrollToTop };\n};\n"],"names":["useTreeScrollPosition","virtualizer","scrollElementRef","scrollOffsetRef","useRef","useCallback"],"mappings":";AAEO,MAAMA,IAAwB,CAACC,GAAkBC,MAA2C;AAC/F,QAAMC,IAAkBC,EAAe,CAAC;AAmBxC,SAAO,EAAE,aAjBWC,EAAY,MAAM;AAClC,IAAIH,EAAiB,WACjB,sBAAsB,MAAM;AAExB,MAAAA,EAAiB,QAAQ,UAAU,CAAC,GAGpCC,EAAgB,UAAU,GAGtBF,KACAA,EAAY,eAAe,CAAC;AAAA,IAEpC,CAAC;AAAA,EAET,GAAG,CAACC,GAAkBD,CAAW,CAAC,EAEzB;AACb;"}

package/components/assetTree/useTreeVirtualization.d.ts

@@ -1,4 +1,4 @@
-import type { TreeItem, GroupedItem, GroupedItems } from './Tree';
+import { TreeItem, GroupedItem, GroupedItems } from './Tree';
 type VirtualizedItem = {
     type: 'group';
     data: GroupedItem;
@@ -12,6 +12,6 @@ type VirtualizedItem = {
 };
 export declare const useTreeVirtualization: (groupedItems: GroupedItems, flatItems: TreeItem[], hasSearchValue: boolean, hasGroups: boolean, internalExpandedGroups: string[] | undefined, scrollElementRef: React.RefObject<HTMLDivElement>, overscan: number) => {
     virtualizedItems: VirtualizedItem[];
-    virtualizer: import("@tanstack/virtual-core").Virtualizer<any, Element>;
+    virtualizer: import('@tanstack/virtual-core').Virtualizer<any, Element>;
 };
 export {};