@trops/dash-core 0.1.356 → 0.1.358

package/dist/electron/index.js

@@ -650,6 +650,9 @@ function requireDashboardConfigEvents () {
 	const DASHBOARD_CONFIG_PUBLISH_PREVIEW = "dashboard-config-publish-preview";
 	const DASHBOARD_CONFIG_SELECT_FILE = "dashboard-config-select-file";
 	const DASHBOARD_CONFIG_INSTALL_PROGRESS = "dashboard-config-install-progress";
+	const DASHBOARD_CONFIG_COLLECT_DEPENDENCIES =
+	  "dashboard-config-collect-dependencies";
+	const DASHBOARD_CONFIG_PUBLISH_PLAN = "dashboard-config-publish-plan";
 
 	dashboardConfigEvents$1 = {
 	  DASHBOARD_CONFIG_EXPORT,
@@ -663,6 +666,8 @@ function requireDashboardConfigEvents () {
 	  DASHBOARD_CONFIG_PUBLISH_PREVIEW,
 	  DASHBOARD_CONFIG_SELECT_FILE,
 	  DASHBOARD_CONFIG_INSTALL_PROGRESS,
+	  DASHBOARD_CONFIG_COLLECT_DEPENDENCIES,
+	  DASHBOARD_CONFIG_PUBLISH_PLAN,
 	};
 	return dashboardConfigEvents$1;
 }
@@ -62999,8 +63004,34 @@ function checkApiCompatibility(providers = [], appCapabilities = []) {
   };
 }
 
+/**
+ * Collect unique component names across a workspace's main layout, every
+ * page layout, and the sidebar layout. Matches what a user actually sees
+ * on screen — `collectComponentNames` only walks a single layout array
+ * and misses widgets placed on non-active pages or in the sidebar.
+ *
+ * @param {Object} workspace - Workspace object ({layout, pages, sidebarLayout})
+ * @returns {string[]} Unique component names
+ */
+function collectComponentNamesFromWorkspace$1(workspace) {
+  const names = new Set();
+  const pushAll = (layout) => {
+    if (!Array.isArray(layout)) return;
+    for (const n of collectComponentNames$1(layout)) names.add(n);
+  };
+
+  pushAll(workspace?.layout);
+  pushAll(workspace?.sidebarLayout);
+  if (Array.isArray(workspace?.pages)) {
+    for (const page of workspace.pages) pushAll(page?.layout);
+  }
+
+  return Array.from(names);
+}
+
 var dashboardConfigUtils$1 = {
   collectComponentNames: collectComponentNames$1,
+  collectComponentNamesFromWorkspace: collectComponentNamesFromWorkspace$1,
   extractEventWiring: extractEventWiring$1,
   buildWidgetDependencies: buildWidgetDependencies$1,
   buildProviderRequirements: buildProviderRequirements$1,
@@ -63094,6 +63125,55 @@ async function publishToRegistry$1(zipPath, manifest) {
   }
 }
 
