npm - @rio-cloud/rio-uikit - Versions diffs - 1.11.0 → 1.13.0 - Mend

@rio-cloud/rio-uikit 1.11.0 → 1.13.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2722) hide show

package/src/utils/init/initDocumentBootstrapping.js ADDED Viewed

@@ -0,0 +1,38 @@
+import { getColorScheme, listenForSchemeChange } from '../colorScheme';
+import { isTest, isInIframe } from './initConfig';
+import { usedUikitVersion } from './usedUikitVersion';
+import { weAreHiring } from './weAreHiring';
+import { doNotUseTailwind } from './doNotUseTailwind';
+import { checkCSSVersion, initCSS } from './initCSS';
+import { checkForReleaseVersion } from './checkForReleaseVersion';
+import { getConsoleStyle } from './styledLogs';
+import { initPiiObserver } from './initPiiObserver';
+export const initDocumentBootstrapping = async () => {
+    if (!document || !document.documentElement) {
+        return;
+    }
+    // Initialize the CSS setup
+    initCSS();
+    if (!isTest) {
+        // Initialize PII observer
+        initPiiObserver();
+        // Handle the current color scheme (e.g., light/dark mode)
+        getColorScheme();
+        listenForSchemeChange();
+        // Verify the UIKIT version of the application
+        await checkForReleaseVersion();
+        // Ensure the correct CSS version is being used
+        checkCSSVersion();
+        if (!isInIframe) {
+            const logStyled = (message) => console.log('%c%s', getConsoleStyle(), message);
+            logStyled('- - - - - - - - - - - - - - - - - -');
+            // Log or validate the UI Kit version
+            usedUikitVersion();
+            // Show a hiring message
+            weAreHiring();
+            logStyled('- - - - - - - - - - - - - - - - - -');
+        }
+    }
+    // Enforce the rule that Tailwind CSS should not be used
+    await doNotUseTailwind();
+};

package/src/utils/init/initPiiObserver.d.ts ADDED Viewed

@@ -0,0 +1,6 @@
+/**
+ * Observes the <html> element for the data attribute "data-hide-pii" set to "true" and, when active,
+ * watches the DOM for elements marked with [data-pii="visible"]. Any such element
+ * will be passed to hidePiiData() immediately on appearance or attribute change.
+ */
+export declare const initPiiObserver: () => void;

package/src/utils/init/initPiiObserver.js ADDED Viewed

