@trops/dash-core 0.1.87 → 0.1.89

package/dist/electron/index.js

@@ -589,11 +589,15 @@ 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";
+const DASHBOARD_CONFIG_PUBLISH$1 = "dashboard-config-publish";
 
 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,
+  DASHBOARD_CONFIG_PUBLISH: DASHBOARD_CONFIG_PUBLISH$1,
 };
 
 /**
@@ -8356,12 +8360,151 @@ 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,
+  };
+}
+
+/**
+ * Generate a registry manifest from a dashboard config.
+ * Converts the internal .dashboard.json format into the registry
+ * manifest.json format used by dash-registry.
+ *
+ * @param {Object} dashboardConfig - Validated dashboard config object
+ * @param {Object} options - Publishing options
+ * @param {string} options.githubUser - GitHub username / org for the package scope
+ * @param {string} options.category - Registry category (default: "general")
+ * @param {string} options.repository - Repository URL (optional)
+ * @returns {Object} Registry manifest object
+ */
+function generateRegistryManifest(dashboardConfig, options = {}) {
+  const name = (dashboardConfig.name || "dashboard")
+    .replace(/[^a-zA-Z0-9-_ ]/g, "")
+    .replace(/\s+/g, "-")
+    .toLowerCase();
+
+  const githubUser = options.githubUser || "";
+  const version = dashboardConfig.workspace?.version
+    ? `1.0.${dashboardConfig.workspace.version}`
+    : "1.0.0";
+
+  const manifest = {
+    githubUser,
+    name,
+    displayName: dashboardConfig.name || "Dashboard",
+    author: dashboardConfig.author?.name || "",
+    description: dashboardConfig.description || "",
+    version,
+    type: "dashboard",
+    category: options.category || "general",
+    tags: dashboardConfig.tags || [],
+    icon: dashboardConfig.icon || "grip",
+    downloadUrl: `https://github.com/${githubUser}/dash-registry/releases/download/${githubUser}--${name}--v{version}/${name}-v{version}.zip`,
+    repository: options.repository || "",
+    publishedAt: new Date().toISOString(),
+    widgets: (dashboardConfig.widgets || []).map((w) => ({
+      id: w.id,
+      name: w.id ? w.id.split(".").pop() : w.package,
+      package: w.package,
+      version: w.version || "*",
+      required: w.required !== false,
+      author: w.author || "",
+    })),
+    providers: dashboardConfig.providers || [],
+    eventWiring: dashboardConfig.eventWiring || [],
+  };
+
+  return manifest;
+}
+
 var dashboardConfigUtils$1 = {
   collectComponentNames: collectComponentNames$1,
   extractEventWiring: extractEventWiring$1,
   buildWidgetDependencies: buildWidgetDependencies$1,
   buildProviderRequirements: buildProviderRequirements$1,
   applyEventWiringToLayout: applyEventWiringToLayout$1,
+  checkDashboardCompatibility,
+  generateRegistryManifest,
 };
 
 var widgetRegistry$1 = {exports: {}};
