@trops/dash-core 0.1.445 → 0.1.447

package/dist/electron/index.js

@@ -27191,6 +27191,10 @@ var widgetRegistry$1 = {exports: {}};
 
 var dynamicWidgetLoader$3 = {exports: {}};
 
+function commonjsRequire(path) {
+	throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
+}
+
 /**
  * Widget Compiler
  *
@@ -27204,6 +27208,90 @@ var dynamicWidgetLoader$3 = {exports: {}};
 const fs$7 = require$$0$2;
 const path$b = require$$1$2;
 
+/**
+ * Structured error thrown by compileWidget() when the underlying
+ * esbuild spawn fails (typically ENOENT — the native helper binary is
+ * missing on this arch in a packaged build). The renderer surfaces
+ * `.code` + `.diagnostics` to give the user something actionable
+ * instead of a raw "spawn ENOENT".
+ */
+class WidgetCompileError extends Error {
+  constructor(message, code, diagnostics) {
+    super(message);
+    this.name = "WidgetCompileError";
+    this.code = code;
+    this.diagnostics = diagnostics;
+  }
+}
+
+/**
+ * Probe the on-disk state of esbuild + its arch-specific native helper.
+ * Returns a flat object suitable for logging/UI display. Never throws.
+ */
+function getEsbuildDiagnostics() {
+  const diagnostics = {
+    platform: process.platform,
+    arch: process.arch,
+    esbuildVersion: null,
+    esbuildPackageDir: null,
+    archPackage: `@esbuild/${process.platform}-${process.arch}`,
+    nativeBinaryPath: null,
+    nativeBinaryExists: false,
+  };
+
+  try {
+    const pkgJsonPath = require.resolve("esbuild/package.json");
+    diagnostics.esbuildPackageDir = path$b.dirname(pkgJsonPath);
+    diagnostics.esbuildVersion = commonjsRequire(pkgJsonPath).version;
+  } catch (err) {
+    diagnostics.esbuildResolveError = err.message;
+  }
+
+  try {
+    const archPkgJson = require.resolve(
+      `${diagnostics.archPackage}/package.json`,
+    );
+    const archDir = path$b.dirname(archPkgJson);
+    // esbuild's native binary on macOS/Linux is bin/esbuild;
+    // on Windows it's esbuild.exe at the package root.
+    const candidate =
+      process.platform === "win32"
+        ? path$b.join(archDir, "esbuild.exe")
+        : path$b.join(archDir, "bin", "esbuild");
+    diagnostics.nativeBinaryPath = candidate;
+    diagnostics.nativeBinaryExists = fs$7.existsSync(candidate);
+  } catch (err) {
+    diagnostics.archResolveError = err.message;
+  }
+
+  return diagnostics;
+}
+
+/**
+ * Quick liveness probe for the widget compiler. Runs a no-op
+ * `esbuild.transform("")` so any missing-native-binary failure surfaces
+ * before the user tries to compile a real widget. Returns
+ * `{ ok, error?, code?, diagnostics }` — never throws.
+ */
+async function healthCheck() {
+  const diagnostics = getEsbuildDiagnostics();
+  try {
+    const esbuild = require("esbuild");
+    await esbuild.transform("", { loader: "js" });
+    return { ok: true, diagnostics };
+  } catch (err) {
+    return {
+      ok: false,
+      error: err.message,
+      code:
+        err.code === "ENOENT" || /spawn|ENOENT/i.test(err.message || "")
+          ? "ESBUILD_SPAWN_FAILED"
+          : "ESBUILD_UNAVAILABLE",
+      diagnostics,
+    };
+  }
+}
+
 /**
  * Find the widgets/ directory, handling nested ZIP extraction.
  *
@@ -27385,6 +27473,18 @@ async function compileWidget$1(widgetPath) {
       `[WidgetCompiler] Compilation failed for ${widgetPath}:`,
       error,
     );
+    // ENOENT on the esbuild path means the native helper binary
+    // wasn't found — usually a packaging issue (wrong arch in the
+    // universal asar, asar-unpacked glob missing the arch package,
+    // dev install never ran for the runtime arch). Wrap with
+    // diagnostics so the UI can show something useful.
+    if (error.code === "ENOENT" || /spawn|ENOENT/i.test(error.message || "")) {
+      throw new WidgetCompileError(
+        `Widget compiler unavailable: ${error.message}`,
+        "ESBUILD_SPAWN_FAILED",
+        getEsbuildDiagnostics(),
+      );
+    }
     throw error;
   } finally {
     // Clean up temporary entry file
@@ -27402,7 +27502,13 @@ async function compileWidget$1(widgetPath) {
   }
 }
 
-var widgetCompiler$1 = { compileWidget: compileWidget$1, findWidgetsDir: findWidgetsDir$2 };
+var widgetCompiler$1 = {
+  compileWidget: compileWidget$1,
+  findWidgetsDir: findWidgetsDir$2,
+  healthCheck,
+  getEsbuildDiagnostics,
+  WidgetCompileError,
+};
 
 /**
  * Dynamic Widget Loader
@@ -74039,6 +74145,99 @@ function findWidget(registry, packageId) {
   return null;
 }
 
+/**
+ * Dedup duplicate `{type: "..."}` entries inside a `providers: [...]`
+ * array literal in a .dash.js source string. Mirrors the regex used at
+ * AI-build write time in dash-electron's WidgetBuilderModal so old
+ * AI-generated widgets get healed before publish (the runtime parse
+ * dedup keeps consumers correct, but the raw .dash.js text on disk
+ * stays dirty unless we rewrite it).
+ *
+ * Conservative: only handles a single-level array of object literals.
+ * More exotic forms fall through unchanged and the runtime dedup picks
+ * up the slack.
+ *
+ * @param {string} source
+ * @returns {{ source: string, dropped: number }}
+ */
+function dedupProvidersInDashSource(source) {
+  if (!source) return { source, dropped: 0 };
+  let totalDropped = 0;
+  const cleaned = source.replace(
+    /(providers\s*:\s*\[)([^[\]]*?)(\])/,
+    (match, head, body, tail) => {
+      const chunks = body
+        .split(/(\{[^{}]*\})/)
+        .filter((s) => s && /\S/.test(s));
+      const seenTypes = new Set();
+      const kept = [];
+      let dropped = 0;
+      for (const chunk of chunks) {
+        if (!chunk.startsWith("{")) continue;
+        const typeMatch = chunk.match(/type\s*:\s*["']([^"']+)["']/);
+        if (!typeMatch) {
+          kept.push(chunk.trim());
+          continue;
+        }
+        const t = typeMatch[1];
+        if (seenTypes.has(t)) {
+          dropped++;
+          continue;
+        }
+        seenTypes.add(t);
+        kept.push(chunk.trim());
+      }
+      if (dropped === 0) return match;
+      totalDropped += dropped;
+      return `${head}${kept.join(", ")}${tail}`;
+    },
+  );
+  return { source: cleaned, dropped: totalDropped };
+}
+
+/**
+ * Walk a widget package's `.dash.js` files and rewrite any with
+ * duplicate provider-type entries. Returns counts so the publish
+ * caller can log what was healed. Errors are non-fatal — a single
+ * unparseable .dash.js shouldn't block the whole publish.
+ */
+function cleanupProvidersInWidgetPackage(widgetPath) {
+  const summary = { filesScanned: 0, filesRewritten: 0, totalDropped: 0 };
+  try {
+    const widgetsDir =
+      findWidgetsDir(widgetPath) || path.join(widgetPath, "widgets");
+    if (!fs.existsSync(widgetsDir)) return summary;
+    for (const file of fs.readdirSync(widgetsDir)) {
+      if (!file.endsWith(".dash.js")) continue;
+      const filePath = path.join(widgetsDir, file);
+      try {
+        const original = fs.readFileSync(filePath, "utf8");
+        summary.filesScanned++;
+        const { source: deduped, dropped } =
+          dedupProvidersInDashSource(original);
+        if (dropped > 0 && deduped !== original) {
+          fs.writeFileSync(filePath, deduped, "utf8");
+          summary.filesRewritten++;
+          summary.totalDropped += dropped;
+          console.log(
+            `[widgetRegistry] Cleaned ${dropped} duplicate provider(s) from ${file}`,
+          );
+        }
+      } catch (err) {
+        console.warn(
+          `[widgetRegistry] cleanupProviders skip ${file}: ${err.message}`,
+        );
+      }
+    }
+  } catch (err) {
+    console.warn(
+      "[widgetRegistry] cleanupProvidersInWidgetPackage failed:",
+      err.message,
+    );
+  }
+  return summary;
+}
+
 /**
  * Scan a widget package directory for `.dash.js` component configs and
  * return the parsed configs. Used when the widget registry's cached
@@ -74381,6 +74580,21 @@ async function prepareWidgetForPublish$1(appId, packageId, options = {}) {
       }
     }
 
+    // 5b. Heal `.dash.js` source files that have duplicate
+    //     provider-type entries before we read configs / build the
+    //     manifest / zip. AI-generated configs occasionally double a
+    //     `{type:"..."}` entry; the runtime dedup makes it invisible
+    //     on the publisher's machine, but we don't want the dirty raw
+    //     text shipping to the registry. Mirrors the write-time dedup
+    //     in dash-electron's WidgetBuilderModal so older widgets
+    //     authored before that fix landed get cleaned at publish.
+    const providerCleanupSummary = cleanupProvidersInWidgetPackage(widget.path);
+    if (providerCleanupSummary.filesRewritten > 0) {
+      console.log(
+        `[widgetRegistry] Provider cleanup: rewrote ${providerCleanupSummary.filesRewritten} file(s), removed ${providerCleanupSummary.totalDropped} duplicate(s)`,
+      );
+    }
+
     // 6. Build manifest using the widget's component configs. The
     //    registry cache may be missing widgets (orphaned / locally-
     //    registered packages), so fall back to scanning the package's