@tenorlab/react-dashboard 1.3.2 → 1.3.5

package/dist/core.d.ts

@@ -0,0 +1,277 @@
+export declare const blankDashboardConfig: IDashboardConfig;
+
+/**
+ * @name createDynamicEntry
+ * Helper function to create dynamic entries
+ * This helps keep the catalog registration clean
+ */
+export declare const createDynamicEntry: (key: string, loader: TWidgetFactoryBase, metaData: TWidgetMetaInfoBase) => [string, IDynamicWidgetCatalogEntryBase];
+
+/**
+ * @name createStaticEntry
+ * Helper function to create static entries
+ * This helps keep the catalog registration clean
+ */
+export declare const createStaticEntry: <TFrameworkComponentType = any>(key: string, component: TFrameworkComponentType, metaData?: TWidgetMetaInfoBase) => [string, IDynamicWidgetCatalogEntryBase];
+
+export declare const cssSettingsCatalog: IDashboardSettingEntry[];
+
+/**
+ * @name cssVarsUtils
+ * @description Provides helpers method like getCssVariableValue, setCssVariableValue etc
+ */
+export declare const cssVarsUtils: {
+    /**
+     * @name getCssVariableValue
+     * @description Return the value of a CSS custom property from the current HTML document
+     * @param cssPropertyName
+     * @returns
+     */
+    getCssVariableValue: (cssPropertyName: string) => string | null;
+    /**
+     * @name setCssVariableValue
+     * @description Sets the value of a CSS custom property on the current HTML document
+     * @param cssPropertyName
+     * @param value
+     */
+    setCssVariableValue: (cssPropertyName: string, value: string) => void;
+    /**
+     * @name restoreCssVarsFromSettings
+     * @description
+     * Sets the values of many CSS custom properties on the current HTML document
+     * from the list of dashboard settings provided
+     * @param settings, an array of IDashboardSettingEntry
+     */
+    restoreCssVarsFromSettings: (settings: IDashboardSettingEntry[]) => void;
+};
+
+export declare const DashboardMaxZoomScale: 1;
+
+export declare const DashboardMinZoomScale: 0.7;
+
+export declare const dashboardSettingsUtils: {
+    incrementOrDecrementValue: (item: IDashboardSettingEntry, direction: -1 | 1) => IDashboardSettingEntry;
+};
+
+export declare const DashboardZoomStep: 0.05;
+
+/**
+ * @name ensureContainersSequence
+ * @description
+ * Ensures that the container widgets are numbered sequentially in the dashboardConfig, but the original order is preserved.
+ */
+export declare const ensureContainersSequence: (dashboardConfig: IDashboardConfig) => IDashboardConfig;
+
+export declare const ensureZoomScaleIsWithinRange: (value: number) => number;
+
+export declare const getDefaultWidgetMetaFromKey: TGetDefaultWidgetMetaFromKey;
+
+/**
+ * @name getDefaultWidgetMetaFromMap
+ * @description Helper to get widget meta info from the catalog by key.
+ */
+export declare const getDefaultWidgetMetaFromMap: <TFrameworkElementType = any>(widgetKey: TDashboardWidgetKey, defaultWidgetMetaMap: Record<TDashboardWidgetKey, TWidgetMetaInfoBase<TFrameworkElementType>>, options?: {
+    title?: string;
+    description?: string;
+}) => TWidgetMetaInfoBase<TFrameworkElementType>;
+
+/**
+ * @name getDistinctCssClasses
+ * @description Ensures a distinct list off css classes, avoiding duplicates
+ * @param defaultClasses
+ * @param additionalClasses
+ * @returns the distinct list as a string
+ */
+export declare const getDistinctCssClasses: (defaultClasses: string, ...additionalClasses: string[]) => string;
+
+export declare const getMetaInfoFromFile: (widgetMetaModules: Record<string, Record<string, TWidgetMetaInfoBase>>, baseSrcPath: string, folder: string, key: string) => TWidgetMetaInfoBase | undefined;
+
+export declare const getNewZoomScaleWithinRange: (currentZoomScale: number, direction: -1 | 1) => number;
+
+/**
+ * @name getWidgetMetaFromCatalog
+ * @description Helper to get widget meta info from the catalog by key.
+ */
+export declare const getWidgetMetaFromCatalog: <TFrameworkElementType = any, TFrameworkComponentType = any>(widgetKey: TDashboardWidgetKey, widgetsCatalog: TDashboardWidgetCatalogBase<TFrameworkElementType, TFrameworkComponentType>) => TWidgetMetaInfoBase<TFrameworkElementType>;
+
+export declare interface IChildWidgetConfigEntry {
+    parentWidgetKey: TDashboardWidgetKey;
+    widgetKey: TDashboardWidgetKey;
+}
+
+export declare interface IDashboardConfig {
+    userID: number | string;
+    clientAppKey: string;
+    dashboardId: string;
+    dashboardName: string;
+    zoomScale: number;
+    responsiveGrid: boolean;
+    widgets: TDashboardWidgetKey[];
+    childWidgetsConfig: IChildWidgetConfigEntry[];
+    cssSettings: IDashboardSettingEntry[];
+    _version?: number;
+    _stateDescription?: string;
+}
+
+export declare interface IDashboardGridPropsBase {
+    isEditing: boolean;
+    zoomScale: number;
+    responsiveGrid: boolean;
+}
+
+export declare interface IDashboardSettingEntry {
+    key: string;
+    name: string;
+    description: string;
+    cssProperty: string;
+    step: number;
+    defaultUnit: string;
+    minValue: number;
+    defaultValue: string;
+    value: string;
+}
+
+export declare interface IDashboardStorageService {
+    getSavedDashboards: TGetSavedDashboards;
+    saveDashboards: TSaveDashboards;
+}
+
+export declare interface IDashboardWidgetPropsBase<TExtraProps = any> {
+    index: number;
+    maxIndex: number;
+    widgetKey: TDashboardWidgetKey;
+    parentWidgetKey?: TDashboardWidgetKey;
+    isEditing: boolean;
+    highlight?: boolean;
+    testId?: string;
+    title?: string;
+    size?: TWidgetSize;
+    borderCssClasses?: string;
+    backgroundCssClasses?: string;
+    hideTitle?: boolean;
+    noShadow?: boolean;
+    noBorder?: boolean;
+    noPadding?: boolean;
+    direction?: TWidgetDirection;
+    extraProps?: TExtraProps;
+}
+
+/**
+ * 2. Define the flexible Catalog Entry
+ * Definition of a single widget or container in the catalog.
+ * It must have EITHER a direct 'component' reference OR a 'loader' function.
+ *
+ * TFrameworkElementType: see TWidgetMetaInfoBase
+ * TFrameworkComponentType: i.e. React.ComponentType<any> (see TWidgetFactoryBase)
+ */
+export declare interface IDynamicWidgetCatalogEntryBase<TFrameworkElementType = any, TFrameworkComponentType = any> {
+    key: TDashboardWidgetKey;
+    title: string;
+    isContainer?: boolean;
+    meta?: TWidgetMetaInfoBase<TFrameworkElementType>;
+    component?: TFrameworkComponentType;
+    loader?: TWidgetFactoryBase<TFrameworkComponentType>;
+}
+
+/**
+ * @name localWidgetDiscovery
+ * @description Scans local directories for widgets.
+ * If lazy is true, it registers loaders. If false, it registers static components.
+ */
+export declare const localWidgetDiscovery: (baseSrcPath: string, // e.g., "/src/async-widgets" or "/src/bundled-widgets"
+widgetModules: Record<string, any>, widgetMetaModules: Record<string, any>, lazy?: boolean) => [string, IDynamicWidgetCatalogEntryBase][];
+
+export declare const parseContainerTitle: (containerWidgetKey: TDashboardWidgetKey) => string;
+
+/**
+ * Enhanced helper to derive key and title from widget file paths.
+ * Handles:
+ * - widget-revenue-trends1 -> WidgetRevenueTrends1
+ * - widget-with-extraprops -> WidgetWithExtraprops
+ * - widget-revenue-trends-async -> WidgetRevenueTrendsAsync
+ */
+export declare const parseKeyAndTitleFromFilePath: (path: string) => {
+    key: TDashboardWidgetKey;
+    title: string;
+    folder: string;
+} | null;
+
+export declare const remoteWidgetDiscovery: (manifestUrl: string) => Promise<{
+    entries: [string, IDynamicWidgetCatalogEntryBase][];
+    message: string;
+    details: string;
+}>;
+
+export declare const removeEmptyContainers: (dashboardConfig: IDashboardConfig) => IDashboardConfig;
+
+/**
+ * @name resolveColorFromClass
+ * @description Resolves the current computed color using your existing CSS classes
+ * @param classNames, i.e. 'bg-primary'
+ * @param property to resolve, i.e. 'backgroundColor'
+ * @returns
+ */
+export declare const resolveColorFromClass: (classNames: string | string[], property?: "color" | "backgroundColor") => string;
+
+export declare type TDashboardUndoStatus = {
+    isUndoDisabled: boolean;
+    isRedoDisabled: boolean;
+    _currentIndex?: number;
+    _historyLength?: number;
+};
+
+export declare type TDashboardWidgetCatalogBase<TFrameworkElementType = any, TFrameworkComponentType = any> = Map<TDashboardWidgetKey, IDynamicWidgetCatalogEntryBase<TFrameworkElementType, TFrameworkComponentType>>;
+
+export declare type TDashboardWidgetKey = string;
+
+export declare type TGetDefaultWidgetMetaFromKey = (widgetKey: TDashboardWidgetKey, options?: TGetDefaultWidgetMetaFromKeyOptions) => TWidgetMetaInfoBase<any>;
+
+export declare type TGetDefaultWidgetMetaFromKeyOptions = {
+    title?: string;
+    description?: string;
+};
+
+export declare type TGetSavedDashboards = (userID: number | string, clientAppKey: string, widgetCatalog: TDashboardWidgetCatalogBase, defaultDashboardConfig: IDashboardConfig) => Promise<IDashboardConfig[]>;
+
+export declare type TManifestEntry = {
+    url: string;
+    meta: TWidgetMetaInfoBase;
+};
+
+export declare type TSaveDashboards = (userID: number | string, clientAppKey: string, dashboardConfigs: IDashboardConfig[], widgetCatalog: TDashboardWidgetCatalogBase) => Promise<boolean>;
+
+export declare type TUndoHistoryEntry = {
+    undoIndex: number;
+    config: IDashboardConfig;
+};
+
+export declare type TWidgetCategory = 'Widget' | 'Chart' | 'Container';
+
+export declare type TWidgetDirection = 'row' | 'column';
+
+/**
+ * 1. Define the Async Loader type
+ * Type for the function that performs the asynchronous dynamic import.
+ * It must return a promise that resolves to the module containing the widget component
+ * as its default export (or a named export if you change the loading strategy).
+ *
+ * TFrameworkComponent could be "React.ComponentType<any>"" or "VueComponent" etc
+ */
+export declare type TWidgetFactoryBase<TFrameworkComponent = any> = () => Promise<{
+    default: TFrameworkComponent;
+}>;
+
+export declare type TWidgetMetaInfoBase<TFrameworkElementType = any> = {
+    name: string;
+    description: string;
+    categories: TWidgetCategory[];
+    noDuplicatedWidgets?: boolean;
+    icon: TFrameworkElementType | undefined;
+    externalDependencies: string[];
+};
+
+export declare type TWidgetSize = 'default' | 'large' | 'xlarge';
+
+export declare const useDashboardStorageService: () => IDashboardStorageService;
+
+export { }