@@ -0,0 +1,196 @@
+import { hidePiiData } from '../hidePiiData';
+const MODE_SHUFFLE = 'shuffle';
+const MODE_MASK = 'mask';
+const MODE_RESET = 'reset';
+const ATTR_DATA_PII = 'data-pii';
+const ATTR_ORIGINAL_PII = 'data-original-pii';
+const ATTR_HIDE_PII = 'data-hide-pii';
+const ATTR_OBFUSCATED_PII = 'data-obfuscated-pii';
+const SELECTOR_PII_VISIBLE = '[data-pii="visible"]';
+const SELECTOR_PII_HIDDEN = '[data-pii="hidden"]';
+const SELECTOR_PII_OBFUSCATED = '[data-obfuscated-pii]';
+const SELECTOR_PII_ORIGINAL = '[data-original-pii]';
+/**
+ * Observes the <html> element for the data attribute "data-hide-pii" set to "true" and, when active,
+ * watches the DOM for elements marked with [data-pii="visible"]. Any such element
+ * will be passed to hidePiiData() immediately on appearance or attribute change.
+ */
+export const initPiiObserver = () => {
+    const html = document.documentElement;
+    let piiItemsObserver = null;
+    let observingPiiItems = false;
+    const obfuscateAllPiiElements = () => {
+        const elements = html.querySelectorAll(SELECTOR_PII_VISIBLE);
+        for (const element of elements) {
+            hidePiiData(element);
+        }
+    };
+    const resetObfuscatedPiiElements = () => {
+        const elements = html.querySelectorAll(SELECTOR_PII_HIDDEN + SELECTOR_PII_ORIGINAL);
+        for (const element of elements) {
+            const originalPiiData = element.getAttribute(ATTR_ORIGINAL_PII);
+            hidePiiData(element, String(originalPiiData));
+            element.removeAttribute(ATTR_ORIGINAL_PII);
+            element.removeAttribute(ATTR_OBFUSCATED_PII);
+            element.setAttribute(ATTR_DATA_PII, 'visible');
+        }
+    };
+    const startPiiItemsObserver = () => {
+        if (piiItemsObserver) {
+            return; // already created
+        }
+        piiItemsObserver = new MutationObserver(mutations => {
+            // Only act when obfuscation is active (shuffle or mask)
+            const mode = html.getAttribute(ATTR_HIDE_PII);
+            if (mode !== MODE_SHUFFLE && mode !== MODE_MASK) {
+                return;
+            }
+            for (const mutation of mutations) {
+                if (mutation.type === 'childList') {
+                    for (const addedNode of mutation.addedNodes) {
+                        if (addedNode.nodeType === Node.ELEMENT_NODE) {
+                            const element = addedNode;
+                            if (element.matches(SELECTOR_PII_VISIBLE)) {
+                                hidePiiData(element);
+                            }
+                            const descendants = element.querySelectorAll(SELECTOR_PII_VISIBLE);
+                            for (const descendant of descendants) {
+                                hidePiiData(descendant);
+                            }
+                        }
+                    }
+                }
+                else if (mutation.type === 'attributes' && mutation.attributeName === ATTR_DATA_PII) {
+                    const target = mutation.target;
+                    if (target.getAttribute(ATTR_DATA_PII) === 'visible') {
+                        hidePiiData(target);
+                    }
+                }
+            }
+        });
+        piiItemsObserver.observe(document.body, {
+            subtree: true,
+            childList: true,
+            attributes: true,
+            attributeFilter: [ATTR_DATA_PII],
+        });
+    };
+    const stopPiiItemsObserver = () => {
+        if (piiItemsObserver) {
+            piiItemsObserver.disconnect();
+            piiItemsObserver = null;
+        }
+    };
+    // Freeze data-original-pii if element has both data-obfuscated-pii and data-original-pii
+    const freezedPiiItemsObserver = new MutationObserver(mutations => {
+        const ensureHiddenConsistent = (element) => {
+            const hidden = element.getAttribute(ATTR_DATA_PII) === 'hidden';
+            const obfuscated = element.getAttribute(ATTR_OBFUSCATED_PII);
+            const original = element.getAttribute(ATTR_ORIGINAL_PII);
+            if (!obfuscated || !original || !hidden) {
+                return;
+            }
+            const shown = element instanceof HTMLInputElement ? (element.value ?? '') : (element.textContent ?? '');
+            // Re-obfuscate if it slipped back to original, OR if it deviates from the stored obfuscated value
+            if (shown === original || shown !== obfuscated) {
+                // Use forceResult so we always set exactly what we intend
+                hidePiiData(element, obfuscated);
+            }
+        };
+        for (const mutation of mutations) {
+            if (mutation.type === 'childList') {
+                for (const node of mutation.addedNodes) {
+                    if (node instanceof Element) {
+                        // console.log('data-original-pii:', node.getAttribute(ATTR_ORIGINAL_PII));
+                        ensureHiddenConsistent(node);
+                        const descendants = node.querySelectorAll(SELECTOR_PII_OBFUSCATED + SELECTOR_PII_ORIGINAL);
+                        for (const descendant of descendants) {
+                            console.log('data-original-pii:', descendant.getAttribute(ATTR_ORIGINAL_PII));
+                            ensureHiddenConsistent(descendant);
+                        }
+                    }
+                }
+            }
+            if (mutation.type === 'attributes') {
+                const target = mutation.target;
+                //console.log('data-original-pii:', target.getAttribute(ATTR_ORIGINAL_PII));
+                ensureHiddenConsistent(target);
+            }
+            if (mutation.type === 'characterData') {
+                const parent = mutation.target.parentElement;
+                if (parent?.matches(SELECTOR_PII_HIDDEN + SELECTOR_PII_OBFUSCATED + SELECTOR_PII_ORIGINAL)) {
+                    ensureHiddenConsistent(parent);
+                }
+            }
+        }
+        freezeObfuscatedPiiElements();
+    });
+    freezedPiiItemsObserver.observe(document.body, {
+        subtree: true,
+        childList: true,
+        attributes: true,
+        characterData: true,
+        attributeFilter: [ATTR_OBFUSCATED_PII, ATTR_ORIGINAL_PII, ATTR_DATA_PII, 'value'],
+    });
+    const freezeObfuscatedPiiElements = () => {
+        const allObfuscatedPiiElements = document.body.querySelectorAll(SELECTOR_PII_OBFUSCATED + SELECTOR_PII_ORIGINAL);
+        for (const element of allObfuscatedPiiElements) {
+            const originalPiiData = element.getAttribute(ATTR_ORIGINAL_PII);
+            const obfuscatedPiiData = element.getAttribute(ATTR_OBFUSCATED_PII);
+            if (getDisplayedValue(element) === originalPiiData) {
+                hidePiiData(element, String(obfuscatedPiiData));
+            }
+        }
+    };
+    const handleHtmlAttrChange = () => {
+        const mode = html.getAttribute(ATTR_HIDE_PII);
+        const active = mode === MODE_SHUFFLE;
+        const reset = mode === MODE_RESET;
+        if (!active && observingPiiItems) {
+            // Stop observing first if we're no longer active
+            stopPiiItemsObserver();
+            observingPiiItems = false;
+        }
+        if (reset) {
+            // Restore originals
+            resetObfuscatedPiiElements();
+        }
+        if (active && !observingPiiItems) {
+            // Start observing when we become active (shuffle or mask)
+            startPiiItemsObserver();
+            observingPiiItems = true;
+            obfuscateAllPiiElements();
+            freezeObfuscatedPiiElements();
+        }
+    };
+    // Observe <html> for data-hide-pii attribute changes to toggle the items observer
+    const htmlDataAttrObserver = new MutationObserver(handleHtmlAttrChange);
+    htmlDataAttrObserver.observe(html, { attributes: true, attributeFilter: [ATTR_HIDE_PII] });
+    // Initial state
+    handleHtmlAttrChange();
+    const getDisplayedValue = (element) => {
+        if (element instanceof HTMLInputElement) {
+            return element.value;
+        }
+        return element.textContent ?? '';
+    };
+    // Keyboard toggle to activate the observer: Ctrl+Shift+U (or Cmd+Shift+U on macOS)
+    const onKeyDown = (event) => {
+        if ((event.ctrlKey || event.metaKey) && event.shiftKey && event.key.toLowerCase() === 'u') {
+            const current = html.getAttribute(ATTR_HIDE_PII);
+            if (current === MODE_SHUFFLE) {
+                // second hit: move to mask
+                html.setAttribute(ATTR_HIDE_PII, MODE_MASK);
+            }
+            else if (current === MODE_MASK) {
+                // third hit: reset to default
+                html.setAttribute(ATTR_HIDE_PII, MODE_RESET);
+            }
+            else {
+                // first hit: set to shuffle
+                html.setAttribute(ATTR_HIDE_PII, MODE_SHUFFLE);
+            }
+        }
+    };
+    document.addEventListener('keydown', onKeyDown);
+};

