@trops/dash-core 0.1.87 → 0.1.88

package/dist/electron/index.js

@@ -589,11 +589,13 @@ var clientCacheEvents$1 = {
 const DASHBOARD_CONFIG_EXPORT$1 = "dashboard-config-export";
 const DASHBOARD_CONFIG_IMPORT$1 = "dashboard-config-import";
 const DASHBOARD_CONFIG_INSTALL$1 = "dashboard-config-install";
+const DASHBOARD_CONFIG_COMPATIBILITY$1 = "dashboard-config-compatibility";
 
 var dashboardConfigEvents$1 = {
   DASHBOARD_CONFIG_EXPORT: DASHBOARD_CONFIG_EXPORT$1,
   DASHBOARD_CONFIG_IMPORT: DASHBOARD_CONFIG_IMPORT$1,
   DASHBOARD_CONFIG_INSTALL: DASHBOARD_CONFIG_INSTALL$1,
+  DASHBOARD_CONFIG_COMPATIBILITY: DASHBOARD_CONFIG_COMPATIBILITY$1,
 };
 
 /**
@@ -8356,12 +8358,98 @@ function applyEventWiringToLayout$1(layout, eventWiring) {
   return layout;
 }
 
+/**
+ * Check compatibility of a dashboard config against installed widgets.
+ * Returns a per-widget status report indicating what's installed,
+ * what needs to be installed, and what's unavailable.
+ *
+ * @param {Array} dashboardWidgets - Widget deps from dashboard config (widgets array)
+ * @param {Array} installedWidgets - Currently installed widget metadata (from widgetRegistry.getWidgets())
+ * @param {Array} registryPackages - Available packages from registry index (optional)
+ * @returns {Object} Compatibility report
+ */
+function checkDashboardCompatibility(
+  dashboardWidgets = [],
+  installedWidgets = [],
+  registryPackages = [],
+) {
+  const installedByName = new Map();
+  for (const w of installedWidgets) {
+    if (w.name) {
+      installedByName.set(w.name, w);
+    }
+  }
+
+  const registryByName = new Map();
+  for (const p of registryPackages) {
+    if (p.name) {
+      registryByName.set(p.name, p);
+    }
+  }
+
+  const widgets = [];
+  let installedCount = 0;
+  let toInstallCount = 0;
+  let unavailableCount = 0;
+
+  for (const dep of dashboardWidgets) {
+    const packageName = dep.package;
+    const required = dep.required !== false;
+    const installed = installedByName.get(packageName);
+
+    if (installed) {
+      installedCount++;
+      widgets.push({
+        package: packageName,
+        required,
+        status: "installed",
+        installedVersion: installed.version || null,
+        requiredVersion: dep.version || "*",
+      });
+    } else if (registryByName.has(packageName)) {
+      toInstallCount++;
+      const registryPkg = registryByName.get(packageName);
+      widgets.push({
+        package: packageName,
+        required,
+        status: "to-install",
+        availableVersion: registryPkg.version || null,
+        requiredVersion: dep.version || "*",
+      });
+    } else {
+      unavailableCount++;
+      widgets.push({
+        package: packageName,
+        required,
+        status: "unavailable",
+        requiredVersion: dep.version || "*",
+      });
+    }
+  }
+
+  const hasUnavailableRequired = widgets.some(
+    (w) => w.status === "unavailable" && w.required,
+  );
+
+  return {
+    compatible: !hasUnavailableRequired,
+    summary: {
+      total: dashboardWidgets.length,
+      installed: installedCount,
+      toInstall: toInstallCount,
+      unavailable: unavailableCount,
+    },
+    widgets,
+  };
+}
+
 var dashboardConfigUtils$1 = {
   collectComponentNames: collectComponentNames$1,
   extractEventWiring: extractEventWiring$1,
   buildWidgetDependencies: buildWidgetDependencies$1,
   buildProviderRequirements: buildProviderRequirements$1,
   applyEventWiringToLayout: applyEventWiringToLayout$1,
+  checkDashboardCompatibility,
 };
 
 var widgetRegistry$1 = {exports: {}};
@@ -10271,10 +10359,43 @@ async function installDashboardFromRegistry$1(
   }
 }
 
+/**
+ * Check compatibility of a dashboard's widget dependencies against
+ * installed widgets and registry availability.
+ *
+ * @param {Array} dashboardWidgets - Widget deps from dashboard config
+ * @param {Object} widgetRegistry - WidgetRegistry instance (needs getWidgets())
+ * @returns {Promise<Object>} Compatibility report
+ */
+async function checkCompatibility$1(dashboardWidgets, widgetRegistry = null) {
+  const { checkDashboardCompatibility } = dashboardConfigUtils$1;
+  const { fetchRegistryIndex } = registryController$1;
+
+  const installedWidgets = widgetRegistry ? widgetRegistry.getWidgets() : [];
+
+  let registryPackages = [];
+  try {
+    const index = await fetchRegistryIndex();
+    registryPackages = index.packages || [];
+  } catch (err) {
+    console.warn(
+      "[DashboardConfigController] Could not fetch registry index for compatibility check:",
+      err.message,
+    );
+  }
+
+  return checkDashboardCompatibility(
+    dashboardWidgets,
+    installedWidgets,
+    registryPackages,
+  );
+}
+
 var dashboardConfigController$1 = {
   exportDashboardConfig: exportDashboardConfig$1,
   importDashboardConfig: importDashboardConfig$1,
   installDashboardFromRegistry: installDashboardFromRegistry$1,
+  checkCompatibility: checkCompatibility$1,
 };
 
 /**
@@ -10367,6 +10488,7 @@ const {
   exportDashboardConfig,
   importDashboardConfig,
   installDashboardFromRegistry,
+  checkCompatibility,
 } = dashboardConfigController$1;
 
 var controller = {
@@ -10413,6 +10535,7 @@ var controller = {
   exportDashboardConfig,
   importDashboardConfig,
   installDashboardFromRegistry,
+  checkCompatibility,
 };
 
 const { ipcRenderer: ipcRenderer$i } = require$$0$1;
@@ -11792,6 +11915,7 @@ const {
   DASHBOARD_CONFIG_EXPORT,
   DASHBOARD_CONFIG_IMPORT,
   DASHBOARD_CONFIG_INSTALL,
+  DASHBOARD_CONFIG_COMPATIBILITY,
 } = events$8;
 
 const dashboardConfigApi$2 = {
@@ -11835,6 +11959,19 @@ const dashboardConfigApi$2 = {
       appId,
       packageName,
     }),
+
+  /**
+   * Check compatibility of a dashboard config against installed widgets.
+   *
+   * @param {string} appId - Application identifier
+   * @param {Array} dashboardWidgets - Widget dependencies from dashboard config
+   * @returns {Promise<Object>} Compatibility report with per-widget status
+   */
+  checkDashboardCompatibility: (appId, dashboardWidgets) =>
+    ipcRenderer$1.invoke(DASHBOARD_CONFIG_COMPATIBILITY, {
+      appId,
+      dashboardWidgets,
+    }),
 };
 
 var dashboardConfigApi_1 = dashboardConfigApi$2;