package/dist/core.es.js

@@ -0,0 +1,360 @@
+const w = [
+  {
+    key: "grid-gap",
+    name: "Gap",
+    description: "Set the gap between widgets in the dashboard grid",
+    cssProperty: "--bwj-dashboard-gap",
+    step: 0.1,
+    defaultUnit: "rem",
+    minValue: 0,
+    defaultValue: "1.25rem",
+    value: "1.25rem"
+  },
+  {
+    key: "widget-width",
+    name: "Widget Width",
+    description: "Set the min width for the widgets",
+    cssProperty: "--bwj-widget-width",
+    step: 0.1,
+    defaultUnit: "rem",
+    minValue: 6,
+    defaultValue: "21rem",
+    value: "21rem"
+  },
+  {
+    key: "widget-border-radius",
+    name: "Widget Border Radius",
+    description: "Set the border radius for the widgets",
+    cssProperty: "--bwj-widget-border-radius",
+    step: 0.1,
+    defaultUnit: "rem",
+    minValue: 0,
+    defaultValue: "0.33rem",
+    value: "0.33rem"
+  },
+  {
+    key: "widget-inner-padding-x",
+    name: "Widget Horiz Padding",
+    description: "Set the horizontal padding for the widgets",
+    cssProperty: "--bwj-widget-inner-px",
+    step: 0.1,
+    defaultUnit: "rem",
+    minValue: 0,
+    defaultValue: "1.0rem",
+    value: "1.0rem"
+  },
+  {
+    key: "widget-inner-padding-y",
+    name: "Widget Vertical Padding",
+    description: "Set the vertical padding for the widgets",
+    cssProperty: "--bwj-widget-inner-py",
+    step: 0.1,
+    defaultUnit: "rem",
+    minValue: 0,
+    defaultValue: "0.75rem",
+    value: "0.75rem"
+  },
+  {
+    key: "widget-header-padding-y",
+    name: "Widget Header Vertical Padding",
+    description: "Set the vertical padding for the widget headers",
+    cssProperty: "--bwj-widget-header-py",
+    step: 0.1,
+    defaultUnit: "rem",
+    minValue: 0,
+    defaultValue: "1.0rem",
+    value: "1.0rem"
+  },
+  {
+    key: "widget-title-font-size",
+    name: "Widget Title Font Size",
+    description: "Set the font size for the widget titles",
+    cssProperty: "--bwj-widget-title-size",
+    step: 0.1,
+    defaultUnit: "rem",
+    minValue: 0,
+    defaultValue: "1.0rem",
+    value: "1.0rem"
+  }
+], S = ["rem", "pc", "cm", "in", "em", "vh", "vw", "%"], b = (e, t) => S.includes(e) ? t : 1, E = {
+  incrementOrDecrementValue: (e, t) => {
+    const i = e.value.match(/([\d.]+)/), a = i ? parseFloat(i[1]) : 0, s = e.value.match(/([^\d.]+)/), n = s ? s[1] : e.defaultUnit, r = b(n, e.step) * t, c = `${Math.max(a + r, e.minValue).toFixed(1)}${n}`;
+    return {
+      ...e,
+      value: c
+    };
+  }
+}, f = (e, t) => `dashboards_${t}_${e}`, v = async (e, t, i, a) => {
+  const s = localStorage.getItem(f(e, t));
+  if (s)
+    try {
+      const n = JSON.parse(s);
+      return n.length < 1 ? [a] : (n.forEach((r) => {
+        r.dashboardId || (r.dashboardId = "default"), r.dashboardName || (r.dashboardName = `Dashboard ${r.dashboardId}`), r.responsiveGrid = r.responsiveGrid ?? !1, (r.widgets || []).length < 1 && (r.widgets = a.widgets);
+        const c = (r.cssSettings || []).filter(
+          (o) => a.cssSettings.some((d) => d.key === o.key)
+        );
+        if (c.length < 1)
+          r.cssSettings = [...a.cssSettings];
+        else {
+          c.forEach((d) => {
+            d.value = (d.value || "").replace(/NaN/g, "");
+            const l = a.cssSettings.find(
+              (g) => g.key === d.key
+            );
+            l && (Object.keys(l).forEach((g) => {
+              g in d || (d[g] = l[g]);
+            }), d.step = l.step, d.minValue = l.minValue, d.defaultValue = l.defaultValue, d.defaultUnit = l.defaultUnit, /\d+/g.test(d.value) === !1 && (d.value = l ? l.value : "1.0rem"));
+          });
+          const o = a.cssSettings.filter((d) => !c.some(
+            (l) => l.key === d.key
+          ));
+          r.cssSettings = [...c, ...o];
+        }
+        r.widgets = r.widgets.filter(
+          (o) => o.includes("WidgetContainer") || i.has(o)
+        ), r.childWidgetsConfig = r.childWidgetsConfig.filter(
+          (o) => i.has(o.widgetKey)
+        ), r.zoomScale ? r.zoomScale < 0.7 && (r.zoomScale = 0.7) : r.zoomScale = 1;
+      }), n);
+    } catch (n) {
+      console.warn("Error parsing saved dashboard config:", n);
+    }
+  return [a];
+}, C = async (e, t, i, a) => {
+  i.forEach((n) => {
+    if (n.userID = e, n.clientAppKey = t, n.responsiveGrid = n.responsiveGrid ?? !1, typeof n != "object")
+      throw new Error("Invalid dashboard configuration");
+    n.widgets = n.widgets.filter(
+      (r) => r.includes("WidgetContainer") || a.has(r)
+    ), n.childWidgetsConfig = n.childWidgetsConfig.filter(
+      (r) => a.has(r.widgetKey)
+    ), n.zoomScale ? n.zoomScale < 0.7 && (n.zoomScale = 0.7) : n.zoomScale = 1;
+  });
+  const s = JSON.stringify(i);
+  return localStorage.setItem(f(e, t), s), !0;
+}, W = {
+  getSavedDashboards: v,
+  saveDashboards: C
+}, P = () => W, z = {
+  userID: 0,
+  clientAppKey: "",
+  dashboardId: "default",
+  dashboardName: "Default",
+  zoomScale: 1,
+  responsiveGrid: !1,
+  widgets: [],
+  childWidgetsConfig: [],
+  cssSettings: [...w]
+}, U = (e) => {
+  const t = `${e}`.split("_");
+  return t.length > 1 ? t[1].replace(/(\D)(\d+)/, "$1 $2") : "Container";
+}, m = 0.7, p = 1, V = 0.05, D = (e) => {
+  let t = Number(e || 0);
+  return t < m && (t = m), t > p && (t = p), t;
+}, j = (e, t) => {
+  let i = Number(Number((V * t).toFixed(2)).toFixed(2)), a = Number((Number(e) + i).toFixed(2));
+  return D(a);
+}, N = (e) => {
+  let t = {
+    ...e
+  };
+  return t.widgets = t.widgets.filter((i) => {
+    if (`${i}`.includes("WidgetContainer")) {
+      const a = t.childWidgetsConfig.filter(
+        (s) => s.parentWidgetKey === i
+      );
+      if (!a || a.length === 0)
+        return t.widgets = t.widgets.filter(
+          (s) => s !== i
+        ), !1;
+    }
+    return !0;
+  }), t;
+}, x = (e) => {
+  const t = e.widgets.filter(
+    (a) => a.includes("WidgetContainer")
+  ), i = {};
+  return t.forEach((a, s) => {
+    const n = `${a.split("_container")[0]}_container${s + 1}`;
+    i[a] = n;
+  }), e.widgets = e.widgets.map((a) => i[a] || a), e.childWidgetsConfig = e.childWidgetsConfig.map((a) => {
+    const s = a.parentWidgetKey, n = i[s];
+    return {
+      ...a,
+      // If a new key exists, use it. If not, keep the original key.
+      parentWidgetKey: n || s
+    };
+  }), e;
+}, u = (e, t) => {
+  const i = `${e}`.includes("Container"), a = i ? ["Container"] : ["Widget"], s = t?.name || e, n = t?.description || (i ? "Container" : "Unknown");
+  return {
+    name: s,
+    description: n,
+    categories: a,
+    noDuplicatedWidgets: !0,
+    icon: void 0,
+    externalDependencies: []
+  };
+}, I = (e, t, i) => t[e] || u(e, i), M = (e, t) => t.get(e)?.meta || u(e), k = (e, t, i) => {
+  const a = i || u(e);
+  return [
+    e,
+    {
+      key: e,
+      title: a.name,
+      isContainer: `${e}`.includes("Container"),
+      meta: a,
+      component: t
+    }
+  ];
+}, h = (e, t, i) => {
+  const a = i || u(e);
+  return [
+    e,
+    {
+      key: e,
+      title: a.name,
+      isContainer: !1,
+      meta: a,
+      loader: t
+    }
+  ];
+}, F = (e) => {
+  const t = e.match(/\/widget-([a-zA-Z0-9-]+)\/index\.ts$/);
+  if (t && t[1]) {
+    const i = t[1], a = i.split("-"), s = `Widget${a.map((r) => r.charAt(0).toUpperCase() + r.slice(1)).join("")}`, n = a.map((r) => r.charAt(0).toUpperCase() + r.slice(1)).join(" ");
+    return {
+      key: s,
+      title: n,
+      folder: i
+    };
+  }
+  return null;
+}, $ = (e, t, i, a) => {
+  const s = `${t}/widget-${i}/meta.ts`, n = e[s];
+  if (!n)
+    return;
+  const r = `${a}Meta`;
+  return n[r] || void 0;
+}, A = async (e) => new Promise(async (t, i) => {
+  const a = [];
+  try {
+    const s = await (await fetch(`${e}?${Math.random()}`)).json();
+    for (const n in s) {
+      const r = s[n], c = () => import(
+        /* @vite-ignore */
+        r.url
+      ), o = {
+        name: r.meta?.name || "Unknown",
+        description: r.meta?.description || "Remote Plugin",
+        categories: r.meta?.categories || ["Widget"],
+        noDuplicatedWidgets: r.meta?.noDuplicatedWidgets ?? !0,
+        icon: void 0,
+        // Or a logic to map a string name to a Lucide component
+        externalDependencies: r.meta?.externalDependencies || []
+      };
+      a.push(h(n, c, o));
+    }
+    t({
+      entries: a,
+      message: "",
+      details: ""
+    });
+  } catch (s) {
+    console.error("Remote plugin discovery failed:", s), i({
+      entries: [],
+      message: "Remote plugin discovery failed:",
+      details: typeof s == "object" ? JSON.stringify(s) : s
+    });
+  }
+}), K = (e, t, i, a = !0) => {
+  const s = [];
+  for (const n in t) {
+    const r = t[n], c = F(n);
+    if (c && r) {
+      const { key: o, title: d, folder: l } = c;
+      let g = $(i, e, l, o);
+      if (g || (g = u(o, {
+        description: `Local ${a ? "dynamic" : "static"} widget`
+      })), a)
+        s.push(
+          h(o, r, g)
+        );
+      else {
+        const y = r.default || r;
+        s.push(k(o, y, g));
+      }
+    }
+  }
+  return s;
+}, G = (e, t = "color") => {
+  if (typeof window > "u") return "#FFFFFF";
+  const i = document.createElement("div");
+  Array.isArray(e) ? e.forEach((s) => i.classList.add(s)) : e.split(" ").forEach((s) => i.classList.add(s)), i.style.display = "none", document.body.appendChild(i);
+  const a = window.getComputedStyle(i)[t];
+  return document.body.removeChild(i), a;
+}, R = {
+  /**
+   * @name getCssVariableValue
+   * @description Return the value of a CSS custom property from the current HTML document
+   * @param cssPropertyName
+   * @returns
+   */
+  getCssVariableValue: (e) => {
+    const t = document.documentElement;
+    return getComputedStyle(t).getPropertyValue(e).trim() || null;
+  },
+  /**
+   * @name setCssVariableValue
+   * @description Sets the value of a CSS custom property on the current HTML document
+   * @param cssPropertyName
+   * @param value
+   */
+  setCssVariableValue: (e, t) => {
+    document.documentElement.style.setProperty(e, t);
+  },
+  /**
+   * @name restoreCssVarsFromSettings
+   * @description
+   * Sets the values of many CSS custom properties on the current HTML document
+   * from the list of dashboard settings provided
+   * @param settings, an array of IDashboardSettingEntry
+   */
+  restoreCssVarsFromSettings: (e) => {
+    const t = document.documentElement;
+    e.forEach((i) => {
+      t.style.setProperty(i.cssProperty, i.value);
+    });
+  }
+}, Z = (e, ...t) => [
+  ...new Set(
+    [e || "", ...t].join(" ").trim().replace(/\n+/gi, " ").replace(/\s+/gi, " ").split(" ")
+  )
+].join(" ").trim();
+export {
+  p as DashboardMaxZoomScale,
+  m as DashboardMinZoomScale,
+  V as DashboardZoomStep,
+  z as blankDashboardConfig,
+  h as createDynamicEntry,
+  k as createStaticEntry,
+  w as cssSettingsCatalog,
+  R as cssVarsUtils,
+  E as dashboardSettingsUtils,
+  x as ensureContainersSequence,
+  D as ensureZoomScaleIsWithinRange,
+  u as getDefaultWidgetMetaFromKey,
+  I as getDefaultWidgetMetaFromMap,
+  Z as getDistinctCssClasses,
+  $ as getMetaInfoFromFile,
+  j as getNewZoomScaleWithinRange,
+  M as getWidgetMetaFromCatalog,
+  K as localWidgetDiscovery,
+  U as parseContainerTitle,
+  F as parseKeyAndTitleFromFilePath,
+  A as remoteWidgetDiscovery,
+  N as removeEmptyContainers,
+  G as resolveColorFromClass,
+  P as useDashboardStorageService
+};