package/src/version.json ADDED Viewed

@@ -0,0 +1,3 @@
+{
+    "version": "1.13.0"
+}

package/version.json CHANGED Viewed

@@ -1,3 +1,3 @@
 {
-    "version": "1.11.0"
+    "version": "1.13.0"
 }

package/components/assetTree/Tree.d.ts DELETED Viewed

@@ -1,244 +0,0 @@
-import React from 'react';
-export { getTypeCounts, getSubTypeCounts } from './treeUtils';
-export type TreeItemName = {
-    firstName?: string;
-    lastName: string;
-};
-export type TreeGroup = {
-    /**
-     * A unique identifier of a group.
-     */
-    id: string;
-    /**
-     * The name of a group.
-     */
-    name: string | React.ReactNode;
-    /**
-     * Can be set to "last" to enforce the last position in the tree.
-     */
-    position?: 'last';
-    /**
-     * Disallows the selection of the group itself.
-     */
-    disabled?: boolean;
-    /**
-     * The rioglyph icon name for a group.
-     *
-     * The prefix `rioglyph-` can be omitted.
-     */
-    icon?: string;
-    /**
-     * The rioglyph icon name for a expanded group.
-     *
-     * The prefix `rioglyph-` can be omitted.
-     */
-    expandedIcon?: string;
-    /**
-     * Additional classes added to the group element.
-     */
-    className?: string;
-};
-export type TreeItem = {
-    /**
-     * A unique identifier of an item.
-     */
-    id: string;
-    /**
-     * The name of an item. Either it is a plain string or an object composed of:
-     * `firstName` and `lastName` where __lastName__ is mandatory.
-     */
-    name: string | TreeItemName;
-    /**
-     * The subline of an item. This can e used to show additional information for that item.
-     */
-    info?: string | React.ReactNode;
-    /**
-     * The primary type of the item.
-     *
-     * This is also used as the fallback icon name and refers to the name of the respective
-     * rioglyph icon (excluding the `rioglyph-` prefix).
-     */
-    type: string;
-    /**
-     * Optional icon override for the item.
-     *
-     * - If set to a string (e.g. `'truck'`), this icon will be used explicitly.
-     * - If set to `undefined`, the `type` property will be used as the fallback icon.
-     * - If set to `null`, no icon will be rendered, even if `type` is defined.
-     *
-     * This allows full control over the icon behavior while maintaining backward compatibility with type-based icons.
-     */
-    icon?: string | null;
-    /**
-     * Optional sub-type of the item.
-     *
-     * This refers to the name of an additional rioglyph icon (excluding the `rioglyph-` prefix),
-     * typically used to render a secondary icon next to the primary one (e.g. for fuel type or
-     * equipment variations).
-     */
-    subType?: string;
-    /**
-     * List of group ids the items is associated with.
-     *
-     * @default []
-     */
-    groupIds?: string[];
-    /**
-     * Additional classes added to the item element.
-     */
-    className?: string;
-};
-export type GroupedItem = TreeGroup & {
-    items: TreeItem[];
-};
-export type GroupedItems = {
-    [key: string]: GroupedItem;
-};
-export type SelectionChangeResponse = {
-    items: string[];
-    groups: string[];
-};
-export type TreeProps = {
-    /**
-     * The list of groups of the items. If no groups are provided all items
-     * are rendered as flat list.
-     *
-     * @default []
-     */
-    groups?: TreeGroup[];
-    /**
-     * The list of items.
-     *
-     * @default []
-     */
-    items?: TreeItem[];
-    /**
-     * List of selected group ids.
-     *
-     * @default []
-     */
-    selectedGroups?: string[];
-    /**
-     * List of selected item ids.
-     *
-     * @default []
-     */
-    selectedItems?: string[];
-    /**
-     * Merged Callback for item and group selection changes.
-     * It responds with a selection object that contains the selected itemIds and groupIds:
-     * `{ items: [], groups: [] }`
-     * @returns
-     */
-    onSelectionChange?: ({ items, groups }: SelectionChangeResponse) => void;
-    /**
-     * Defines the selection behavior of the tree.
-     *
-     * @default true
-     */
-    hasMultiselect?: boolean;
-    /**
-     * Defines if the single selection should also show radios.
-     *
-     * @default false
-     */
-    showRadioButtons?: boolean;
-    /**
-     * Defines whether or not the built-in Search is shown.
-     *
-     * @default false
-     */
-    hideSearch?: boolean;
-    /**
-     * The text used as placeholder for the search input.
-     */
-    searchPlaceholder?: string;
-    /**
-     * Callback for when the search value changes.
-     * @param value
-     * @returns
-     */
-    onSearchChange?: (value: string) => void;
-    /**
-     * Used to define custom search component which replaces the built-in search.
-     */
-    search?: React.ReactNode;
-    /**
-     * Used to define custom asset type counter component which replaces the built-in summary.
-     */
-    summary?: React.ReactNode;
-    /**
-     * Defines whether a summary is shown.
-     *
-     * @default false
-     */
-    hideSummary?: boolean;
-    /**
-     * Callback triggered when the built-in asset type filter changes.
-     * This is only available when the default summary is used.
-     *
-     * @param type
-     * @returns
-     */
-    onTypeFilterChange?: (currentTypes: string[]) => void;
-    /**
-     * Defines whether the entire area below the search field is shown or not. Note: Disabling the
-     * tree head will hide the select all checkbox and the tree options as well as the tree summary.
-     *
-     * @default false
-     */
-    hideTreeHead?: boolean;
-    treeHeaderContent?: React.ReactElement;
-    /**
-     * Defines the max-height of the scrollable list.
-     */
-    scrollHeight?: number;
-    /**
-     * List of group ids which are expanded.
-     */
-    expandedGroups?: string[];
-    /**
-     * Callback function triggered when a group expands or collapses.
-     * @param newExpandedGroups
-     * @returns
-     */
-    onExpandGroupsChange?: (newExpandedGroups: string[]) => void;
-    /**
-     * Defines whether empty groups are shown or not.
-     *
-     * @default true
-     */
-    showEmptyGroups?: boolean;
-    /**
-     * Component to offer customization options for the tree.
-     */
-    treeOptions?: React.ReactNode[];
-    /**
-     * Tooltip content for the tree options dropdown.
-     */
-    treeOptionsTooltip?: React.ReactNode;
-    /**
-     * Disables animation when filtering or using search
-     *
-     * @default false
-     */
-    disableAnimation?: boolean;
-    /**
-     * The number of items (including groups and children) used for virtualizing the tree.
-     *
-     * @default 50
-     */
-    virtualizeThreshold?: number;
-    /**
-     * The number of items rendered beyond the visible area of a virtualized tree.
-     *
-     * @default 5
-     */
-    overscan?: number;
-    /**
-     * Additional classes added to the wrapping element.
-     */
-    className?: string;
-};
-declare const Tree: React.MemoExoticComponent<(props: TreeProps) => import("react/jsx-runtime").JSX.Element>;
-export default Tree;

