@trops/dash-core 0.1.88 → 0.1.90

package/dist/electron/index.js

@@ -590,12 +590,16 @@ 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";
+const DASHBOARD_CONFIG_PREVIEW$1 = "dashboard-config-preview";
 
 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,
+  DASHBOARD_CONFIG_PREVIEW: DASHBOARD_CONFIG_PREVIEW$1,
 };
 
 /**
@@ -8443,6 +8447,110 @@ function checkDashboardCompatibility(
   };
 }
 
+/**
+ * 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;
+}
+
+/**
+ * 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;
+}
+
 var dashboardConfigUtils$1 = {
   collectComponentNames: collectComponentNames$1,
   extractEventWiring: extractEventWiring$1,
@@ -8450,6 +8558,8 @@ var dashboardConfigUtils$1 = {
   buildProviderRequirements: buildProviderRequirements$1,
   applyEventWiringToLayout: applyEventWiringToLayout$1,
   checkDashboardCompatibility,
+  generateRegistryManifest,
+  buildDashboardPreview,
 };
 
 var widgetRegistry$1 = {exports: {}};
@@ -10391,11 +10501,238 @@ async function checkCompatibility$1(dashboardWidgets, widgetRegistry = null) {
   );
 }
 
+/**
+ * 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,
+    };
+  }
+}
+
+/**
+ * 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,
+  };
+}
+
 var dashboardConfigController$1 = {
   exportDashboardConfig: exportDashboardConfig$1,
   importDashboardConfig: importDashboardConfig$1,
   installDashboardFromRegistry: installDashboardFromRegistry$1,
   checkCompatibility: checkCompatibility$1,
+  prepareDashboardForPublish: prepareDashboardForPublish$1,
+  getDashboardPreview: getDashboardPreview$1,
 };
 
 /**
@@ -10489,6 +10826,8 @@ const {
   importDashboardConfig,
   installDashboardFromRegistry,
   checkCompatibility,
+  prepareDashboardForPublish,
+  getDashboardPreview,
 } = dashboardConfigController$1;
 
 var controller = {
@@ -10536,6 +10875,8 @@ var controller = {
   importDashboardConfig,
   installDashboardFromRegistry,
   checkCompatibility,
+  prepareDashboardForPublish,
+  getDashboardPreview,
 };
 
 const { ipcRenderer: ipcRenderer$i } = require$$0$1;
@@ -11916,6 +12257,8 @@ const {
   DASHBOARD_CONFIG_IMPORT,
   DASHBOARD_CONFIG_INSTALL,
   DASHBOARD_CONFIG_COMPATIBILITY,
+  DASHBOARD_CONFIG_PUBLISH,
+  DASHBOARD_CONFIG_PREVIEW,
 } = events$8;
 
 const dashboardConfigApi$2 = {
@@ -11972,6 +12315,33 @@ const dashboardConfigApi$2 = {
       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,
+    }),
+
+  /**
+   * 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 }),
 };
 
 var dashboardConfigApi_1 = dashboardConfigApi$2;