+/**
+ * Bulk-resolve package refs to their registry state. Used by the
+ * batch-publish dialog to decorate dependency rows with ownership +
+ * latest version + visibility.
+ *
+ * Sends token if available (authenticated callers see their private
+ * packages too). Anonymous calls still work — only public data is
+ * returned.
+ *
+ * @param {Array<{scope: string, name: string}>} refs
+ * @returns {Promise<Object>} { success, resolved: [...], error? }
+ */
+async function resolvePackages(refs) {
+  if (!Array.isArray(refs) || refs.length === 0) {
+    return { success: true, resolved: [] };
+  }
+
+  try {
+    const headers = { "Content-Type": "application/json" };
+    const auth = getStoredToken$2();
+    if (auth?.token) {
+      headers.Authorization = `Bearer ${auth.token}`;
+    }
+
+    const response = await fetch(`${REGISTRY_BASE_URL}/api/packages/resolve`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ refs }),
+    });
+
+    const data = await response.json().catch(() => null);
+
+    if (!response.ok) {
+      return {
+        success: false,
+        error: data?.error || `Resolve failed: ${response.status}`,
+      };
+    }
+
+    return { success: true, resolved: Array.isArray(data) ? data : [] };
+  } catch (err) {
+    console.error("[RegistryApiController] Resolve error:", err);
+    return {
+      success: false,
+      error: err.message || "Failed to resolve packages",
+    };
+  }
+}
+
 /**
  * Get the registry URL for a published package.
  *
@@ -63107,6 +63187,7 @@ function getRegistryUrl$1(scope, name) {
 
 var registryApiController$2 = {
   publishToRegistry: publishToRegistry$1,
+  resolvePackages,
   getRegistryUrl: getRegistryUrl$1,
   REGISTRY_BASE_URL,
 };
@@ -63700,6 +63781,7 @@ const {
 } = dashboardConfigValidator$1;
 const {
   collectComponentNames,
+  collectComponentNamesFromWorkspace,
   extractEventWiring,
   buildWidgetDependencies,
   buildProviderRequirements,
@@ -64711,6 +64793,214 @@ async function checkCompatibility$1(dashboardWidgets, widgetRegistry = null) {
   );
 }
 
+/**
+ * Collect enriched dependency info for a workspace — widgets + theme.
+ *
+ * Read-only. Used by the batch-publish dialog to build its dependency
+ * table. Resolves local state (scope, name, version from each widget's
+ * package.json, and packageDir for later zipping). Does NOT query the
+ * registry — that's the caller's job (see registry resolve endpoint).
+ *
+ * @param {string} appId - Application identifier
+ * @param {number|string} workspaceId - Workspace ID
+ * @param {Object} widgetRegistry - WidgetRegistry instance
+ * @param {Object} options - { componentConfigs?: Object }
+ * @returns {Promise<Object>} { success, widgets, theme }
+ */
+async function collectDashboardDependencies$1(
+  appId,
+  workspaceId,
+  widgetRegistry = null,
+  options = {},
+) {
+  try {
+    // 1. Read workspace
+    const filename = path$1.join(
+      app$1.getPath("userData"),
+      appName$1,
+      appId,
+      configFilename,
+    );
+    const workspacesArray = getFileContents$1(filename);
+    const workspace = workspacesArray.find(
+      (w) => w.id === workspaceId || w.id === Number(workspaceId),
+    );
+
+    if (!workspace) {
+      return {
+        success: false,
+        error: `Workspace not found: ${workspaceId}`,
+      };
+    }
+
+    // 2. Collect component names from main + pages + sidebar layouts
+    const componentNames = collectComponentNamesFromWorkspace(workspace);
+
+    // 3. Resolve widget refs (scope, packageName, widgetName, version)
+    const deps = buildWidgetDependencies(
+      componentNames,
+      widgetRegistry,
+      options.componentConfigs || null,
+    );
+
+    // 4. Enrich with packageDir + componentNames-in-package (from registry)
+    //    so the caller can zip and publish each widget.
+    const installedWidgets = widgetRegistry ? widgetRegistry.getWidgets() : [];
+
+    const widgets = deps.map((dep) => {
+      // Find the installed widget whose componentNames contains this dep's widgetName
+      const match = installedWidgets.find(
+        (w) =>
+          (w.componentNames && w.componentNames.includes(dep.widgetName)) ||
+          (w.scope === dep.scope &&
+            (w.name === dep.packageName ||
+              w.packageId === `${dep.scope}/${dep.packageName}`)),
+      );
+
+      return {
+        scope: dep.scope || null,
+        packageName: dep.packageName,
+        widgetName: dep.widgetName,
+        component: dep.widgetName,
+        localVersion: dep.version,
+        packageDir: match?.path || null,
+        packageId: match?.packageId || null,
+        author: dep.author || "",
+        hasLocalPackage: !!match?.path,
+      };
+    });
+
+    // 5. Resolve theme (if workspace has one)
+    let theme = null;
+    if (workspace.themeKey) {
+      try {
+        const themeResult = themeController$2.listThemesForApplication(
+          null,
+          appId,
+        );
+        const themeData = themeResult?.themes?.[workspace.themeKey];
+        if (themeData) {
+          const registryMeta = themeData._registryMeta || {};
+          theme = {
+            themeKey: workspace.themeKey,
+            scope: registryMeta.scope || null,
+            name: registryMeta.name || workspace.themeKey,
+            localVersion: registryMeta.version || null,
+            hasRegistryMeta: !!themeData._registryMeta,
+          };
+        }
+      } catch (err) {
+        console.warn(
+          "[dashboardConfig] Could not resolve theme for dependencies:",
+          err.message,
+        );
+      }
+    }
+
+    return { success: true, widgets, theme };
+  } catch (error) {
+    console.error(
+      "[dashboardConfig] collectDashboardDependencies failed:",
+      error,
+    );
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Build an enriched dependency plan for batch-publishing a dashboard.
+ *
+ * Combines local dependency info (collectDashboardDependencies) with the
+ * registry's current state (POST /api/packages/resolve) so the batch-
+ * publish UI can decorate each widget + theme row with "already in
+ * registry at vX.Y.Z", "owned by you", "public/private", etc.
+ *
+ * Each returned widget has a `registry` sub-object that is either null
+ * (registry call failed or the package didn't exist) or the resolved
+ * entry from the API. Never throws on registry failures — the UI can
+ * still fall back to local-only info.
+ *
+ * @param {string} appId - Application identifier
+ * @param {number|string} workspaceId - Workspace ID
+ * @param {Object} widgetRegistry - WidgetRegistry instance
+ * @param {Object} options - { componentConfigs?: Object }
+ * @returns {Promise<Object>} { success, widgets, theme, registryError? }
+ */
+async function getDashboardPublishPlan$1(
+  appId,
+  workspaceId,
+  widgetRegistry = null,
+  options = {},
+) {
+  try {
+    const { resolvePackages } = registryApiController$2;
+
+    const deps = await collectDashboardDependencies$1(
+      appId,
+      workspaceId,
+      widgetRegistry,
+      options,
+    );
+    if (!deps.success) {
+      return { success: false, error: deps.error };
+    }
+
+    const refs = [];
+    for (const w of deps.widgets) {
+      if (w.scope && w.packageName) {
+        refs.push({ scope: w.scope, name: w.packageName });
+      }
+    }
+    if (deps.theme && deps.theme.scope && deps.theme.name) {
+      refs.push({ scope: deps.theme.scope, name: deps.theme.name });
+    }
+
+    let registryError = null;
+    const resolvedByKey = new Map();
+    if (refs.length > 0) {
+      const res = await resolvePackages(refs);
+      if (res.success && Array.isArray(res.resolved)) {
+        for (const r of res.resolved) {
+          resolvedByKey.set(`${r.scope}/${r.name}`, r);
+        }
+      } else {
+        registryError = res.error || "Registry lookup failed";
+      }
+    }
+
+    const widgets = deps.widgets.map((w) => {
+      const key =
+        w.scope && w.packageName ? `${w.scope}/${w.packageName}` : null;
+      return {
+        ...w,
+        registry: key ? resolvedByKey.get(key) || null : null,
+      };
+    });
+
+    let theme = null;
+    if (deps.theme) {
+      const key =
+        deps.theme.scope && deps.theme.name
+          ? `${deps.theme.scope}/${deps.theme.name}`
+          : null;
+      theme = {
+        ...deps.theme,
+        registry: key ? resolvedByKey.get(key) || null : null,
+      };
+    }
+
+    return {
+      success: true,
+      widgets,
+      theme,
+      ...(registryError ? { registryError } : {}),
+    };
+  } catch (error) {
+    console.error("[dashboardConfig] getDashboardPublishPlan failed:", error);
+    return { success: false, error: error.message };
+  }
+}
+
 /**
  * Prepare a dashboard for publishing to the registry.
  *
@@ -65179,6 +65469,8 @@ var dashboardConfigController$1 = {
   installDashboardFromRegistry: installDashboardFromRegistry$1,
   checkCompatibility: checkCompatibility$1,
   prepareDashboardForPublish: prepareDashboardForPublish$1,
+  collectDashboardDependencies: collectDashboardDependencies$1,
+  getDashboardPublishPlan: getDashboardPublishPlan$1,
   getDashboardPreview: getDashboardPreview$1,
   checkDashboardUpdatesForApp: checkDashboardUpdatesForApp$1,
   getProviderSetupManifest: getProviderSetupManifest$1,
@@ -71497,6 +71789,8 @@ const {
   installDashboardFromRegistry,
   checkCompatibility,
   prepareDashboardForPublish,
+  collectDashboardDependencies,
+  getDashboardPublishPlan,
   getDashboardPreview,
   checkDashboardUpdatesForApp,
   getProviderSetupManifest,
@@ -71593,6 +71887,8 @@ var controller = {
   installDashboardFromRegistry,
   checkCompatibility,
   prepareDashboardForPublish,
+  collectDashboardDependencies,
+  getDashboardPublishPlan,
   getDashboardPreview,
   checkDashboardUpdatesForApp,
   getProviderSetupManifest,
@@ -73128,6 +73424,8 @@ const {
   DASHBOARD_CONFIG_PROVIDER_SETUP,
   DASHBOARD_CONFIG_PUBLISH_PREVIEW,
   DASHBOARD_CONFIG_INSTALL_PROGRESS,
+  DASHBOARD_CONFIG_COLLECT_DEPENDENCIES,
+  DASHBOARD_CONFIG_PUBLISH_PLAN,
 } = events$8;
 
 const dashboardConfigApi$2 = {
@@ -73212,6 +73510,42 @@ const dashboardConfigApi$2 = {
       options,
     }),
 
+  /**
+   * Collect enriched widget + theme dependency info for a workspace.
+   * Used by the batch-publish dialog to build its dependency table.
+   *
+   * Returns local state only — the caller is responsible for enriching
+   * with registry state (ownership, latest published version, visibility).
+   *
+   * @param {string} appId - Application identifier
+   * @param {number|string} workspaceId - Workspace ID
+   * @param {Object} options - { componentConfigs?: Object }
+   * @returns {Promise<Object>} { success, widgets, theme }
+   */
+  collectDashboardDependencies: (appId, workspaceId, options = {}) =>
+    ipcRenderer$9.invoke(DASHBOARD_CONFIG_COLLECT_DEPENDENCIES, {
+      appId,
+      workspaceId,
+      options,
+    }),
+
+  /**
+   * Build an enriched dependency plan for batch-publishing a dashboard.
+   * Merges local dep info with registry state (existence, version,
+   * visibility, ownership) so the UI can decorate each row.
+   *
+   * @param {string} appId - Application identifier
+   * @param {number|string} workspaceId - Workspace ID
+   * @param {Object} options - { componentConfigs?: Object }
+   * @returns {Promise<Object>} { success, widgets, theme, registryError? }
+   */
+  getDashboardPublishPlan: (appId, workspaceId, options = {}) =>
+    ipcRenderer$9.invoke(DASHBOARD_CONFIG_PUBLISH_PLAN, {
+      appId,
+      workspaceId,
+      options,
+    }),
+
   /**
    * Get a preview of a dashboard package from the registry.
    * Returns structured preview data and compatibility report.