package/components/assetTree/TreeLeaf.js DELETED Viewed

@@ -1,25 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-// biome-ignore lint/style/useImportType: required for JSX runtime compatibility with older toolchains
-import React from 'react';
-import classNames from 'classnames';
-import isObject from 'lodash/fp/isObject';
-import Checkbox from '../checkbox/Checkbox';
-import RadioButton from '../radiobutton/RadioButton';
-const getIconRenderInfo = (item) => {
-    if (item.icon === null) {
-        // explicit opt-out
-        return { primaryIcon: null, subIcon: null };
-    }
-    // fallback to type
-    const primaryIcon = item.icon ?? item.type;
-    // treat subType as pair icon name
-    const subIcon = item.subType ?? null;
-    return { primaryIcon, subIcon };
-};
-const TreeLeaf = React.memo((props) => {
-    const { item, hasMultiselect, showRadioButtons, isSelected, onSelectItem, onActiveItem } = props;
-    const treeNodeClassNames = classNames('TreeLeaf', 'form-group margin-bottom-0', isSelected && 'active', item.className && item.className);
-    const { primaryIcon, subIcon } = getIconRenderInfo(item);
-    return (_jsxs("div", { className: treeNodeClassNames, "data-key": item.id, children: [hasMultiselect && _jsx(Checkbox, { className: 'TreeCheckbox', checked: isSelected, onClick: onSelectItem }), !hasMultiselect && showRadioButtons && (_jsx(RadioButton, { className: 'TreeRadioButton', checked: isSelected, onChange: onSelectItem })), _jsxs("span", { className: 'TreeLabel TreeLabelName', onClick: onActiveItem, children: [primaryIcon && !subIcon && _jsx("span", { className: `rioglyph rioglyph-${primaryIcon}` }), primaryIcon && subIcon && (_jsxs("span", { className: 'rioglyph-icon-pair', children: [_jsx("span", { className: `rioglyph rioglyph-${primaryIcon}` }), _jsx("span", { className: `rioglyph rioglyph-${subIcon}` })] })), _jsxs("span", { className: 'TreeLabelNameText', children: [_jsx("span", { className: 'TreeLabelNameTextHeadline', children: isObject(item.name) ? (_jsxs(_Fragment, { children: [_jsx("span", { className: 'text-light margin-right-3', children: item.name.firstName }), _jsx("span", { children: item.name.lastName })] })) : (item.name) }), item.info && _jsx("span", { className: 'TreeLabelNameTextSubline', children: item.info })] })] })] }));
-});
-export default TreeLeaf;

