[Init] Initial commit - NetMesh terminal manager

electron/bridges/appIconManager.cjs

@@ -0,0 +1,197 @@
+"use strict";
+
+const path = require("node:path");
+const fs = require("node:fs");
+
+const VALID_VARIANTS = new Set([
+  "original",
+  "bright",
+  "dark",
+  "colorful",
+  "high-contrast",
+  "white-navy",
+  "white-sky",
+  "white-rose",
+  "white-emerald",
+  "white-amber",
+  "white-violet",
+  "rainbow",
+]);
+
+const DEFAULT_VARIANT = "original";
+
+let currentVariant = DEFAULT_VARIANT;
+let currentIconPath = null;
+let preferPublicSources = false;
+let useMacIconSources = false;
+
+function isValidAppIconVariant(variant) {
+  return typeof variant === "string" && VALID_VARIANTS.has(variant);
+}
+
+function normalizeAppIconVariant(variant) {
+  return isValidAppIconVariant(variant) ? variant : DEFAULT_VARIANT;
+}
+
+function isPackagedApp(app) {
+  try {
+    return app?.isPackaged === true;
+  } catch {
+    return false;
+  }
+}
+
+function pickExistingPath(candidates) {
+  return candidates.find((candidate) => fs.existsSync(candidate));
+}
+
+function buildSourceCandidates(appPath, relativeParts) {
+  const publicCandidate = path.join(appPath, "public", ...relativeParts);
+  const distCandidate = path.join(appPath, "dist", ...relativeParts);
+  return preferPublicSources
+    ? [publicCandidate, distCandidate]
+    : [distCandidate, publicCandidate];
+}
+
+function resolveOriginalIconPath(appPath) {
+  const primaryParts = useMacIconSources
+    ? ["icons", "variants", "macos", "original.png"]
+    : ["icons", "variants", "original.png"];
+  const candidates = useMacIconSources
+    ? buildSourceCandidates(appPath, primaryParts)
+    : [
+        ...buildSourceCandidates(appPath, primaryParts),
+        ...buildSourceCandidates(appPath, ["icon-win.png"]),
+        ...buildSourceCandidates(appPath, ["icon.png"]),
+      ];
+  const existing = pickExistingPath(candidates);
+  if (existing) return existing;
+  // Dev fallback: elf SVG.
+  const svgCandidate = path.join(appPath, "public", "senmesh-elf-logo.svg");
+  if (fs.existsSync(svgCandidate)) return svgCandidate;
+  return candidates[0];
+}
+
+function buildVariantSourceCandidates(appPath, fileName) {
+  const relativeParts = useMacIconSources
+    ? ["icons", "variants", "macos", fileName]
+    : ["icons", "variants", fileName];
+  return buildSourceCandidates(appPath, relativeParts);
+}
+
+function resolveVariantIconPath(variant, appPath) {
+  const normalized = normalizeAppIconVariant(variant);
+  if (normalized === "original") {
+    return resolveOriginalIconPath(appPath);
+  }
+
+  const fileName = `${normalized}.png`;
+  const candidates = buildVariantSourceCandidates(appPath, fileName);
+  const resolved = pickExistingPath(candidates);
+  if (resolved) return resolved;
+  return resolveOriginalIconPath(appPath);
+}
+
+function resolveStrictVariantIconPath(variant, appPath) {
+  const normalized = normalizeAppIconVariant(variant);
+  if (normalized === "original") {
+    return resolveOriginalIconPath(appPath);
+  }
+
+  const fileName = `${normalized}.png`;
+  const candidates = buildVariantSourceCandidates(appPath, fileName);
+  return pickExistingPath(candidates) || null;
+}
+
+function initializeAppIconManager(appPath, options = {}) {
+  preferPublicSources = options.preferPublic === true;
+  useMacIconSources = options.isMac === true;
+  currentVariant = DEFAULT_VARIANT;
+  currentIconPath = resolveVariantIconPath(currentVariant, appPath);
+  return currentIconPath;
+}
+
+function getAppIconPath(appPath) {
+  if (!currentIconPath) {
+    return initializeAppIconManager(appPath);
+  }
+  return currentIconPath;
+}
+
+function getAppIconVariant() {
+  return currentVariant;
+}
+
+function createNativeImage(nativeImage, iconPath) {
+  if (!nativeImage || !iconPath || !fs.existsSync(iconPath)) return null;
+  try {
+    // Read from disk so regenerated assets at the same path refresh immediately.
+    return nativeImage.createFromBuffer(fs.readFileSync(iconPath));
+  } catch {
+    try {
+      return nativeImage.createFromPath(iconPath);
+    } catch {
+      return null;
+    }
+  }
+}
+
+function applyIconToWindow(win, iconPath, nativeImage) {
+  if (!win || win.isDestroyed?.() || !iconPath || !win.setIcon) return;
+  try {
+    const image = createNativeImage(nativeImage, iconPath);
+    if (image) {
+      win.setIcon(image);
+      return;
+    }
+    win.setIcon(iconPath);
+  } catch {
+    // ignore
+  }
+}
+
+function applyAppIconVariant(variant, context) {
+  const { app, BrowserWindow, nativeImage, appPath, isMac } = context;
+  preferPublicSources = !isPackagedApp(app);
+  useMacIconSources = isMac === true;
+  const normalized = normalizeAppIconVariant(variant);
+  const iconPath = resolveStrictVariantIconPath(normalized, appPath);
+  if (!iconPath || !fs.existsSync(iconPath)) {
+    return false;
+  }
+
+  currentVariant = normalized;
+  currentIconPath = iconPath;
+
+  const windows = BrowserWindow?.getAllWindows?.() || [];
+  for (const win of windows) {
+    applyIconToWindow(win, iconPath, nativeImage);
+  }
+
+  if (isMac && app?.dock?.setIcon && nativeImage) {
+    try {
+      const dockImage = createNativeImage(nativeImage, iconPath);
+      if (dockImage) {
+        app.dock.setIcon(dockImage);
+      }
+    } catch {
+      // ignore
+    }
+  }
+
+  return true;
+}
+
+module.exports = {
+  DEFAULT_VARIANT,
+  VALID_VARIANTS,
+  isValidAppIconVariant,
+  normalizeAppIconVariant,
+  initializeAppIconManager,
+  getAppIconPath,
+  getAppIconVariant,
+  resolveVariantIconPath,
+  resolveStrictVariantIconPath,
+  applyAppIconVariant,
+  applyIconToWindow,
+};