@odigos/ui-kit 0.0.6 → 0.0.8

package/lib/index-BJxaoI0G.js

@@ -0,0 +1,131 @@
+import React from 'react';
+import Theme from './theme.js';
+
+const ArrowIcon = ({ size = 16, fill: f, rotate = 0, onClick }) => {
+    const theme = Theme.useTheme();
+    const fill = f || theme.text.secondary;
+    return (React.createElement("svg", { width: size * (9 / 13.5), height: size, viewBox: '0 0 9 13.5', xmlns: 'http://www.w3.org/2000/svg', fill: fill, style: { transform: `rotate(${rotate}deg)` }, onClick: onClick },
+        React.createElement("path", { d: 'M0.616717 8.03169L0.616717 5.70699L16.1519 5.70699L16.1519 8.03169L0.616717 8.03169ZM8.11144 -2.81613L9.7262 -1.10502L1.45534 6.87054L9.7262 14.9097L8.17631 16.6208L-1.19268 7.5802L-1.19268 6.1921L8.11144 -2.81613Z' })));
+};
+
+const CodeIcon = ({ size = 16, fill: f, rotate = 0, onClick }) => {
+    const theme = Theme.useTheme();
+    const fill = f || theme.text.secondary;
+    return (React.createElement("svg", { width: size, height: size, viewBox: '0 0 16 16', xmlns: 'http://www.w3.org/2000/svg', fill: 'none', style: { transform: `rotate(${rotate}deg)` }, onClick: onClick },
+        React.createElement("path", { stroke: fill, strokeLinecap: 'round', strokeLinejoin: 'round', d: 'M11.334 12a18.802 18.802 0 0 0 3.231-3.66.62.62 0 0 0 0-.68A18.8 18.8 0 0 0 11.334 4m-6.665 8a18.803 18.803 0 0 1-3.231-3.66.62.62 0 0 1 0-.68A18.801 18.801 0 0 1 4.669 4m4.667-1.332L6.669 13.335' })));
+};
+
+const CopyIcon = ({ size = 16, fill: f, rotate = 0, onClick }) => {
+    const theme = Theme.useTheme();
+    const fill = f || theme.text.secondary;
+    return (React.createElement("svg", { width: size, height: size, viewBox: '0 0 16 16', xmlns: 'http://www.w3.org/2000/svg', fill: 'none', style: { transform: `rotate(${rotate}deg)` }, onClick: onClick },
+        React.createElement("path", { stroke: fill, strokeLinecap: 'round', strokeLinejoin: 'round', d: 'M11.2679 11.2679C11.425 11.2446 11.5649 11.213 11.6967 11.1702C12.7115 10.8405 13.5071 10.0449 13.8369 9.03006C14 8.52795 14 7.90752 14 6.66667C14 5.42581 14 4.80539 13.8369 4.30328C13.5071 3.28848 12.7115 2.49287 11.6967 2.16314C11.1946 2 10.5742 2 9.33333 2C8.09248 2 7.47205 2 6.96994 2.16314C5.95515 2.49287 5.15954 3.28848 4.82981 4.30328C4.787 4.43505 4.75542 4.57498 4.73212 4.73212M11.2679 11.2679C11.3333 10.8262 11.3333 10.2485 11.3333 9.33333C11.3333 8.09248 11.3333 7.47205 11.1702 6.96994C10.8405 5.95515 10.0449 5.15954 9.03006 4.82981C8.52795 4.66667 7.90752 4.66667 6.66667 4.66667C5.75147 4.66667 5.17377 4.66667 4.73212 4.73212M11.2679 11.2679C11.2446 11.425 11.213 11.5649 11.1702 11.6967C10.8405 12.7115 10.0449 13.5071 9.03006 13.8369C8.52795 14 7.90752 14 6.66667 14C5.42581 14 4.80539 14 4.30328 13.8369C3.28848 13.5071 2.49287 12.7115 2.16314 11.6967C2 11.1946 2 10.5742 2 9.33333C2 8.09248 2 7.47205 2.16314 6.96994C2.49287 5.95515 3.28848 5.15954 4.30328 4.82981C4.43505 4.787 4.57498 4.75542 4.73212 4.73212' })));
+};
+
+const ExtendArrowIcon = ({ size = 16, fill: f, rotate = 0, onClick }) => {
+    const theme = Theme.useTheme();
+    const fill = f || theme.text.secondary;
+    return (React.createElement("svg", { width: size, height: size, viewBox: '0 0 12 12', xmlns: 'http://www.w3.org/2000/svg', fill: 'none', style: { transform: `rotate(${rotate}deg)` }, onClick: onClick },
+        React.createElement("path", { stroke: fill, strokeLinecap: 'round', strokeLinejoin: 'round', d: 'M4 5.06934C4.53103 5.80028 5.15354 6.45498 5.85106 7.01644C5.93869 7.08697 6.06131 7.08697 6.14894 7.01644C6.84646 6.45498 7.46897 5.80028 8 5.06934' })));
+};
+
+const ListIcon = ({ size = 16, fill: f, rotate = 0, onClick }) => {
+    const theme = Theme.useTheme();
+    const fill = f || theme.text.secondary;
+    return (React.createElement("svg", { width: size, height: size, viewBox: '0 0 16 16', xmlns: 'http://www.w3.org/2000/svg', fill: 'none', style: { transform: `rotate(${rotate}deg)` }, onClick: onClick },
+        React.createElement("path", { stroke: fill, strokeLinecap: 'round', strokeLinejoin: 'round', d: 'M2.667 6.001h10.666M2.666 9.335h10.667M2.667 12.668H8m-5.333-10h10.666' })));
+};
+
+const NoDataIcon = ({ size = 16, fill: f, rotate = 0, onClick }) => {
+    const theme = Theme.useTheme();
+    const fill = f || theme.text.secondary;
+    return (React.createElement("svg", { width: size, height: size, viewBox: '0 0 16 16', xmlns: 'http://www.w3.org/2000/svg', fill: 'none', style: { transform: `rotate(${rotate}deg)` }, onClick: onClick },
+        React.createElement("path", { stroke: fill, strokeLinecap: 'round', strokeLinejoin: 'round', d: 'M6.31647 10.9497L7.96639 9.29983M7.96639 9.29983L9.61631 7.64992M7.96639 9.29983L6.31647 7.64992M7.96639 9.29983L9.61631 10.9497M14.6666 8.26667V9.73333C14.6666 11.2268 14.6666 11.9735 14.3759 12.544C14.1203 13.0457 13.7123 13.4537 13.2106 13.7094C12.6401 14 11.8934 14 10.3999 14H5.59992C4.10645 14 3.35971 14 2.78928 13.7094C2.28751 13.4537 1.87956 13.0457 1.6239 12.544C1.33325 11.9735 1.33325 11.2268 1.33325 9.73333V6.26667C1.33325 4.77319 1.33325 4.02646 1.6239 3.45603C1.87956 2.95426 2.28751 2.54631 2.78928 2.29065C3.35971 2 4.10645 2 5.59992 2H5.81029C6.12336 2 6.2799 2 6.42199 2.04315C6.54778 2.08135 6.6648 2.14398 6.76636 2.22745C6.88108 2.32174 6.96791 2.45199 7.14157 2.71248L7.52493 3.28752C7.69859 3.54801 7.78542 3.67826 7.90014 3.77255C8.0017 3.85602 8.11873 3.91865 8.24452 3.95685C8.38661 4 8.54314 4 8.85621 4H10.3999C11.8934 4 12.6401 4 13.2106 4.29065C13.7123 4.54631 14.1203 4.95426 14.3759 5.45603C14.6666 6.02646 14.6666 6.77319 14.6666 8.26667Z' })));
+};
+
+const NotebookIcon = ({ size = 16, fill: f, rotate = 0, onClick }) => {
+    const theme = Theme.useTheme();
+    const fill = f || theme.text.secondary;
+    return (React.createElement("svg", { width: size, height: size, viewBox: '0 0 16 16', xmlns: 'http://www.w3.org/2000/svg', fill: 'none', style: { transform: `rotate(${rotate}deg)` }, onClick: onClick },
+        React.createElement("path", { stroke: fill, strokeLinecap: 'round', strokeLinejoin: 'round', d: 'M8.00016 3.37696V14.3327M8.00016 3.37696C10.0168 2.64365 12.6703 2.23608 14.6668 3.37696V13.7103C12.5356 12.7969 9.9581 13.4427 8.00016 14.3327M8.00016 3.37696C5.98356 2.64365 3.33004 2.23608 1.3335 3.37696V13.7103C3.46472 12.7969 6.04222 13.4427 8.00016 14.3327' })));
+};
+
+const SearchIcon = ({ size = 16, fill: f, rotate = 0, onClick }) => {
+    const theme = Theme.useTheme();
+    const fill = f || theme.text.secondary;
+    return (React.createElement("svg", { width: size * (14 / 15), height: size, viewBox: '0 0 14 15', xmlns: 'http://www.w3.org/2000/svg', fill: 'none', style: { transform: `rotate(${rotate}deg)` }, onClick: onClick },
+        React.createElement("path", { stroke: fill, strokeLinecap: 'round', strokeLinejoin: 'round', d: 'M12.25 13.165L10.2144 11.1294M10.2144 11.1294C11.1117 10.2322 11.6667 8.99258 11.6667 7.62337C11.6667 4.88496 9.44674 2.66504 6.70833 2.66504C3.96992 2.66504 1.75 4.88496 1.75 7.62337C1.75 10.3618 3.96992 12.5817 6.70833 12.5817C8.07754 12.5817 9.31712 12.0267 10.2144 11.1294Z' })));
+};
+
+const SortArrowsIcon = ({ size = 16, fill: f, rotate = 0, onClick }) => {
+    const theme = Theme.useTheme();
+    const fill = f || theme.text.secondary;
+    return (React.createElement("svg", { width: size, height: size * (24 / 25), viewBox: '0 0 25 24', xmlns: 'http://www.w3.org/2000/svg', fill: 'none', style: { transform: `rotate(${rotate}deg)` }, onClick: onClick },
+        React.createElement("path", { stroke: fill, strokeLinecap: 'round', strokeLinejoin: 'round', d: 'M16.5 9C15.4379 7.53812 14.1929 6.22872 12.7979 5.1058C12.6226 4.96473 12.3774 4.96473 12.2021 5.1058C10.8071 6.22872 9.56206 7.53812 8.5 9M8.5 15C9.56206 16.4619 10.8071 17.7713 12.2021 18.8942C12.3774 19.0353 12.6226 19.0353 12.7979 18.8942C14.1929 17.7713 15.4379 16.4619 16.5 15' })));
+};
+
+const TrashIcon = ({ size = 16, fill: f, rotate = 0, onClick }) => {
+    const theme = Theme.useTheme();
+    const fill = f || theme.text.error;
+    return (React.createElement("svg", { width: size, height: size, viewBox: '0 0 16 16', xmlns: 'http://www.w3.org/2000/svg', fill: 'none', style: { transform: `rotate(${rotate}deg)` }, onClick: onClick },
+        React.createElement("path", { stroke: fill, strokeLinecap: 'round', strokeLinejoin: 'round', d: 'M10.6665 4.00065L9.92946 2.52655C9.56401 1.79567 8.81699 1.33398 7.99984 1.33398C7.18268 1.33398 6.43566 1.79567 6.07022 2.52655L5.33317 4.00065M2.6665 4.00065H13.3332M3.99984 4.00065H11.9998V10.0007C11.9998 11.2432 11.9998 11.8644 11.7968 12.3545C11.5262 13.0079 11.0071 13.527 10.3537 13.7977C9.8636 14.0007 9.24235 14.0007 7.99984 14.0007C6.75733 14.0007 6.13607 14.0007 5.64601 13.7977C4.99261 13.527 4.47348 13.0079 4.20283 12.3545C3.99984 11.8644 3.99984 11.2432 3.99984 10.0007V4.00065Z' })));
+};
+
+const XIcon = ({ size = 16, fill: f, rotate = 0, onClick }) => {
+    const theme = Theme.useTheme();
+    const fill = f || theme.text.secondary;
+    return (React.createElement("svg", { width: size, height: size * (14 / 18), viewBox: '0 0 18 14', xmlns: 'http://www.w3.org/2000/svg', fill: 'none', style: { transform: `rotate(${rotate}deg)` }, onClick: onClick },
+        React.createElement("path", { fill: fill, d: 'M9.487 5.832v2.433h1.495V5.832H9.487ZM17.847 17.185l2.028-1.791L9.487 7.047l10.388-8.414L17.928-3.158 6.162 6.304v1.453l11.685 9.428Z' }),
+        React.createElement("path", { fill: fill, d: 'M8.513 5.832v2.433H7.018V5.832h1.495ZM0.153 17.185l-2.028-1.791L8.513 7.047l-10.388-8.414L0.072-3.158l11.766 9.462v1.453L0.153 17.185Z' })));
+};
+
+const MinusIcon = ({ size = 16, fill: f, rotate = 0, onClick }) => {
+    const theme = Theme.useTheme();
+    const fill = f || theme.text.secondary;
+    return (React.createElement("svg", { width: size, height: size, viewBox: '0 0 24 24', xmlns: 'http://www.w3.org/2000/svg', fill: 'none', style: { transform: `rotate(${rotate}deg)` }, onClick: onClick },
+        React.createElement("path", { stroke: fill, strokeWidth: '2', strokeLinecap: 'round', strokeLinejoin: 'round', d: 'M5 12H19' })));
+};
+
+const PlusIcon = ({ size = 16, fill: f, rotate = 0, onClick }) => {
+    const theme = Theme.useTheme();
+    const fill = f || theme.text.secondary;
+    return (React.createElement("svg", { width: size, height: size, viewBox: '0 0 16 16', xmlns: 'http://www.w3.org/2000/svg', fill: 'none', style: { transform: `rotate(${rotate}deg)` }, onClick: onClick },
+        React.createElement("path", { stroke: fill, strokeLinecap: 'round', strokeLinejoin: 'round', d: 'M7.99992 12.6663V7.99967M7.99992 7.99967V3.33301M7.99992 7.99967L3.33325 7.99967M7.99992 7.99967L12.6666 7.99967' })));
+};
+
+const EyeClosedIcon = ({ size = 16, fill: f, rotate = 0, onClick }) => {
+    const theme = Theme.useTheme();
+    const fill = f || theme.text.secondary;
+    return (React.createElement("svg", { width: size, height: size, viewBox: '0 0 24 24', xmlns: 'http://www.w3.org/2000/svg', fill: 'none', style: { transform: `rotate(${rotate}deg)` }, onClick: onClick },
+        React.createElement("path", { stroke: fill, strokeLinecap: 'round', strokeLinejoin: 'round', d: 'M14.83 9.17999C14.2706 8.61995 13.5576 8.23846 12.7813 8.08386C12.0049 7.92926 11.2002 8.00851 10.4689 8.31152C9.73758 8.61453 9.11264 9.12769 8.67316 9.78607C8.23367 10.4444 7.99938 11.2184 8 12.01C7.99916 13.0663 8.41619 14.08 9.16004 14.83' }),
+        React.createElement("path", { stroke: fill, strokeLinecap: 'round', strokeLinejoin: 'round', d: 'M12 16.01C13.0609 16.01 14.0783 15.5886 14.8284 14.8384C15.5786 14.0883 16 13.0709 16 12.01' }),
+        React.createElement("path", { stroke: fill, strokeLinecap: 'round', strokeLinejoin: 'round', d: 'M17.61 6.39004L6.38 17.62C4.6208 15.9966 3.14099 14.0944 2 11.99C6.71 3.76002 12.44 1.89004 17.61 6.39004Z' }),
+        React.createElement("path", { stroke: fill, strokeLinecap: 'round', strokeLinejoin: 'round', d: 'M20.9994 3L17.6094 6.39' }),
+        React.createElement("path", { stroke: fill, strokeLinecap: 'round', strokeLinejoin: 'round', d: 'M6.38 17.62L3 21' }),
+        React.createElement("path", { stroke: fill, strokeLinecap: 'round', strokeLinejoin: 'round', d: 'M19.5695 8.42999C20.4801 9.55186 21.2931 10.7496 21.9995 12.01C17.9995 19.01 13.2695 21.4 8.76953 19.23' })));
+};
+
+const EyeOpenIcon = ({ size = 16, fill: f, rotate = 0, onClick }) => {
+    const theme = Theme.useTheme();
+    const fill = f || theme.text.secondary;
+    return (React.createElement("svg", { width: size, height: size, viewBox: '0 0 24 24', xmlns: 'http://www.w3.org/2000/svg', fill: 'none', style: { transform: `rotate(${rotate}deg)` }, onClick: onClick },
+        React.createElement("path", { stroke: fill, strokeLinecap: 'round', strokeLinejoin: 'round', d: 'M12 16.01C14.2091 16.01 16 14.2191 16 12.01C16 9.80087 14.2091 8.01001 12 8.01001C9.79086 8.01001 8 9.80087 8 12.01C8 14.2191 9.79086 16.01 12 16.01Z' }),
+        React.createElement("path", { stroke: fill, strokeLinecap: 'round', strokeLinejoin: 'round', d: 'M2 11.98C8.09 1.31996 15.91 1.32996 22 11.98' }),
+        React.createElement("path", { stroke: fill, strokeLinecap: 'round', strokeLinejoin: 'round', d: 'M22 12.01C15.91 22.67 8.09 22.66 2 12.01' })));
+};
+
+const CheckIcon = ({ size = 16, fill: f, rotate = 0, onClick }) => {
+    const theme = Theme.useTheme();
+    const fill = f || theme.text.secondary;
+    return (React.createElement("svg", { width: size * (16 / 17), height: size, viewBox: '0 0 16 17', xmlns: 'http://www.w3.org/2000/svg', fill: 'none', style: { transform: `rotate(${rotate}deg)` }, onClick: onClick },
+        React.createElement("path", { stroke: fill, strokeLinecap: 'round', strokeLinejoin: 'round', d: 'M3.6665 9.24833L6.67773 12.7315L6.94495 12.2642C8.37771 9.75889 10.3605 7.61153 12.7439 5.98403L13.3332 5.58167' })));
+};
+
+const CrossIcon = ({ size = 16, fill: f, rotate = 0, onClick }) => {
+    const theme = Theme.useTheme();
+    const fill = f || theme.text.secondary;
+    return (React.createElement("svg", { width: size, height: size, viewBox: '0 0 16 16', xmlns: 'http://www.w3.org/2000/svg', fill: 'none', style: { transform: `rotate(${rotate}deg)` }, onClick: onClick },
+        React.createElement("path", { stroke: fill, strokeLinecap: 'round', strokeLinejoin: 'round', d: 'M4 12L8 8M8 8L12 4M8 8L4 4M8 8L12 12' })));
+};
+
+export { ArrowIcon as A, CodeIcon as C, ExtendArrowIcon as E, ListIcon as L, MinusIcon as M, NoDataIcon as N, PlusIcon as P, SearchIcon as S, TrashIcon as T, XIcon as X, CopyIcon as a, NotebookIcon as b, SortArrowsIcon as c, EyeClosedIcon as d, EyeOpenIcon as e, CheckIcon as f, CrossIcon as g };

