@allior/wmake-cli 0.0.6 → 0.0.7

package/dist/widget.js

@@ -1,182 +1,138 @@
-/**
- * Сборка виджета: 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() {
-    return path.resolve(process.cwd());
-}
-function run(cmd, args, cwd, env) {
-    const r = spawnSync(cmd, args, {
-        cwd,
-        stdio: "inherit",
-        shell: true,
-        env: { ...process.env, ...env },
+import { build } from "vite";
+import { getRawWmakeGlobals, getWmakeDeps, getWmakeDepsWithVersions } from "./vite-config.js";
+import { generateMergedFields } from "./generate-fields.js";
+import admZip from "adm-zip";
+/** Builds project for StreamElements widget using CDN mode */
+export async function buildWidget(options = {}) {
+    const { full = false, seDir } = options;
+    const projectDir = process.cwd();
+    await build({
+        configFile: path.resolve(projectDir, "vite.widget.config.ts"),
+        build: {
+            emptyOutDir: true,
+            minify: true,
+        }
     });
-    return r.status === 0;
-}
-function getPackageManager() {
-    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) {
-    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"));
-        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, ext) => {
-        const found = [];
-        const walk = (d) => {
-            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");
-    }
-    let finalJs = fs.readFileSync(jsFiles[0], "utf-8");
-    // Если мы НЕ в FULL режиме, оборачиваем в проверку готовности глобалов
-    if (!options.full) {
-        const { getRawWmakeGlobals } = await import("./vite-config.js");
+    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))));
-        finalJs = `(function() {
-  var req = ${requiredGlobals};
-  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 dependencies confirmed: " + req.join(", "));
-      var run = function() {
-        // Принудительно гарантируем наличие переменных в глобальной области
-        ${Array.from(new Set(Object.values(rawGlobals))).map(g => `if (!window.${g}) window.${g} = undefined; var ${g} = window.${g};`).join(" ")}
-        try {
-          ${finalJs}
-        } catch (e) {
-          console.error("[WMAKE] Runtime error during widget execution:", e);
-        }
-      };
-      run();
-    } else {
-      if (window.__WMAKE_LOG_MISSING !== missing.join(",")) {
-         console.warn("[WMAKE] Waiting for dependencies: " + missing.join(", "));
-         window.__WMAKE_LOG_MISSING = missing.join(",");
-      }
-      setTimeout(check, 100);
-    }
-  }
-  console.log("[WMAKE] Initializing dependency check...");
-  check();
-})();`;
+        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]); }
     }
-    fs.writeFileSync(path.join(buildDir, "js.txt"), finalJs);
-    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"));
+    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);
     }
-    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;
+  }
+
+  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" });
     }
-    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);
+
+    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);
     }
-    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);
+
+    loadNext(0);
+  }
+
+  window.addEventListener("onWidgetLoad", function(obj) {
+    var detail = obj.detail;
+    window.__WMAKE_INIT_DATA__ = detail;
+    injectScripts(detail && detail.fieldData);
+  });
+})();`;
+        js = loaderJs;
     }
-    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;
+    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);
 }

package/package.json

@@ -1,13 +1,12 @@
 {
   "name": "@allior/wmake-cli",
-  "version": "0.0.6",
-  "description": "Streamiby/wmake CLI: build widgets, base64 encode assets, generate fields",
+  "version": "0.0.7",
+  "description": "WMake CLI: build widgets, base64 encode assets, generate fields",
   "type": "module",
   "main": "dist/index.js",
   "exports": {
     ".": "./dist/index.js",
-    "./vite-config": "./dist/vite-config.js",
-    "./vite-plugin": "./dist/vite-config.js"
+    "./vite": "./dist/vite-config.js"
   },
   "bin": {
     "wmake-cli": "dist/bin.js",

package/src/bin.ts

@@ -1,82 +1,44 @@
-#!/usr/bin/env node
-import path from "node:path";
-import fs from "node:fs";
+#!/usr/bin/env bun
 import { Command } from "commander";
-import { processPath } from "./base64.js";
 import { buildWidget } from "./widget.js";
 import { runGenerateFields } from "./generate-fields.js";
-import { runExtractTestData } from "./extract-test-data.js";
+import { readFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(path.join(__dirname, "../package.json"), "utf8"));
 
 const program = new Command();
 
-program.name("wmake").description("CLI for streamiby / wmake").version("1.0.0");
+program
+  .name("wmake")
+  .description("Build tool for @allior/wmake components")
+  .version(pkg.version);
 
 program
   .command("widget")
-  .description("Build chat-demo into widget files and zip in examples/chat-demo/dist")
-  .option("--full", "Full bundle (no CDN external), like the old build")
-  .action(async (opts: { full?: boolean }) => {
-    try {
-      await buildWidget({ full: opts.full });
-    } catch (e) {
-      console.error((e as Error).message);
-      process.exit(1);
-    }
+  .description("Build a StreamElements widget")
+  .option("-f, --full", "Build a full bundle without CDN deps")
+  .option("-s, --se-dir <dir>", "Directory containing StreamElements files (fields.json, data.json)")
+  .option("--no-wmake-versions", "Do not include wmake versions in fields")
+  .option("--no-test-alerts", "Do not include test alerts in fields")
+  .option("--no-test-messages", "Do not include test messages in fields")
+  .action(async (options) => {
+    await buildWidget({ 
+      full: options.full,
+      seDir: options.seDir,
+      skipWmakeVersions: !options.wmakeVersions,
+      skipTestAlerts: !options.testAlerts,
+      skipTestMessages: !options.testMessages
+    });
   });
 
 program
   .command("generate-fields")
-  .description("Generate fields.json from fields.base.json and test data objects (WMAKE_FIELDS_DIR)")
-  .action(async () => {
-    try {
-      const fieldsDir = process.env.WMAKE_FIELDS_DIR;
-      if (!fieldsDir?.trim()) {
-        throw new Error("WMAKE_FIELDS_DIR must be set.");
-      }
-      const mod = (await import("@allior/wmake-streamelements-events")) as unknown as {
-        testMessages: Record<string, unknown>;
-        testAlerts: Record<string, unknown>;
-      };
-      runGenerateFields({
-        fieldsDir: path.resolve(fieldsDir),
-        testMessages: mod.testMessages,
-        testAlerts: mod.testAlerts,
-      });
-    } catch (e) {
-      console.error((e as Error).message);
-      process.exit(1);
-    }
-  });
-
-program
-  .command("extract-test-data")
-  .description("No-op: test data lives in streamelements/src/assets as TS objects")
-  .action(async () => {
-    try {
-      await runExtractTestData();
-    } catch (e) {
-      console.error((e as Error).message);
-      process.exit(1);
-    }
-  });
-
-program
-  .command("base64")
-  .description("Convert images, videos, SVG to base64 for browsers")
-  .argument("<path>", "File or directory path")
-  .option("-o, --output <path>", "Output file or directory")
-  .option("-f, --full", "Output with additional info")
-  .action(async (inputPath: string, options: { output?: string; full?: boolean }) => {
-    if (!fs.existsSync(inputPath)) {
-      console.error("Error: Path does not exist");
-      process.exit(1);
-    }
-    try {
-      await processPath(inputPath, options.output ?? null, options.full ?? false);
-    } catch (e) {
-      console.error("Error:", (e as Error).message);
-      process.exit(1);
-    }
+  .description("Generate fields.json from fields.base.json (manual source update)")
+  .action(() => {
+    runGenerateFields(process.cwd());
   });
 
 program.parse();