@@ -10271,10 +10414,223 @@ 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,
+  );
+}
+
+/**
+ * Prepare a dashboard for publishing to the registry.
+ *
+ * Validates that the workspace is shareable, builds the dashboard config,
+ * checks that all widgets exist in the registry, generates a registry
+ * manifest, and creates a ZIP containing both the manifest and
+ * .dashboard.json config.
+ *
+ * @param {BrowserWindow} win - The main window (for save dialog)
+ * @param {string} appId - Application identifier
+ * @param {number|string} workspaceId - ID of the workspace to publish
+ * @param {Object} options - Publishing options
+ * @param {string} options.authorName - Author name
+ * @param {string} options.authorId - Author ID
+ * @param {string} options.description - Dashboard description
+ * @param {string[]} options.tags - Tags
+ * @param {string} options.icon - Icon name
+ * @param {string} options.githubUser - GitHub user/org for registry scope
+ * @param {string} options.category - Registry category
+ * @param {Object} widgetRegistry - WidgetRegistry instance
+ * @returns {Promise<Object>} Result with success, manifest, and filePath
+ */
+async function prepareDashboardForPublish$1(
+  win,
+  appId,
+  workspaceId,
+  options = {},
+  widgetRegistry = null,
+) {
+  try {
+    const { generateRegistryManifest } = dashboardConfigUtils$1;
+
+    // 1. Read workspace
+    const filename = path.join(
+      app.getPath("userData"),
+      appName,
+      appId,
+      configFilename,
+    );
+    const workspacesArray = getFileContents(filename);
+    const workspace = workspacesArray.find(
+      (w) => w.id === workspaceId || w.id === Number(workspaceId),
+    );
+
+    if (!workspace) {
+      return {
+        success: false,
+        error: `Workspace not found: ${workspaceId}`,
+      };
+    }
+
+    // 2. Check shareable flag — imported dashboards cannot be published
+    if (workspace._dashboardConfig && workspace._dashboardConfig.shareable === false) {
+      return {
+        success: false,
+        error: "This dashboard was imported and cannot be published. Only dashboards you created can be shared.",
+      };
+    }
+
+    const layout = workspace.layout || [];
+
+    // 3. Build the dashboard config (reuse export logic)
+    const componentNames = collectComponentNames(layout);
+    const eventWiring = extractEventWiring(layout);
+    const widgets = buildWidgetDependencies(componentNames, widgetRegistry);
+    const providers = buildProviderRequirements(componentNames, widgetRegistry);
+
+    const dashboardConfig = applyDefaults({
+      schemaVersion: CURRENT_SCHEMA_VERSION,
+      name: workspace.name || workspace.label || "Dashboard",
+      description: options.description || "",
+      author: {
+        name: options.authorName || "",
+        id: options.authorId || "",
+      },
+      shareable: true,
+      tags: options.tags || [],
+      icon: options.icon || "grip",
+      workspace: {
+        id: workspace.id,
+        name: workspace.name,
+        type: workspace.type || "workspace",
+        label: workspace.label || workspace.name,
+        version: workspace.version || 1,
+        layout,
+        menuId: workspace.menuId || 1,
+      },
+      widgets,
+      providers,
+      eventWiring,
+    });
+
+    // 4. Validate the config
+    const validation = validateDashboardConfig(dashboardConfig);
+    if (!validation.valid) {
+      return {
+        success: false,
+        error: `Generated config is invalid: ${validation.errors.join(", ")}`,
+      };
+    }
+
+    // 5. Verify all widgets exist in the registry
+    const { fetchRegistryIndex } = registryController$1;
+    let registryPackages = [];
+    try {
+      const index = await fetchRegistryIndex();
+      registryPackages = index.packages || [];
+    } catch (err) {
+      return {
+        success: false,
+        error: `Cannot verify widgets in registry: ${err.message}`,
+      };
+    }
+
+    const registryNames = new Set(registryPackages.map((p) => p.name));
+    const missingFromRegistry = widgets
+      .filter((w) => w.required !== false && !registryNames.has(w.package))
+      .map((w) => w.package);
+
+    if (missingFromRegistry.length > 0) {
+      return {
+        success: false,
+        error: `Required widgets not found in registry: ${missingFromRegistry.join(", ")}. Publish them first.`,
+      };
+    }
+
+    // 6. Generate registry manifest
+    const manifest = generateRegistryManifest(dashboardConfig, {
+      githubUser: options.githubUser || options.authorId || "",
+      category: options.category || "general",
+      repository: options.repository || "",
+    });
+
+    // 7. Show save dialog for the publish package
+    const sanitizedName = manifest.name;
+    const { canceled, filePath } = await dialog.showSaveDialog(win, {
+      title: "Save Dashboard Package for Registry",
+      defaultPath: path.join(
+        app.getPath("desktop"),
+        `${sanitizedName}-v${manifest.version}.zip`,
+      ),
+      filters: [{ name: "ZIP Archive", extensions: ["zip"] }],
+    });
+
+    if (canceled || !filePath) {
+      return { success: false, canceled: true };
+    }
+
+    // 8. Create ZIP with manifest and dashboard config
+    const zip = new AdmZip();
+    zip.addFile("manifest.json", Buffer.from(JSON.stringify(manifest, null, 2), "utf-8"));
+    zip.addFile(
+      `${sanitizedName}.dashboard.json`,
+      Buffer.from(JSON.stringify(dashboardConfig, null, 2), "utf-8"),
+    );
+    zip.writeZip(filePath);
+
+    console.log(
+      `[DashboardConfigController] Prepared publish package: ${filePath}`,
+    );
+
+    return {
+      success: true,
+      filePath,
+      manifest,
+      config: dashboardConfig,
+    };
+  } catch (error) {
+    console.error(
+      "[DashboardConfigController] Error preparing dashboard for publish:",
+      error,
+    );
+    return {
+      success: false,
+      error: error.message,
+    };
+  }
+}
+
 var dashboardConfigController$1 = {
   exportDashboardConfig: exportDashboardConfig$1,
   importDashboardConfig: importDashboardConfig$1,
   installDashboardFromRegistry: installDashboardFromRegistry$1,
+  checkCompatibility: checkCompatibility$1,
+  prepareDashboardForPublish: prepareDashboardForPublish$1,
 };
 
 /**
@@ -10367,6 +10723,8 @@ const {
   exportDashboardConfig,
   importDashboardConfig,
   installDashboardFromRegistry,
+  checkCompatibility,
+  prepareDashboardForPublish,
 } = dashboardConfigController$1;
 
 var controller = {
@@ -10413,6 +10771,8 @@ var controller = {
   exportDashboardConfig,
   importDashboardConfig,
   installDashboardFromRegistry,
+  checkCompatibility,
+  prepareDashboardForPublish,
 };
 
 const { ipcRenderer: ipcRenderer$i } = require$$0$1;
@@ -11792,6 +12152,8 @@ const {
   DASHBOARD_CONFIG_EXPORT,
   DASHBOARD_CONFIG_IMPORT,
   DASHBOARD_CONFIG_INSTALL,
+  DASHBOARD_CONFIG_COMPATIBILITY,
+  DASHBOARD_CONFIG_PUBLISH,
 } = events$8;
 
 const dashboardConfigApi$2 = {
@@ -11835,6 +12197,36 @@ 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,
+    }),
+
+  /**
+   * Prepare a dashboard for publishing to the registry.
+   * Validates shareable status, checks widgets exist in registry,
+   * generates manifest, and saves a publish-ready ZIP.
+   *
+   * @param {string} appId - Application identifier
+   * @param {number|string} workspaceId - Workspace to publish
+   * @param {Object} options - Publishing options (authorName, authorId, description, tags, icon, githubUser, category)
+   * @returns {Promise<Object>} Result with success, manifest, filePath
+   */
+  prepareDashboardForPublish: (appId, workspaceId, options = {}) =>
+    ipcRenderer$1.invoke(DASHBOARD_CONFIG_PUBLISH, {
+      appId,
+      workspaceId,
+      options,
+    }),
 };
 
 var dashboardConfigApi_1 = dashboardConfigApi$2;