@trops/dash-core 0.1.89 → 0.1.91

package/dist/electron/index.js

@@ -591,6 +591,8 @@ const DASHBOARD_CONFIG_IMPORT$1 = "dashboard-config-import";
 const DASHBOARD_CONFIG_INSTALL$1 = "dashboard-config-install";
 const DASHBOARD_CONFIG_COMPATIBILITY$1 = "dashboard-config-compatibility";
 const DASHBOARD_CONFIG_PUBLISH$1 = "dashboard-config-publish";
+const DASHBOARD_CONFIG_PREVIEW$1 = "dashboard-config-preview";
+const DASHBOARD_CONFIG_CHECK_UPDATES$1 = "dashboard-config-check-updates";
 
 var dashboardConfigEvents$1 = {
   DASHBOARD_CONFIG_EXPORT: DASHBOARD_CONFIG_EXPORT$1,
@@ -598,6 +600,8 @@ var dashboardConfigEvents$1 = {
   DASHBOARD_CONFIG_INSTALL: DASHBOARD_CONFIG_INSTALL$1,
   DASHBOARD_CONFIG_COMPATIBILITY: DASHBOARD_CONFIG_COMPATIBILITY$1,
   DASHBOARD_CONFIG_PUBLISH: DASHBOARD_CONFIG_PUBLISH$1,
+  DASHBOARD_CONFIG_PREVIEW: DASHBOARD_CONFIG_PREVIEW$1,
+  DASHBOARD_CONFIG_CHECK_UPDATES: DASHBOARD_CONFIG_CHECK_UPDATES$1,
 };
 
 /**
@@ -8497,6 +8501,103 @@ function generateRegistryManifest(dashboardConfig, options = {}) {
   return manifest;
 }
 
+/**
+ * Build a structured preview object from a dashboard registry package
+ * or dashboard config. Provides all data needed for a rich preview UI.
+ *
+ * @param {Object} source - Registry package manifest or dashboard config
+ * @returns {Object} Structured preview with metadata, widgets, wiring, providers
+ */
+function buildDashboardPreview(source) {
+  const preview = {
+    name: source.displayName || source.name || "Dashboard",
+    description: source.description || "",
+    author: typeof source.author === "object"
+      ? source.author.name || ""
+      : source.author || "",
+    authorId: typeof source.author === "object"
+      ? source.author.id || ""
+      : "",
+    version: source.version || "",
+    icon: source.icon || "grip",
+    tags: source.tags || [],
+    screenshots: source.screenshots || [],
+    publishedAt: source.publishedAt || null,
+    category: source.category || "general",
+    widgets: (source.widgets || []).map((w) => ({
+      name: w.name || w.id || w.package || "",
+      package: w.package || "",
+      version: w.version || "*",
+      required: w.required !== false,
+      author: w.author || "",
+    })),
+    eventWiring: (source.eventWiring || []).map((wire) => ({
+      raw: wire,
+      summary: `${wire.source?.widget || "?"}.${wire.source?.event || "?"} → ${wire.target?.widget || "?"}.${wire.target?.handler || wire.source?.event || "?"}`,
+    })),
+    providers: (source.providers || []).map((p) => ({
+      type: p.type || "",
+      providerClass: p.providerClass || "",
+      required: p.required !== false,
+      usedBy: p.usedBy || [],
+    })),
+    summary: {
+      widgetCount: (source.widgets || []).length,
+      eventCount: (source.eventWiring || []).length,
+      providerCount: (source.providers || []).length,
+      requiredWidgets: (source.widgets || []).filter((w) => w.required !== false).length,
+      optionalWidgets: (source.widgets || []).filter((w) => w.required === false).length,
+    },
+  };
+
+  return preview;
+}
+
+/**
+ * Check installed dashboards for available updates in the registry.
+ *
+ * Compares the `_dashboardConfig.installedVersion` of each workspace
+ * against the current version in the registry.
+ *
+ * @param {Array} workspaces - All workspaces from workspaces.json
+ * @param {Array} registryPackages - Packages from registry index
+ * @returns {Array} Update records with workspace info and version comparison
+ */
+function checkDashboardUpdates(workspaces = [], registryPackages = []) {
+  const registryByName = new Map();
+  for (const pkg of registryPackages) {
+    if (pkg.name && (pkg.type || "widget") === "dashboard") {
+      registryByName.set(pkg.name, pkg);
+    }
+  }
+
+  const updates = [];
+
+  for (const ws of workspaces) {
+    const config = ws._dashboardConfig;
+    if (!config || !config.registryPackage) continue;
+
+    const registryPkg = registryByName.get(config.registryPackage);
+    if (!registryPkg) continue;
+
+    const installedVersion = config.installedVersion || "0.0.0";
+    const latestVersion = registryPkg.version || "0.0.0";
+
+    if (installedVersion !== latestVersion) {
+      updates.push({
+        workspaceId: ws.id,
+        workspaceName: ws.name || ws.label || "",
+        registryPackage: config.registryPackage,
+        installedVersion,
+        latestVersion,
+        importedAt: config.importedAt || null,
+      });
+    }
+  }
+
+  return updates;
+}
+
 var dashboardConfigUtils$1 = {
   collectComponentNames: collectComponentNames$1,
   extractEventWiring: extractEventWiring$1,
@@ -8505,6 +8606,8 @@ var dashboardConfigUtils$1 = {
   applyEventWiringToLayout: applyEventWiringToLayout$1,
   checkDashboardCompatibility,
   generateRegistryManifest,
+  buildDashboardPreview,
+  checkDashboardUpdates,
 };
 
 var widgetRegistry$1 = {exports: {}};
@@ -10244,6 +10347,8 @@ async function processDashboardConfig(
     importedAt: new Date().toISOString(),
     originalAuthor: dashboardConfig.author,
     schemaVersion: dashboardConfig.schemaVersion,
+    registryPackage: options.registryPackage || null,
+    installedVersion: options.installedVersion || null,
   };
 
   // Save workspace to workspaces.json
@@ -10400,6 +10505,8 @@ async function installDashboardFromRegistry$1(
       widgetRegistry,
       {
         source: "registry",
+        registryPackage: packageName,
+        installedVersion: registryPkg.version || null,
       },
     );
   } catch (error) {
@@ -10625,12 +10732,104 @@ async function prepareDashboardForPublish$1(
   }
 }
 
+/**
+ * Get a full preview of a dashboard package from the registry.
+ * Combines the structured preview data with a compatibility check.
+ *
+ * @param {string} packageName - Registry package name
+ * @param {Object} widgetRegistry - WidgetRegistry instance
+ * @returns {Promise<Object>} Preview data with compatibility report
+ */
+async function getDashboardPreview$1(packageName, widgetRegistry = null) {
+  const { buildDashboardPreview, checkDashboardCompatibility } =
+    dashboardConfigUtils$1;
+  const { getPackage, fetchRegistryIndex } = registryController$1;
+
+  const pkg = await getPackage(packageName);
+  if (!pkg) {
+    return {
+      success: false,
+      error: `Dashboard package not found: ${packageName}`,
+    };
+  }
+
+  const preview = buildDashboardPreview(pkg);
+
+  // Get compatibility report
+  const installedWidgets = widgetRegistry ? widgetRegistry.getWidgets() : [];
+  let registryPackages = [];
+  try {
+    const index = await fetchRegistryIndex();
+    registryPackages = index.packages || [];
+  } catch (err) {
+    // Non-fatal — preview still works without compatibility
+  }
+
+  const compatibility = checkDashboardCompatibility(
+    pkg.widgets || [],
+    installedWidgets,
+    registryPackages,
+  );
+
+  return {
+    success: true,
+    preview,
+    compatibility,
+  };
+}
+
+/**
+ * Check installed dashboards for available updates.
+ * Reads workspaces, finds those installed from the registry,
+ * and compares versions against the current registry index.
+ *
+ * @param {string} appId - Application identifier
+ * @returns {Promise<Object>} Result with updates array
+ */
+async function checkDashboardUpdatesForApp$1(appId) {
+  const { checkDashboardUpdates } = dashboardConfigUtils$1;
+  const { fetchRegistryIndex } = registryController$1;
+
+  try {
+    const filename = path.join(
+      app.getPath("userData"),
+      appName,
+      appId,
+      configFilename,
+    );
+    const workspaces = getFileContents(filename) || [];
+
+    const index = await fetchRegistryIndex();
+    const registryPackages = index.packages || [];
+
+    const updates = checkDashboardUpdates(workspaces, registryPackages);
+
+    return {
+      success: true,
+      updates,
+      totalInstalled: workspaces.filter((w) => w._dashboardConfig?.registryPackage).length,
+    };
+  } catch (error) {
+    console.error(
+      "[DashboardConfigController] Error checking dashboard updates:",
+      error,
+    );
+    return {
+      success: false,
+      error: error.message,
+      updates: [],
+    };
+  }
+}
+
 var dashboardConfigController$1 = {
   exportDashboardConfig: exportDashboardConfig$1,
   importDashboardConfig: importDashboardConfig$1,
   installDashboardFromRegistry: installDashboardFromRegistry$1,
   checkCompatibility: checkCompatibility$1,
   prepareDashboardForPublish: prepareDashboardForPublish$1,
+  getDashboardPreview: getDashboardPreview$1,
+  checkDashboardUpdatesForApp: checkDashboardUpdatesForApp$1,
 };
 
 /**
@@ -10725,6 +10924,8 @@ const {
   installDashboardFromRegistry,
   checkCompatibility,
   prepareDashboardForPublish,
+  getDashboardPreview,
+  checkDashboardUpdatesForApp,
 } = dashboardConfigController$1;
 
 var controller = {
@@ -10773,6 +10974,8 @@ var controller = {
   installDashboardFromRegistry,
   checkCompatibility,
   prepareDashboardForPublish,
+  getDashboardPreview,
+  checkDashboardUpdatesForApp,
 };
 
 const { ipcRenderer: ipcRenderer$i } = require$$0$1;
@@ -12154,6 +12357,8 @@ const {
   DASHBOARD_CONFIG_INSTALL,
   DASHBOARD_CONFIG_COMPATIBILITY,
   DASHBOARD_CONFIG_PUBLISH,
+  DASHBOARD_CONFIG_PREVIEW,
+  DASHBOARD_CONFIG_CHECK_UPDATES,
 } = events$8;
 
 const dashboardConfigApi$2 = {
@@ -12227,6 +12432,25 @@ const dashboardConfigApi$2 = {
       workspaceId,
       options,
     }),
+
+  /**
+   * Get a preview of a dashboard package from the registry.
+   * Returns structured preview data and compatibility report.
+   *
+   * @param {string} packageName - Registry package name
+   * @returns {Promise<Object>} Preview with metadata, widgets, wiring, compatibility
+   */
+  getDashboardPreview: (packageName) =>
+    ipcRenderer$1.invoke(DASHBOARD_CONFIG_PREVIEW, { packageName }),
+
+  /**
+   * Check installed dashboards for available updates.
+   *
+   * @param {string} appId - Application identifier
+   * @returns {Promise<Object>} Result with updates array
+   */
+  checkDashboardUpdates: (appId) =>
+    ipcRenderer$1.invoke(DASHBOARD_CONFIG_CHECK_UPDATES, { appId }),
 };
 
 var dashboardConfigApi_1 = dashboardConfigApi$2;