@allior/wmake-cli 0.0.5 → 0.0.7

package/src/vite-config.ts

@@ -1,141 +1,152 @@
 import path from "node:path";
 import fs from "node:fs";
-import { PluginOption } from "vite";
+import type { AliasOptions, PluginOption } from "vite";
 
-export const CDN_BASE = "https://cdn.jsdelivr.net/npm";
-export const REACT_VER = "19.0.0";
-export const WMAKE_VER = "1.0.0";
+export const BASE_GLOBALS: Record<string, string> = {
+  react: "React",
+  "react-dom": "ReactDOM",
+  "react-dom/client": "ReactDOM",
+  "react/jsx-runtime": "React",
+};
 
-export const EXTERNAL_FOR_CDN = new Set([
-  "react",
-  "react/jsx-runtime",
-  "react-dom",
-  "react-dom/client",
-  "@allior/wmake-utils",
-  "@allior/wmake-utils/react",
-  "@allior/wmake-streamelements-events",
-  "@allior/wmake-streamelements-events/react",
-  "@allior/wmake-emotes/7tv",
-  "@allior/wmake-streamelements",
-]);
-
-const BOOTSTRAP_PLACEHOLDER_SRC = "__MAIN_SCRIPT_SRC__";
-const BOOTSTRAP_PLACEHOLDER_VER = "__DEFAULT_WMAKE_VER__";
-
-const bootstrapScript = `
-(function(){
-  var CDN_BASE='${CDN_BASE}';
-  var REACT_VER='${REACT_VER}';
-  var defaultVer='${BOOTSTRAP_PLACEHOLDER_VER}';
-  var mainScriptSrc='${BOOTSTRAP_PLACEHOLDER_SRC}';
-  function run(ver){
-    var v=ver||defaultVer;
-    var map={imports:{
-      'react':CDN_BASE+'/react@'+REACT_VER+'/+esm',
-      'react/jsx-runtime':CDN_BASE+'/react@'+REACT_VER+'/jsx-runtime.js',
-      'react-dom':CDN_BASE+'/react-dom@'+REACT_VER+'/+esm',
-      'react-dom/client':CDN_BASE+'/react-dom@'+REACT_VER+'/client.js',
-      '@allior/wmake-utils':CDN_BASE+'/@allior/wmake-utils@'+v+'/dist/root/index.js',
-      '@allior/wmake-utils/react':CDN_BASE+'/@allior/wmake-utils@'+v+'/dist/react/index.js',
-      '@allior/wmake-streamelements-events':CDN_BASE+'/@allior/wmake-streamelements-events@'+v+'/dist/root/index.js',
-      '@allior/wmake-streamelements-events/react':CDN_BASE+'/@allior/wmake-streamelements-events@'+v+'/dist/react/index.js',
-      '@allior/wmake-emotes/7tv':CDN_BASE+'/@allior/wmake-emotes@'+v+'/dist/7tv/index.js',
-      '@allior/wmake-streamelements':CDN_BASE+'/@allior/wmake-streamelements@'+v+'/dist/root/index.js'
-    }};
-    var s=document.createElement('script');
-    s.type='importmap';
-    s.textContent=JSON.stringify(map);
-    document.head.appendChild(s);
-    var m=document.createElement('script');
-    m.type='module';
-    m.src=mainScriptSrc;
-    document.body.appendChild(m);
+/** Translates package name to global window variable name */
+export function getWmakeGlobals(cwd: string = process.cwd()): Record<string, string> {
+  const deps = getWmakeDeps(cwd);
+  const res: Record<string, string> = { ...BASE_GLOBALS };
+  for (const pkg of deps) {
+    const name = pkg.replace("@allior/wmake-", "");
+    const pascalName = name
+      .split("-")
+      .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+      .join("");
+    res[pkg] = `Wmake${pascalName}`;
+    res[`${pkg}/react`] = `Wmake${pascalName}React`;
   }
-  if(typeof window.addEventListener==='function'){
-    window.addEventListener('onWidgetLoad',function(obj){
-      var fd=obj.detail&&obj.detail.fieldData;
-      run(fd&&fd.wmakeVersion);
-    });
-    setTimeout(function(){if(!document.querySelector('script[type="importmap"]'))run(defaultVer);},100);
-  }else{run(defaultVer);}
-})();
-`;
-
-export function wmakeImportMapPlugin(): PluginOption {
-  const imports: Record<string, string> = {
-    react: `${CDN_BASE}/react@${REACT_VER}/+esm`,
-    "react/jsx-runtime": `${CDN_BASE}/react@${REACT_VER}/jsx-runtime.js`,
-    "react-dom": `${CDN_BASE}/react-dom@${REACT_VER}/+esm`,
-    "react-dom/client": `${CDN_BASE}/react-dom@${REACT_VER}/client.js`,
-    "@allior/wmake-utils": `${CDN_BASE}/@allior/wmake-utils@${WMAKE_VER}/dist/root/index.js`,
-    "@allior/wmake-utils/react": `${CDN_BASE}/@allior/wmake-utils@${WMAKE_VER}/dist/react/index.js`,
-    "@allior/wmake-streamelements-events": `${CDN_BASE}/@allior/wmake-streamelements-events@${WMAKE_VER}/dist/root/index.js`,
-    "@allior/wmake-streamelements-events/react": `${CDN_BASE}/@allior/wmake-streamelements-events@${WMAKE_VER}/dist/react/index.js`,
-    "@allior/wmake-emotes/7tv": `${CDN_BASE}/@allior/wmake-emotes@${WMAKE_VER}/dist/7tv/index.js`,
-    "@allior/wmake-streamelements": `${CDN_BASE}/@allior/wmake-streamelements@${WMAKE_VER}/dist/root/index.js`,
-  };
+  return res;
+}
 