package/components/assetTree/TreeNode.js DELETED Viewed

@@ -1,20 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import React from 'react';
-import classNames from 'classnames';
-import Checkbox from '../checkbox/Checkbox';
-// Add prefix `rioglyph-` if icon is given and does not start with the prefix
-const withRioglyphPrefix = (name) => {
-    if (!name) {
-        return null;
-    }
-    return name.startsWith('rioglyph-') ? name : `rioglyph-${name}`;
-};
-const TreeNode = React.memo((props) => {
-    const { node, hasMultiselect = false, isSelected = false, isOpen = false, isIndeterminate = false, onToggleNode, onSelect, } = props;
-    const treeNodeClassNames = classNames('TreeNode', 'from-group', isSelected && 'checked', node.className && node.className);
-    const hasChildren = !!node.items.length;
-    const expandedIcon = node.expandedIcon || node.icon;
-    const iconName = isOpen ? withRioglyphPrefix(expandedIcon) : withRioglyphPrefix(node.icon);
-    return (_jsxs("div", { className: treeNodeClassNames, "data-key": node.id, onClick: () => hasChildren && onToggleNode(node.id), children: [hasMultiselect && (_jsx(Checkbox, { className: 'TreeCheckbox', checked: isSelected, disabled: node.disabled, indeterminate: isIndeterminate, onClick: () => onSelect(node, isIndeterminate) })), _jsxs("span", { className: 'TreeLabel TreeLabelName', children: [iconName && _jsx("span", { className: `rioglyph ${iconName}` }), _jsx("span", { className: 'TreeLabelNameText', children: _jsx("span", { className: 'TreeLabelNameTextHeadline', children: node.name }) }), _jsx("span", { className: 'TreeLabelCount label label-muted label-filled label-condensed', children: node.items.length }), _jsx("span", { className: `TreeLabelExpander rioglyph rioglyph-chevron-down ${hasChildren ? '' : 'text-color-light'}` })] })] }));
-});
-export default TreeNode;