package/lib/index-BZS1ijMm.js

@@ -0,0 +1,30 @@
+// Sometimes we need to allow "zero" values, and a simple "!val" check would result in false positives.
+// This function is a strict check for empty values, permitting values like "0" and "false".
+const isEmpty = (val) => {
+    if (Array.isArray(val)) {
+        return !val?.length;
+    }
+    else if (typeof val === 'object') {
+        return !Object.keys(val || {}).length;
+    }
+    else {
+        return [undefined, null, ''].includes(val);
+    }
+};
+
+function safeJsonParse(val, fallback) {
+    if (!val)
+        return fallback;
+    if (typeof val === 'object')
+        return val;
+    try {
+        const parsed = JSON.parse(val);
+        return parsed;
+    }
+    catch (e) {
+        console.error('Error parsing JSON string:', e);
+        return fallback;
+    }
+}
+
+export { isEmpty as i, safeJsonParse as s };

package/lib/index-BjJpYtF1.js

@@ -0,0 +1,42 @@
+import React from 'react';
+import Theme from './theme.js';
+
+const VmLogo = ({ size = 16, fill: f, rotate = 0, onClick }) => {
+    const theme = Theme.useTheme();
+    const fill = f || theme.text.secondary;
+    return (React.createElement("svg", { width: size, height: size, viewBox: '0 0 14 14', xmlns: 'http://www.w3.org/2000/svg', fill: 'none', style: { transform: `rotate(${rotate}deg)` }, onClick: onClick },
+        React.createElement("path", { stroke: fill, strokeLinecap: 'round', strokeLinejoin: 'round', d: 'M7 7.00016V12.5418M7 7.00016L1.94814 4.30969M7 7.00016L12.0519 4.30969M7 12.5418C7.12674 12.5418 7.25347 12.5291 7.37812 12.5037C7.65987 12.4463 7.92489 12.2996 8.45492 12.0063L10.7951 10.7111C11.3251 10.4177 11.5901 10.2711 11.7829 10.0659C11.9534 9.8843 12.0822 9.6704 12.161 9.43804C12.25 9.17542 12.25 8.88207 12.25 8.29536V5.70497C12.25 5.11826 12.25 4.82491 12.161 4.56229C12.1315 4.47526 12.095 4.39081 12.0519 4.30969M7 12.5418C6.87326 12.5418 6.74653 12.5291 6.62188 12.5037C6.34013 12.4463 6.07511 12.2996 5.54508 12.0063L3.20492 10.7111C2.67489 10.4177 2.40987 10.2711 2.21713 10.0659C2.04659 9.8843 1.91777 9.6704 1.83901 9.43804C1.75 9.17542 1.75 8.88207 1.75 8.29536V5.70497C1.75 5.11826 1.75 4.82491 1.83901 4.56229C1.86851 4.47526 1.90503 4.39081 1.94814 4.30969M12.0519 4.30969C11.9799 4.17423 11.8895 4.04802 11.7829 3.93447C11.5901 3.72926 11.3251 3.58258 10.7951 3.28923L8.45492 1.99404C7.92489 1.70068 7.65987 1.554 7.37812 1.49659C7.12882 1.4458 6.87117 1.4458 6.62188 1.49659C6.34013 1.554 6.07511 1.70068 5.54508 1.99404L3.20492 3.28923C2.67489 3.58258 2.40987 3.72926 2.21713 3.93447C2.11047 4.04802 2.02013 4.17423 1.94814 4.30969' })));
+};
+
+const ActionsIcon = ({ size = 16, fill: f, rotate = 0, onClick }) => {
+    const theme = Theme.useTheme();
+    const fill = f || theme.text.secondary;
+    return (React.createElement("svg", { width: size, height: size, viewBox: '0 0 16 16', xmlns: 'http://www.w3.org/2000/svg', fill: 'none', style: { transform: `rotate(${rotate}deg)` }, onClick: onClick },
+        React.createElement("path", { stroke: fill, strokeLinecap: 'round', strokeLinejoin: 'round', d: 'M4.03577 5.58623L7.87311 2.57807C8.96507 1.72206 9.51105 1.29405 9.88484 1.33635C10.2084 1.37297 10.4931 1.58015 10.6428 1.88795C10.8158 2.24356 10.6404 2.94122 10.2895 4.33655L9.99556 5.50565C9.85509 6.06426 9.78486 6.34357 9.83323 6.58606C9.87578 6.79937 9.9806 6.99284 10.1327 7.13876C10.3056 7.30464 10.5677 7.37948 11.0919 7.52916L11.432 7.62628C12.4401 7.91412 12.9442 8.05804 13.1457 8.35103C13.3209 8.60578 13.3771 8.93198 13.2982 9.23643C13.2074 9.58657 12.7841 9.91181 11.9376 10.5623L8.16976 13.4575C7.08454 14.2914 6.54192 14.7083 6.16999 14.6636C5.84799 14.6248 5.56547 14.4171 5.41715 14.1101C5.24584 13.7555 5.41898 13.0669 5.76527 11.6898L6.02808 10.6446C6.16855 10.0859 6.23878 9.80664 6.19041 9.56415C6.14786 9.35085 6.04304 9.15737 5.89096 9.01146C5.71807 8.84557 5.45596 8.77073 4.93173 8.62105L4.55326 8.51299C3.55574 8.22817 3.05698 8.08576 2.8556 7.79472C2.68046 7.5416 2.62311 7.21724 2.6998 6.91357C2.78798 6.5644 3.20391 6.23834 4.03577 5.58623Z' })));
+};
+
+const DestinationsIcon = ({ size = 16, fill: f, rotate = 0, onClick }) => {
+    const theme = Theme.useTheme();
+    const fill = f || theme.text.secondary;
+    return (React.createElement("svg", { width: size, height: size, viewBox: '0 0 16 16', xmlns: 'http://www.w3.org/2000/svg', fill: 'none', style: { transform: `rotate(${rotate}deg)` }, onClick: onClick },
+        React.createElement("path", { stroke: fill, strokeLinecap: 'round', strokeLinejoin: 'round', d: 'M7.9999 14.0999C11.3688 14.0999 14.0999 11.3688 14.0999 7.9999C14.0999 4.63096 11.3688 1.8999 7.9999 1.8999C4.63096 1.8999 1.8999 4.63096 1.8999 7.9999C1.8999 11.3688 4.63096 14.0999 7.9999 14.0999Z' }),
+        React.createElement("path", { stroke: fill, strokeLinecap: 'round', strokeLinejoin: 'round', d: 'M7.99984 11.3332C9.84077 11.3332 11.3332 9.84077 11.3332 7.99984C11.3332 6.15889 9.84077 4.6665 7.99984 4.6665C6.15889 4.6665 4.6665 6.15889 4.6665 7.99984C4.6665 9.84077 6.15889 11.3332 7.99984 11.3332Z' }),
+        React.createElement("path", { stroke: fill, strokeLinecap: 'round', strokeLinejoin: 'round', d: 'M8.6665 7.99984C8.6665 8.36804 8.36804 8.6665 7.99984 8.6665C7.63164 8.6665 7.33317 8.36804 7.33317 7.99984C7.33317 7.63164 7.63164 7.33317 7.99984 7.33317C8.36804 7.33317 8.6665 7.63164 8.6665 7.99984Z' })));
+};
+
+const RulesIcon = ({ size = 16, fill: f, rotate = 0, onClick }) => {
+    const theme = Theme.useTheme();
+    const fill = f || theme.text.secondary;
+    return (React.createElement("svg", { width: size, height: size, viewBox: '0 0 16 16', xmlns: 'http://www.w3.org/2000/svg', fill: 'none', style: { transform: `rotate(${rotate}deg)` }, onClick: onClick },
+        React.createElement("path", { stroke: fill, strokeWidth: '1.2', strokeLinecap: 'round', strokeLinejoin: 'round', d: 'M4.5 1.94059V1.94836M1.94111 4.49806V4.50583M1 7.99611V8.00389M1.94111 11.4942V11.5019M4.5 14.0516V14.0594M8 14.9922V15M11.5 14.0516V14.0594M14.0589 11.4942V11.5019M15 7.99611V8.00389M14.0589 4.49806V4.50583M11.5 1.94059V1.94836M8 1V1.00777' }),
+        React.createElement("path", { stroke: fill, strokeLinecap: 'round', strokeLinejoin: 'round', d: 'M8 8H8.01125M8 3.5L9.326 4.79876L11.182 4.81802L11.2012 6.674L12.5 8L11.2012 9.326L11.182 11.182L9.326 11.2012L8 12.5L6.674 11.2012L4.81802 11.182L4.79876 9.326L3.5 8L4.79876 6.674L4.81802 4.81802L6.674 4.79876L8 3.5Z' })));
+};
+
+const SourcesIcon = ({ size = 16, fill: f, rotate = 0, onClick }) => {
+    const theme = Theme.useTheme();
+    const fill = f || theme.text.secondary;
+    return (React.createElement("svg", { width: size, height: size, viewBox: '0 0 16 16', xmlns: 'http://www.w3.org/2000/svg', fill: 'none', style: { transform: `rotate(${rotate}deg)` }, onClick: onClick },
+        React.createElement("path", { stroke: fill, strokeLinecap: 'round', strokeLinejoin: 'round', d: 'M13.3332 3.8V8M13.3332 3.8C13.3332 4.79411 10.9454 5.6 7.99984 5.6C5.05432 5.6 2.6665 4.79411 2.6665 3.8M13.3332 3.8C13.3332 2.80589 10.9454 2 7.99984 2C5.05432 2 2.6665 2.80589 2.6665 3.8M13.3332 8V12.0875C13.3332 13.1437 10.9454 14 7.99984 14C5.05432 14 2.6665 13.1437 2.6665 12.0875V8M13.3332 8C13.3332 8.99413 10.9454 9.8 7.99984 9.8C5.05432 9.8 2.6665 8.99413 2.6665 8M2.6665 8V3.8M10.6665 7.33333H10.6732M10.6665 11.3333H10.6732' })));
+};
+
+export { ActionsIcon as A, DestinationsIcon as D, RulesIcon as R, SourcesIcon as S, VmLogo as V };