-  const importMap = { imports };
-  const staticImportMapScript = `<script type="importmap">${JSON.stringify(importMap)}</script>`;
+/** Translates package name to global window variable name (without React/ReactDOM) */
+export function getRawWmakeGlobals(cwd: string = process.cwd()): Record<string, string> {
+  const deps = getWmakeDeps(cwd);
+  const res: Record<string, string> = {};
+  for (const pkg of deps) {
+    const name = pkg.replace("@allior/wmake-", "");
+    const pascalName = name
+      .split("-")
+      .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+      .join("");
+    res[pkg] = `Wmake${pascalName}`;
+    res[`${pkg}/react`] = `Wmake${pascalName}React`;
+  }
+  return res;
+}
 
-  return {
-    name: "importmap-cdn",
-    transformIndexHtml: {
-      order: "post" as const,
-      handler(html: string, ctx: { server?: unknown }) {
-        const isBuild = !ctx.server;
-        if (isBuild) {
-          const script = "<script>\n" + bootstrapScript.trim() + "\n</script>";
-          return html.replace(/(<head[^>]*>)/i, "$1\n" + script);
+/** Generates Vite aliases for workspace development */
+export function getWmakeAliases(root: string): AliasOptions {
+  const dirs = fs.readdirSync(root, { withFileTypes: true });
+  const aliases: any = {};
+  for (const dir of dirs) {
+    if (dir.isDirectory()) {
+      const pkgPath = path.join(root, dir.name, "package.json");
+      if (fs.existsSync(pkgPath)) {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+        if (pkg.name && pkg.name.startsWith("@allior/wmake-")) {
+          aliases[pkg.name] = path.resolve(root, dir.name, "dist/root/index.js");
+          aliases[`${pkg.name}/react`] = path.resolve(root, dir.name, "dist/react/index.js");
         }
-        return staticImportMapScript + "\n" + html;
-      },
-    },
-    writeBundle(options: { dir?: string }) {
-      const outDir = options.dir ?? "dist";
-      const htmlPath = path.join(outDir, "index.html");
-      if (!fs.existsSync(htmlPath)) return;
+      }
+    }
+  }
+  return aliases;
+}
 
-      let html = fs.readFileSync(htmlPath, "utf-8");
-      const scriptTagMatch = html.match(
-        /<script(?=[^>]*type=["']module["'])(?=[^>]*src=)[^>]*src=["']([^"']+)["'][^>]*>\s*<\/script>/,
-      );
+/** Detects @allior/wmake-* dependencies in package.json and sorts them by hierarchy */
+export function getWmakeDeps(cwd: string = process.cwd()): string[] {
+  const pkgPath = path.join(cwd, "package.json");
+  if (!fs.existsSync(pkgPath)) return [];
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+  const deps = Object.keys(pkg.dependencies || {}).filter((d) => d.startsWith("@allior/wmake-"));
+  
+  return sortWmakeDeps(deps);
+}
+
+/** Detects dependencies and their current versions from package.json */
+export function getWmakeDepsWithVersions(cwd: string = process.cwd()): Record<string, string> {
+  const pkgPath = path.join(cwd, "package.json");
+  if (!fs.existsSync(pkgPath)) return {};
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+  const res: Record<string, string> = {};
+  const deps = pkg.dependencies || {};
+  for (const d in deps) {
+    if (d.startsWith("@allior/wmake-")) {
+       res[d] = deps[d].replace(/[\^~]/, "");
+    }
+  }
+  return res;
+}
 
-      if (!scriptTagMatch) return;
-      const mainScriptSrc = scriptTagMatch[1];
+/** Checks if a dependency should be external in CDN mode */
+export function isExternalForCdn(id: string, cwd: string = process.cwd()): boolean {
+  const normId = id.replace(/\\/g, "/");
+  if (Object.keys(BASE_GLOBALS).some(base => id === base || id.startsWith(base + "/"))) return true;
+  if (id.startsWith("@allior/wmake-") && id !== "@allior/wmake-cli") return true;
+  
+  const WMAKE_LIBS = ["utils", "streamelements", "streamelements-events", "emotes"];
+  for (const lib of WMAKE_LIBS) {
+    if (normId.includes(`/${lib}/dist/`)) return true;
+  }
+  
+  if (normId.includes("/@allior/wmake-") || normId.includes("/wmake-")) {
+    if (!normId.includes("/wmake-cli/")) return true;
+  }
+  return false;
+}
 
-      html = html
-        .replace(BOOTSTRAP_PLACEHOLDER_VER, WMAKE_VER)
-        .replace(BOOTSTRAP_PLACEHOLDER_SRC, mainScriptSrc)
-        .replace(scriptTagMatch[0], "");
+/** Legacy helper for external dependencies */
+export function getExternalForCdn(cwd: string = process.cwd()): string[] {
+  const deps = getWmakeDeps(cwd);
+  const res = [...Object.keys(BASE_GLOBALS)];
+  for (const pkg of deps) {
+    res.push(pkg);
+    res.push(`${pkg}/react`);
+  }
+  return res;
+}
 
-      fs.writeFileSync(htmlPath, html);
-    },
-  };
+/** Provides list of dependencies for pre-optimization */
+export function getWmakeOptimizeDeps(cwd: string = process.cwd()): string[] {
+  const deps = getWmakeDeps(cwd);
+  return [...deps, ...deps.map((d) => `${d}/react`)];
 }
 
-export function getWmakeAliases(root: string) {
+/** Vite plugin to inject global window shims for widget development */
+export function wmakeScriptCdnPlugin(options: { useCdn?: boolean } = {}): PluginOption {
+  const { useCdn = true } = options;
+  if (!useCdn) return { name: "wmake-script-cdn-plugin" };
+
   return {
-    "@allior/wmake-streamelements-events/react": path.join(root, "streamelements-events/dist/react/index.js"),
-    "@allior/wmake-streamelements-events": path.join(root, "streamelements-events/dist/root/index.js"),
-    "@allior/wmake-utils/react": path.join(root, "utils/dist/react/index.js"),
-    "@allior/wmake-utils": path.join(root, "utils/dist/root/index.js"),
-    "@allior/wmake-emotes/react": path.join(root, "emotes/dist/react/index.js"),
-    "@allior/wmake-emotes/7tv": path.join(root, "emotes/dist/7tv/index.js"),
-    "@allior/wmake-emotes": path.join(root, "emotes/dist/root/index.js"),
-    "@allior/wmake-streamelements/react": path.join(root, "streamelements/dist/react/index.js"),
-    "@allior/wmake-streamelements/fields": path.join(root, "streamelements/dist/fields/index.js"),
-    "@allior/wmake-streamelements": path.join(root, "streamelements/dist/root/index.js"),
+    name: "wmake-script-cdn-plugin",
+    transformIndexHtml(html: string) {
+      return html.replace(
+        "</head>",
+        `<script src="https://cdn.jsdelivr.net/bundle/npm/react@18.2.0/umd/react.production.min.js"></script>
+        <script src="https://cdn.jsdelivr.net/bundle/npm/react-dom@18.2.0/umd/react-dom.production.min.js"></script>
+        </head>`
+      );
+    },
   };
 }
 
-export function getWmakeOptimizeDeps() {
-  return {
-    include: [
-      "@allior/wmake-streamelements-events",
-      "@allior/wmake-utils",
-      "@allior/wmake-emotes/7tv",
-      "@allior/wmake-streamelements",
-    ],
-  };
+/** Sorts dependencies in correct loading order based on internals */
+export function sortWmakeDeps(deps: string[]): string[] {
+    const order = ["utils", "streamelements-events", "emotes", "streamelements"];
+    return [...deps].sort((a, b) => {
+        const aName = a.replace("@allior/wmake-", "");
+        const bName = b.replace("@allior/wmake-", "");
+        let aIdx = order.indexOf(aName);
+        let bIdx = order.indexOf(bName);
+        if (aIdx === -1) aIdx = 999;
+        if (bIdx === -1) bIdx = 999;
+        return aIdx - bIdx;
+    });
 }

package/src/widget.ts

@@ -1,179 +1,155 @@
-/**
- * Сборка виджета: html.txt, js.txt, css.txt, fields.txt, data.txt и архив .zip.
- * Все пути относительно текущей папки (откуда вызывается скрипт).
- */
-import fs from "node:fs";
-import path from "node:path";
-import { spawnSync } from "node:child_process";
-import {
-  runGenerateFields,
-  runGenerateFieldsFromModule,
-} from "./generate-fields.js";
-
-/** Текущая папка (каталог проекта виджета). */
-function getProjectDir(): string {
-  return path.resolve(process.cwd());
-}
-
-function run(
-  cmd: string,
-  args: string[],
-  cwd: string,
-  env?: NodeJS.ProcessEnv,
-): boolean {
-  const r = spawnSync(cmd, args, {
-    cwd,
-    stdio: "inherit",
-    shell: true,
-    env: { ...process.env, ...env },
-  });
-  return r.status === 0;
-}
-
-function getPackageManager(): string {
-  const userAgent = process.env.npm_config_user_agent || "";
-  if (userAgent.includes("bun")) return "bun";
-  if (userAgent.includes("pnpm")) return "pnpm";
-  if (userAgent.includes("yarn")) return "yarn";
-  return "npm";
-}
-
-export async function buildWidget(options: { full?: boolean }): Promise<void> {
-  const projectDir = getProjectDir();
-  const distDir = path.join(projectDir, "dist");
-  const buildDir = path.resolve(projectDir, process.env.BUILD_DIR ?? "build");
-  const archiveName = process.env.ARCHIVE_NAME ?? "widget";
-
-  console.log("Generating fields...");
-  const basePath = path.join(projectDir, "fields.base.json");
-  const fieldsTsPath = path.join(projectDir, "fields.ts");
-  if (fs.existsSync(basePath)) {
-    const mod =
-      (await import("@allior/wmake-streamelements-events")) as unknown as {
-        testMessages: Record<string, unknown>;
-        testAlerts: Record<string, unknown>;
-      };
-    runGenerateFields({
-      fieldsDir: projectDir,
-      testMessages: mod.testMessages,
-      testAlerts: mod.testAlerts,
-    });
-  } else if (fs.existsSync(fieldsTsPath)) {
-    runGenerateFieldsFromModule(fieldsTsPath);
-  } else {
-    console.log(
-      "No fields.base.json or fields.ts found, skipping fields generation",
-    );
-  }
-  console.log("Building...");
-  const buildEnv = options.full ? { BUILD_FULL: "1" } : {};
-  if (!run(getPackageManager(), ["run", "build"], projectDir, buildEnv)) {
-    throw new Error("Build failed.");
-  }
-
-  if (!fs.existsSync(distDir)) {
-    throw new Error("dist not found. Run build first.");
-  }
-
-  fs.mkdirSync(buildDir, { recursive: true });
-
-  const html = fs.readFileSync(path.join(distDir, "index.html"), "utf-8");
-  fs.writeFileSync(path.join(buildDir, "html.txt"), html);
-
-  const assetsDir = path.join(distDir, "assets");
-  const findFiles = (dir: string, ext: string): string[] => {
-    const found: string[] = [];
-    const walk = (d: string) => {
-      if (!fs.existsSync(d)) return;
-      for (const e of fs.readdirSync(d)) {
-        const full = path.join(d, e);
-        const stat = fs.statSync(full);
-        if (stat.isDirectory()) walk(full);
-        else if (e.endsWith(ext)) found.push(full);
-      }
-    };
-    walk(dir);
-    return found;
-  };
-  const jsFiles = findFiles(assetsDir, ".js");
-  const cssFiles = findFiles(assetsDir, ".css");
-
-  if (jsFiles.length === 0 || cssFiles.length === 0) {
-    throw new Error("Expected .js and .css in dist/assets");
-  }
-
-  fs.writeFileSync(
-    path.join(buildDir, "js.txt"),
-    fs.readFileSync(jsFiles[0], "utf-8"),
-  );
-  fs.writeFileSync(
-    path.join(buildDir, "css.txt"),
-    fs.readFileSync(cssFiles[0], "utf-8"),
-  );
-
-  const fieldsJsonPath = path.join(projectDir, "fields.json");
-  if (fs.existsSync(fieldsJsonPath)) {
-    fs.copyFileSync(fieldsJsonPath, path.join(buildDir, "fields.txt"));
-  }
-
-  const pkgPath = path.join(projectDir, "package.json");
-  const wmakeVersion =
-    fs.existsSync(pkgPath) &&
-    (() => {
-      try {
-        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-        return typeof pkg.version === "string" ? pkg.version : undefined;
-      } catch {
-        return undefined;
-      }
-    })();
-  const dataPath = path.join(projectDir, "data.json");
-  const data = fs.existsSync(dataPath)
-    ? JSON.parse(fs.readFileSync(dataPath, "utf-8"))
-    : {};
-  if (wmakeVersion) {
-    data.wmakeVersion = wmakeVersion;
-  }
-  fs.writeFileSync(
-    path.join(buildDir, "data.txt"),
-    JSON.stringify(data, null, 2),
-  );
-
-  console.log(
-    "Widget files:",
-    path.join(buildDir, "html.txt"),
-    "js.txt, css.txt, fields.txt, data.txt",
-  );
-
-  const zipPath = path.join(distDir, `${archiveName}.zip`);
-  const zip = spawnSync("zip", ["-r", zipPath, "."], {
-    cwd: buildDir,
-    stdio: "pipe",
-  });
-  if (zip.status === 0) {
-    console.log("Archive:", zipPath);
-    return;
-  }
-  try {
-    const AdmZip = (await import("adm-zip")).default;
-    const archive = new AdmZip();
-    for (const f of [
-      "html.txt",
-      "js.txt",
-      "css.txt",
-      "fields.txt",
-      "data.txt",
-    ]) {
-      const fp = path.join(buildDir, f);
-      if (fs.existsSync(fp)) archive.addLocalFile(fp, "", f);
-    }
-    archive.writeZip(zipPath);
-    console.log("Archive (adm-zip):", zipPath);
-  } catch (e) {
-    console.error("zip failed and adm-zip fallback error:", e);
-    console.error(
-      "Install 'zip' (e.g. apk add zip) or ensure adm-zip is installed.",
-    );
-    throw e;
-  }
-}
+import fs from "node:fs";
+import path from "node:path";
+import { build } from "vite";
+import { getRawWmakeGlobals, getWmakeDeps, getWmakeDepsWithVersions } from "./vite-config.js";
+import { generateMergedFields, GenerateFieldsOptions } from "./generate-fields.js";
+import admZip from "adm-zip";
+
+export interface BuildWidgetOptions extends GenerateFieldsOptions {
+  full?: boolean;
+  seDir?: string;
+}
+
+/** Builds project for StreamElements widget using CDN mode */
+export async function buildWidget(options: BuildWidgetOptions = {}) {
+  const { full = false, seDir } = options;
+  const projectDir = process.cwd();
+  
+  await build({
+    configFile: path.resolve(projectDir, "vite.widget.config.ts"),
+    build: {
+      emptyOutDir: true,
+      minify: true,
+    }
+  });
+
+  const distDir = path.join(projectDir, "dist");
+  const buildDir = path.join(projectDir, "build");
+  if (!fs.existsSync(buildDir)) fs.mkdirSync(buildDir, { recursive: true });
+
+  let html = fs.readFileSync(path.join(distDir, "index.html"), "utf-8");
+  let css = fs.readFileSync(path.join(distDir, "assets/style.css"), "utf-8");
+  let js = fs.readFileSync(path.join(distDir, "assets/index.js"), "utf-8");
+
+  if (!full) {
+    const rawGlobals = getRawWmakeGlobals(projectDir);
+    const requiredGlobals = JSON.stringify(Array.from(new Set(Object.values(rawGlobals))));
+    const wmakeDepsWithVersions = getWmakeDepsWithVersions(projectDir);
+    const wmakeDeps = getWmakeDeps(projectDir);
+    const globalsInOrder = Array.from(new Set(Object.values(rawGlobals)));
+
+    const loaderJs = `(function() {
+  var req = ${requiredGlobals};
+  var wmakeDeps = ${JSON.stringify(wmakeDeps)};
+  var wmakeFallbacks = ${JSON.stringify(wmakeDepsWithVersions)};
+  
+  for (var i = 0; i < req.length; i++) {
+    if (!window.hasOwnProperty(req[i])) window[req[i]] = undefined;
+  }
+
+  function check() {
+    var missing = [];
+    for (var i = 0; i < req.length; i++) {
+        if (!window[req[i]]) { missing.push(req[i]); }
+    }
+    if (missing.length === 0) {
+      console.log("[WMAKE] All context dependencies initialized");
+      var run = function() {
+        ${globalsInOrder.map(g => `var ${g} = window.${g};`).join(" ")}
+        try {
+          ${js.trim()}
+        } catch (e) {
+          console.error("[WMAKE] Runtime error:", e);
+        }
+      };
+      run();
+    } else {
+      setTimeout(check, 100);
+    }
+  }
+
+  function injectScripts(fieldData) {
+    var CDN_BASE = "https://cdn.jsdelivr.net/npm";
+    var head = document.getElementsByTagName("head")[0];
+    
+    var queue = [];
+    for (var i = 0; i < wmakeDeps.length; i++) {
+        queue.push({ pkg: wmakeDeps[i], entry: "root" });
+        queue.push({ pkg: wmakeDeps[i], entry: "react" });
+    }
+
+    function loadNext(qIdx) {
+      if (qIdx >= queue.length) {
+        check();
+        return;
+      }
+      
+      var item = queue[qIdx];
+      var pkg = item.pkg;
+      var name = pkg.replace("@allior/wmake-", "");
+      var pascalName = name.split("-").map(function(w) { return w.charAt(0).toUpperCase() + w.slice(1); }).join("");
+      var fieldKey = "wmake" + pascalName + "Version";
+      var version = (fieldData && fieldData[fieldKey]) || wmakeFallbacks[pkg] || "latest";
+      
+      var src = CDN_BASE + "/" + pkg + "@" + version + "/dist/" + item.entry + "/index.iife.js";
+      var script = document.createElement("script");
+      script.src = src;
+      script.onload = function() { loadNext(qIdx + 1); };
+      script.onerror = function() { loadNext(qIdx + 1); };
+      head.appendChild(script);
+    }
+
+    loadNext(0);
+  }
+
+  window.addEventListener("onWidgetLoad", function(obj) {
+    var detail = obj.detail;
+    window.__WMAKE_INIT_DATA__ = detail;
+    injectScripts(detail && detail.fieldData);
+  });
+})();`;
+
+    js = loaderJs;
+  }
+
+  fs.writeFileSync(path.join(buildDir, "html.txt"), html, "utf-8");
+  fs.writeFileSync(path.join(buildDir, "css.txt"), css, "utf-8");
+  fs.writeFileSync(path.join(buildDir, "js.txt"), js, "utf-8");
+
+  const fields = generateMergedFields(projectDir, seDir, {
+      skipWmakeVersions: options.skipWmakeVersions,
+      skipTestAlerts: options.skipTestAlerts,
+      skipTestMessages: options.skipTestMessages,
+  });
+  fs.writeFileSync(path.join(buildDir, "fields.txt"), JSON.stringify(fields, null, 2), "utf-8");
+
+  const dataPath = seDir 
+    ? path.join(projectDir, seDir, "data.json")
+    : path.join(projectDir, "data.json");
+    
+  let dataFilename = "";
+  if (fs.existsSync(dataPath)) {
+    dataFilename = "data.txt";
+    fs.writeFileSync(path.join(buildDir, dataFilename), fs.readFileSync(dataPath, "utf-8"), "utf-8");
+  }
+
+  const iniContent = `[HTML]
+path = "html.txt"
+
+[CSS]
+path = "css.txt"
+
+[JS]
+path = "js.txt"
+
+[FIELDS]
+path = "fields.txt"
+${dataFilename ? `\n[DATA]\npath = "${dataFilename}"` : ""}
+`;
+  fs.writeFileSync(path.join(buildDir, "widget.ini"), iniContent, "utf-8");
+
+  const zip = new admZip();
+  zip.addLocalFolder(buildDir);
+  const zipPath = path.join(distDir, "widget.zip");
+  zip.writeZip(zipPath);
+}