package/components/assetTree/TreeSearch.js DELETED Viewed

@@ -1,12 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-// biome-ignore lint/style/useImportType: required for JSX runtime compatibility with older toolchains
-import React from 'react';
-import classNames from 'classnames';
-import noop from 'lodash/fp/noop';
-import ClearableInput from '../clearableInput/ClearableInput';
-const TreeSearch = React.memo((props) => {
-    const { value, className, placeholder, onChange = noop } = props;
-    const classes = classNames('TreeSearch', className);
-    return (_jsx("div", { className: classes, children: _jsxs("div", { className: 'input-group flex-1-0', children: [_jsx("span", { className: 'input-group-addon', children: _jsx("span", { className: 'rioglyph rioglyph-search', "aria-hidden": 'true' }) }), _jsx(ClearableInput, { value: value, onChange: onChange, placeholder: placeholder })] }) }));
-});
-export default TreeSearch;

package/components/assetTree/TypeCounter.js DELETED Viewed

@@ -1,21 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-// biome-ignore lint/style/useImportType: required for JSX runtime compatibility with older toolchains
-import { forwardRef, useRef } from 'react';
-import classNames from 'classnames';
-import noop from 'lodash/fp/noop';
-import useHover from '../../hooks/useHover';
-import mergeRefs from '../../utils/mergeRefs';
-const TypeCounter = forwardRef((props, ref) => {
-    const { icon, value, isActive, hasFilter = false, enableActivity = false, onClick = noop, type, hideOnZero = false, ...remainingProps } = props;
-    const internalRef = useRef(null);
-    const mergedRef = mergeRefs([ref, internalRef]);
-    const isHover = useHover(internalRef);
-    const wrapperClassName = classNames('TypeCounter', 'display-flex align-items-center', 'user-select-none', 'margin-right-2', enableActivity ? 'cursor-pointer' : 'pointer-events-none', enableActivity && hasFilter && !isActive && !isHover && 'opacity-50');
-    const counterClassNames = classNames('TreeLabelCount', 'label label-condensed', isHover && !isActive && 'bg-white text-color-darker', isHover && !isActive && 'border-color-gray', isHover && isActive && 'border-color-primary', isActive ? 'label-primary' : 'label-muted label-filled');
-    const handleClick = () => type && onClick(type);
-    if (hideOnZero && !value) {
-        return null;
-    }
-    return (_jsxs("div", { ref: mergedRef, ...remainingProps, className: wrapperClassName, onClick: handleClick, children: [_jsx("span", { className: `rioglyph rioglyph-${icon} text-size-16 margin-right-2` }), _jsx("span", { className: counterClassNames, children: value || 0 })] }));
-});
-export default TypeCounter;