package/lib/index-BulCzWQI.js

@@ -0,0 +1,204 @@
+import { PROGRAMMING_LANGUAGES, SIGNAL_TYPE, NOTIFICATION_TYPE } from './types.js';
+import 'react';
+import './index-DIcomki-.js';
+import 'styled-components';
+import { T as TracesIcon, M as MetricsIcon, L as LogsIcon, I as InfoIcon, W as WarningTriangleIcon, E as ErrorTriangleIcon, C as CheckCircledIcon } from './index-DLKEpJJm.js';
+import { O as OdigosLogo } from './index-BGlk5VhF.js';
+
+const capitalizeFirstLetter = (string) => {
+    return string.charAt(0).toUpperCase() + string.slice(1);
+};
+
+/**
+ * Recursively flattens a nested object into a single-level object where each key
+ * represents the path to its corresponding value in the original object. Keys for nested
+ * properties are concatenated using a dot (`.`) as a separator, while array elements
+ * include their index in square brackets (`[]`).
+ *
+ * @param {Record<string, any>} obj - The input object to be flattened.
+ * @param {string} [prefix=''] - The current prefix for the keys, used for recursion.
+ * @param {Record<string, any>} [result={}] - The accumulator object that stores the flattened result.
+ * @returns {Record<string, any>} A new object where all nested properties are flattened into
+ *                                a single level with their paths as keys.
+ *
+ * @example
+ * const input = {
+ *   name: {
+ *     name: 'Name',
+ *     value: 'load-generator',
+ *     status: null,
+ *     explain: '...',
+ *   },
+ * };
+ *
+ * const output = flattenObjectKeys(input);
+ * Output:
+ * {
+ *   'name.name': 'Name',
+ *   'name.value': 'load-generator',
+ *   'name.status': null,
+ *   'name.explain': '...',
+ * }
+ */
+const flattenObjectKeys = (obj, prefix = '', result = {}) => {
+    for (const key in obj) {
+        if (obj.hasOwnProperty(key)) {
+            const value = obj[key];
+            const newKey = prefix ? `${prefix}.${key}` : key;
+            if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+                // Recurse for nested objects
+                flattenObjectKeys(value, newKey, result);
+            }
+            else if (Array.isArray(value)) {
+                value.forEach((item, index) => {
+                    const arrayKey = `${newKey}[${index}]`;
+                    if (item !== null && typeof item === 'object') {
+                        // Recurse for objects in arrays
+                        flattenObjectKeys(item, arrayKey, result);
+                    }
+                    else {
+                        // Assign primitive array values
+                        result[arrayKey] = item;
+                    }
+                });
+            }
+            else {
+                // Assign non-object, non-array values
+                result[newKey] = value;
+            }
+        }
+    }
+    return result;
+};
+
+const getProgrammingLanguageIcon = (language) => {
+    // const BASE_URL = 'https://d1n7d4xz7fr8b4.cloudfront.net/'
+    const BASE_URL = 'https://odigos-sources.s3.us-east-1.amazonaws.com/';
+    const LOGOS = {
+        [PROGRAMMING_LANGUAGES.JAVA]: `${BASE_URL}java.svg`,
+        [PROGRAMMING_LANGUAGES.GO]: `${BASE_URL}go.svg`,
+        [PROGRAMMING_LANGUAGES.JAVASCRIPT]: `${BASE_URL}nodejs.svg`,
+        [PROGRAMMING_LANGUAGES.PYTHON]: `${BASE_URL}python.svg`,
+        [PROGRAMMING_LANGUAGES.DOTNET]: `${BASE_URL}dotnet.svg`,
+        [PROGRAMMING_LANGUAGES.CSHARP]: `${BASE_URL}csharp.svg`,
+        [PROGRAMMING_LANGUAGES.CPLUSPLUS]: `${BASE_URL}cplusplus.svg`,
+        [PROGRAMMING_LANGUAGES.PHP]: `${BASE_URL}php.svg`,
+        [PROGRAMMING_LANGUAGES.RUBY]: `${BASE_URL}ruby.svg`,
+        [PROGRAMMING_LANGUAGES.RUST]: `${BASE_URL}rust.svg`,
+        [PROGRAMMING_LANGUAGES.SWIFT]: `${BASE_URL}swift.svg`,
+        [PROGRAMMING_LANGUAGES.ELIXIR]: `${BASE_URL}elixir.svg`,
+        [PROGRAMMING_LANGUAGES.MYSQL]: `${BASE_URL}mysql.svg`,
+        [PROGRAMMING_LANGUAGES.NGINX]: `${BASE_URL}nginx.svg`,
+        [PROGRAMMING_LANGUAGES.POSTGRES]: `${BASE_URL}postgres.svg`,
+        [PROGRAMMING_LANGUAGES.REDIS]: `${BASE_URL}redis.svg`,
+        [PROGRAMMING_LANGUAGES.KAFKA]: `${BASE_URL}kafka.svg`,
+        [PROGRAMMING_LANGUAGES.IGNORED]: '', // TODO: good icon
+        [PROGRAMMING_LANGUAGES.UNKNOWN]: '', // TODO: good icon
+        [PROGRAMMING_LANGUAGES.PROCESSING]: '', // TODO: good icon
+        [PROGRAMMING_LANGUAGES.NO_CONTAINERS]: '', // TODO: good icon
+        [PROGRAMMING_LANGUAGES.NO_RUNNING_PODS]: '', // TODO: good icon
+    };
+    return LOGOS[language];
+};
+
+const getMonitorIcon = (type) => {
+    const LOGOS = {
+        [SIGNAL_TYPE.LOGS]: LogsIcon,
+        [SIGNAL_TYPE.METRICS]: MetricsIcon,
+        [SIGNAL_TYPE.TRACES]: TracesIcon,
+    };
+    return LOGOS[type];
+};
+
+const getStatusIcon = (type, theme) => {
+    const LOGOS = {
+        [NOTIFICATION_TYPE.SUCCESS]: (props) => CheckCircledIcon({ fill: theme.text[type], ...props }),
+        [NOTIFICATION_TYPE.ERROR]: (props) => ErrorTriangleIcon({ fill: theme.text[type], ...props }),
+        [NOTIFICATION_TYPE.WARNING]: (props) => WarningTriangleIcon({ fill: theme.text[type], ...props }),
+        [NOTIFICATION_TYPE.INFO]: (props) => InfoIcon({ fill: theme.text[type], ...props }),
+        [NOTIFICATION_TYPE.DEFAULT]: (props) => OdigosLogo({ fill: theme.text[type], ...props }),
+    };
+    return LOGOS[type];
+};
+
+// Example: splitCamelString('LoremIpsumDolorSitAmet')
+// > 'Lorem Ipsum Dolor Sit Amet'
+const splitCamelString = (str) => {
+    if (!str)
+        return '';
+    return str.replace(/([a-z0-9])([A-Z])/g, '$1 $2');
+};
+
+const mapConditions = (conditions) => {
+    return (conditions?.map(({ status, type, reason, message, lastTransitionTime }) => ({
+        status,
+        type: splitCamelString(type),
+        reason: !!reason ? splitCamelString(reason) : '',
+        message,
+        lastTransitionTime,
+    })) || []);
+};
+
+const parseJsonStringToPrettyString = (value) => {
+    let str = '';
+    try {
+        const parsed = JSON.parse(value);
+        // Handle arrays
+        if (Array.isArray(parsed)) {
+            str = parsed
+                .map((item) => {
+                if (typeof item === 'object' && item !== null)
+                    return `${item.key}: ${item.value}`;
+                else
+                    return item;
+            })
+                .join(', ');
+        }
+        // Handle objects (non-array JSON objects)
+        else if (typeof parsed === 'object' && parsed !== null) {
+            str = Object.entries(parsed)
+                .map(([key, val]) => `${key}: ${val}`)
+                .join(', ');
+        }
+        // Should never reach this if it's a string (it will throw)
+        else {
+            str = value;
+        }
+    }
+    catch (error) {
+        str = value;
+    }
+    return str;
+};
+
+const removeEmptyValuesFromObject = (obj) => {
+    if (typeof obj !== 'object')
+        return obj;
+    const result = Array.isArray(obj) ? [] : {};
+    Object.keys(obj).forEach((key) => {
+        const value = obj[key];
+        if (Array.isArray(value)) {
+            // Remove empty arrays or recursively clean non-empty ones
+            const filteredArray = value.filter((item) => item !== null && item !== undefined && item !== '');
+            if (filteredArray.length > 0)
+                result[key] = filteredArray.map((item) => removeEmptyValuesFromObject(item));
+        }
+        else if (typeof value === 'object' && value !== null) {
+            // Recursively clean nested objects
+            const nestedObject = removeEmptyValuesFromObject(value);
+            if (Object.keys(nestedObject).length > 0)
+                result[key] = nestedObject;
+        }
+        else if (![undefined, null, ''].includes(value)) {
+            // Keep valid values
+            result[key] = value;
+        }
+    });
+    return result;
+};
+
+const safeJsonStringify = (obj, indent = 2) => {
+    return JSON.stringify(obj || {}, null, indent);
+};
+
+export { getProgrammingLanguageIcon as a, getStatusIcon as b, capitalizeFirstLetter as c, splitCamelString as d, flattenObjectKeys as f, getMonitorIcon as g, mapConditions as m, parseJsonStringToPrettyString as p, removeEmptyValuesFromObject as r, safeJsonStringify as s };