package/components/assetTree/treeUtils.d.ts DELETED Viewed

@@ -1,18 +0,0 @@
-import type { TreeItem, TreeGroup, GroupedItems } from './Tree';
-export declare const notEqual: (value: any, other: any) => boolean;
-export declare const notEmpty: (value?: any) => boolean;
-export declare const filterOutByItemId: (list: string[]) => (item: TreeItem | TreeGroup) => boolean;
-export declare const containsItemById: (list: string[]) => (item: TreeGroup) => boolean;
-export declare const getListIds: (list: TreeItem[] | TreeGroup[]) => string[];
-export declare const getTypeCounts: (items: TreeItem[]) => import("lodash").Dictionary<number>;
-export declare const getSubTypeCounts: (items: TreeItem[]) => import("lodash").Dictionary<number>;
-export declare const debounceFn: <T extends (...args: any[]) => any>(fn: T) => import("lodash").DebouncedFunc<T>;
-export declare const getFullName: (item: TreeItem) => string;
-export declare const getFlatItems: (items: TreeItem[], searchValue: string) => TreeItem[];
-export declare const filterEmptyGroups: import("lodash/fp").LodashFilter2x1<GroupedItems>;
-export declare const filterAssetByType: (types?: string[]) => import("lodash/fp").LodashFilter2x1<TreeItem>;
-export declare const excludeFromList: <T>(list: T[], itemId: T) => T[];
-export declare const sortGroupsByName: (groups: GroupedItems) => TreeItem[];
-export declare const sortGroupItemsByName: (groups: GroupedItems) => GroupedItems;
-export declare const getMappedItemsToGroups: (groups: TreeGroup[], items: TreeItem[]) => GroupedItems;
-export declare const addOrRemoveFromList: <T>(list: T[], item: T) => T[];