package/lib/index-BumPE6cF.js

@@ -0,0 +1,37 @@
+import { ACTION_TYPE, INSTRUMENTATION_RULE_TYPE } from './types.js';
+import { S as SamplerIcon, P as PiiMaskingIcon, R as RenameAttributeIcon, D as DeleteAttributeIcon, A as AddClusterInfoIcon, K as K8sLogo, O as OdigosLogo, C as CodeAttributesIcon, a as PayloadCollectionIcon } from './index-BGlk5VhF.js';
+import 'react';
+import './index-DIcomki-.js';
+import 'styled-components';
+
+const getActionIcon = (type) => {
+    const typeLowerCased = type?.toLowerCase();
+    const isSamplerCategory = typeLowerCased?.includes('sampler');
+    const isAttributesCategory = typeLowerCased === 'attributes';
+    if (isSamplerCategory)
+        return SamplerIcon;
+    if (isAttributesCategory)
+        return PiiMaskingIcon;
+    const LOGOS = {
+        [ACTION_TYPE.K8S_ATTRIBUTES]: K8sLogo,
+        [ACTION_TYPE.ADD_CLUSTER_INFO]: AddClusterInfoIcon,
+        [ACTION_TYPE.DELETE_ATTRIBUTES]: DeleteAttributeIcon,
+        [ACTION_TYPE.PII_MASKING]: PiiMaskingIcon,
+        [ACTION_TYPE.RENAME_ATTRIBUTES]: RenameAttributeIcon,
+        [ACTION_TYPE.ERROR_SAMPLER]: SamplerIcon,
+        [ACTION_TYPE.PROBABILISTIC_SAMPLER]: SamplerIcon,
+        [ACTION_TYPE.LATENCY_SAMPLER]: SamplerIcon,
+    };
+    return LOGOS[type];
+};
+
+const getInstrumentationRuleIcon = (type) => {
+    const LOGOS = {
+        [INSTRUMENTATION_RULE_TYPE.PAYLOAD_COLLECTION]: PayloadCollectionIcon,
+        [INSTRUMENTATION_RULE_TYPE.CODE_ATTRIBUTES]: CodeAttributesIcon,
+        [INSTRUMENTATION_RULE_TYPE.UNKNOWN_TYPE]: OdigosLogo,
+    };
+    return LOGOS[type];
+};
+
+export { getInstrumentationRuleIcon as a, getActionIcon as g };

package/lib/index-CKD2OX24.js

@@ -0,0 +1,192 @@
+import { NOTIFICATION_TYPE, OTHER_STATUS, ENTITY_TYPES, PLATFORM_TYPE } from './types.js';
+import { a as getProgrammingLanguageIcon } from './index-BulCzWQI.js';
+import 'react';
+import './index-DIcomki-.js';
+import 'styled-components';
+import { R as RulesIcon, A as ActionsIcon, D as DestinationsIcon, S as SourcesIcon, V as VmLogo } from './index-BjJpYtF1.js';
+import { K as K8sLogo } from './index-BGlk5VhF.js';
+
+const compareCondition = (renderCondition, fields) => {
+    if (!renderCondition || !renderCondition.length)
+        return true;
+    if (renderCondition.length === 1)
+        return renderCondition[0] == 'true';
+    const [key, cond, val] = renderCondition;
+    const field = fields.find((field) => field.name === key);
+    if (!field) {
+        console.warn(`Field with name ${key} not found, condition will be skipped`);
+        return true;
+    }
+    switch (cond) {
+        case '===':
+        case '==':
+            return field.value === val;
+        case '!==':
+        case '!=':
+            return field.value !== val;
+        case '>':
+            return field.value > val;
+        case '<':
+            return field.value < val;
+        case '>=':
+            return field.value >= val;
+        case '<=':
+            return field.value <= val;
+        default:
+            console.warn(`Invalid condition ${cond}, condition will be skipped`);
+            return true;
+    }
+};
+
+const filterActions = (actions, filters) => {
+    let filtered = [...actions];
+    if (!!filters.monitors?.length)
+        filtered = filtered.filter((action) => !!filters.monitors?.find((metric) => action.spec.signals.find((str) => str.toLowerCase() === metric.id)));
+    return filtered;
+};
+
+const filterDestinations = (destinations, filters) => {
+    let filtered = [...destinations];
+    if (!!filters.monitors?.length)
+        filtered = filtered.filter((dest) => !!filters.monitors?.find((metr) => dest.exportedSignals[metr.id]));
+    return filtered;
+};
+
+const filterSources = (sources, filters) => {
+    let filtered = [...sources];
+    if (!!filters.namespaces?.length)
+        filtered = filtered.filter((source) => !!filters.namespaces?.find((ns) => ns.id === source.namespace));
+    if (!!filters.kinds?.length)
+        filtered = filtered.filter((source) => !!filters.kinds?.find((type) => type.id === source.kind));
+    if (!!filters.languages?.length)
+        filtered = filtered.filter((source) => !!filters.languages?.find((language) => !!source.containers?.find((cont) => cont.language === language.id)));
+    if (!!filters.onlyErrors)
+        filtered = filtered.filter((source) => !!source.conditions?.find((cond) => cond.status === NOTIFICATION_TYPE.ERROR));
+    if (!!filters.errors?.length)
+        filtered = filtered.filter((source) => !!filters.errors?.find((error) => !!source.conditions?.find((cond) => cond.message === error.id)));
+    return filtered;
+};
+
+const formatBytes = (bytes) => {
+    if (!bytes)
+        return '0 KB/s';
+    const sizes = ['Bytes/s', 'KB/s', 'MB/s', 'GB/s', 'TB/s'];
+    const i = Math.floor(Math.log(bytes) / Math.log(1024));
+    const value = bytes / Math.pow(1024, i);
+    return `${value.toFixed(i === 0 ? 0 : 1)} ${sizes[i]}`;
+};
+
+const getConditionsBooleans = (conditions) => {
+    const hasErrors = !!conditions?.find(({ status }) => status === NOTIFICATION_TYPE.ERROR);
+    const hasWarnings = !!conditions?.find(({ status }) => status === NOTIFICATION_TYPE.WARNING);
+    const hasDisableds = !!conditions?.find(({ status }) => status === OTHER_STATUS.DISABLED);
+    const hasLoadings = !!conditions?.find(({ status }) => status === OTHER_STATUS.LOADING);
+    const priorotizedStatus = hasErrors ? NOTIFICATION_TYPE.ERROR : hasWarnings ? NOTIFICATION_TYPE.WARNING : hasDisableds ? NOTIFICATION_TYPE.INFO : undefined;
+    return {
+        hasErrors,
+        hasWarnings,
+        hasDisableds,
+        hasLoadings,
+        priorotizedStatus,
+    };
+};
+
+const getContainersInstrumentedCount = (containers) => {
+    const instrumentedCount = containers?.reduce((prev, curr) => (curr.instrumented ? prev + 1 : prev), 0);
+    const totalCount = containers?.length || 0;
+    return `${instrumentedCount}/${totalCount} instrumented`;
+};
+
+const getContainersIcons = (containers) => {
+    const icons = containers?.map(({ language }) => getProgrammingLanguageIcon(language)) || [];
+    return icons;
+};
+
+const getEntityIcon = (type) => {
+    const LOGOS = {
+        [ENTITY_TYPES.SOURCE]: SourcesIcon,
+        [ENTITY_TYPES.DESTINATION]: DestinationsIcon,
+        [ENTITY_TYPES.ACTION]: ActionsIcon,
+        [ENTITY_TYPES.INSTRUMENTATION_RULE]: RulesIcon,
+    };
+    return LOGOS[type];
+};
+
+const getEntityLabel = (entity, entityType, options) => {
+    const { extended, prioritizeDisplayName } = options || {};
+    let type = '';
+    let name = '';
+    switch (entityType) {
+        case ENTITY_TYPES.INSTRUMENTATION_RULE:
+            const rule = entity;
+            type = rule.type;
+            name = rule.ruleName;
+            break;
+        case ENTITY_TYPES.SOURCE:
+            const source = entity;
+            type = source.name;
+            name = source.otelServiceName;
+            break;
+        case ENTITY_TYPES.ACTION:
+            const action = entity;
+            type = action.type;
+            name = action.spec.actionName;
+            break;
+        case ENTITY_TYPES.DESTINATION:
+            const destination = entity;
+            type = destination.destinationType.displayName;
+            name = destination.name;
+            break;
+    }
+    if (extended)
+        return type + (name && name !== type ? ` (${name})` : '');
+    else if (prioritizeDisplayName)
+        return name || type;
+    else
+        return type;
+};
+
+const getMetricForEntity = (metrics, entityType, entityId) => {
+    const metric = entityType === ENTITY_TYPES.SOURCE
+        ? metrics?.sources.find((m) => m.kind === entityId.kind && m.name === entityId.name && m.namespace === entityId.namespace)
+        : metrics?.destinations.find((m) => m.id === entityId);
+    return metric || { throughput: 0 };
+};
+
+const getPlatformIcon = (type) => {
+    const LOGOS = {
+        [PLATFORM_TYPE.K8S]: K8sLogo,
+        [PLATFORM_TYPE.VM]: VmLogo,
+    };
+    return LOGOS[type];
+};
+
+const getPlatformLabel = (type) => {
+    const LABELS = {
+        [PLATFORM_TYPE.K8S]: 'Kubernetes Cluster',
+        [PLATFORM_TYPE.VM]: 'Virtual Machine',
+    };
+    return LABELS[type];
+};
+
+const getValueForRange = (current, matrix) => {
+    // CURRENT: represents the current value (such as window width)
+    // MATRIX: represents the ranges (index[0] == min, index[1] == max, index[2] == value to get)
+    // EXAMPLE:
+    // getValueForRange(width, [
+    //   [0, 1000, 'small'], // ---> from 0 to 1000, return "small"
+    //   [1000, null, 'big'], // ---> from 1000 to infinite, return "big"
+    // ])
+    const found = matrix.find(([min, max]) => current >= min && (max === null || current <= max));
+    return found?.[2] || null;
+};
+
+const isOverTime = (originDate, difference = 0) => {
+    const now = new Date().getTime();
+    const compareWith = new Date(originDate).getTime();
+    return compareWith - now <= difference;
+};
+
+const sleep = async (ms = 1000) => new Promise((resolve) => setTimeout(resolve, ms));
+
+export { filterDestinations as a, filterSources as b, compareCondition as c, formatBytes as d, getContainersInstrumentedCount as e, filterActions as f, getConditionsBooleans as g, getContainersIcons as h, getEntityIcon as i, getEntityLabel as j, getMetricForEntity as k, getPlatformIcon as l, getPlatformLabel as m, getValueForRange as n, isOverTime as o, sleep as s };