@allior/wmake-cli 0.0.5 → 0.0.7

package/dist/widget.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"widget.d.ts","sourceRoot":"","sources":["../src/widget.ts"],"names":[],"mappings":"AAwCA,wBAAsB,WAAW,CAAC,OAAO,EAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CA0I5E"}
+{"version":3,"file":"widget.d.ts","sourceRoot":"","sources":["../src/widget.ts"],"names":[],"mappings":"AAIA,OAAO,EAAwB,qBAAqB,EAAE,MAAM,sBAAsB,CAAC;AAGnF,MAAM,WAAW,kBAAmB,SAAQ,qBAAqB;IAC/D,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,8DAA8D;AAC9D,wBAAsB,WAAW,CAAC,OAAO,GAAE,kBAAuB,iBA6IjE"}

package/dist/widget.js

@@ -1,145 +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.");
+    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 (!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");
-    }
-    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"));
+    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,9 +1,13 @@
 {
   "name": "@allior/wmake-cli",
-  "version": "0.0.5",
-  "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": "./dist/vite-config.js"
+  },
   "bin": {
     "wmake-cli": "dist/bin.js",
     "@allior/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();

package/src/generate-fields.ts

@@ -1,117 +1,104 @@
-/**
- * Генерирует fields.json из fields.base.json и ключей из объектов testMessages / testAlerts.
- * Путь к каталогу с fields.base.json задаётся WMAKE_FIELDS_DIR.
- * Данные сообщений и алертов передаются объектами (из скриптов streamelements).
- */
-
-import fs from "node:fs";
-import path from "node:path";
-import { spawnSync } from "node:child_process";
-
-const TEST_GROUP = "Tests / Тесты";
-
-type FieldDef = Record<string, unknown>;
-type FieldsMap = Record<string, FieldDef>;
-
-function pascalCase(s: string): string {
-  return s.charAt(0).toUpperCase() + s.slice(1);
-}
-
-/** camelCase → sentence case (e.g. veryShort → "Very short", selfSub → "Self sub") */
-function keyToTitle(key: string): string {
-  const words = key
-    .replace(/([A-Z])/g, " $1")
-    .toLowerCase()
-    .trim();
-  return words.charAt(0).toUpperCase() + words.slice(1);
-}
-
-function messageLabel(key: string): string {
-  return `${keyToTitle(key)} message`;
-}
-
-function alertLabel(key: string): string {
-  return `${keyToTitle(key)} alert`;
-}
-
-export type MessagesRecord = Record<string, unknown>;
-export type AlertsRecord = Record<string, unknown>;
-
-export function runGenerateFields(options: {
-  fieldsDir: string;
-  testMessages: MessagesRecord;
-  testAlerts: AlertsRecord;
-}): void {
-  const { fieldsDir, testMessages: messages, testAlerts: alerts } = options;
-
-  const basePath = path.join(fieldsDir, "fields.base.json");
-  const outPath = path.join(fieldsDir, "fields.json");
-
-  const base = JSON.parse(fs.readFileSync(basePath, "utf-8")) as FieldsMap;
-
-  const messageKeys = Object.keys(messages);
-  const alertKeys = Object.keys(alerts);
-
-  const testMessageFields: FieldsMap = {};
-  for (const key of messageKeys) {
-    const fieldId = "testMessage" + pascalCase(key);
-    testMessageFields[fieldId] = {
-      type: "button",
-      label: messageLabel(key),
-      group: TEST_GROUP,
-    };
-  }
-
-  const testAlertFields: FieldsMap = {};
-  for (const key of alertKeys) {
-    const fieldId = "testAlert" + pascalCase(key);
-    testAlertFields[fieldId] = {
-      type: "button",
-      label: alertLabel(key),
-      group: TEST_GROUP,
-    };
-  }
-
-  const insertAfterKey = "blueFlowerAnimationDuration";
-  const result: FieldsMap = {};
-  let inserted = false;
-  for (const k of Object.keys(base)) {
-    if (k.startsWith("_")) continue;
-    result[k] = base[k] as FieldDef;
-    if (k === insertAfterKey) {
-      Object.assign(result, testMessageFields, testAlertFields);
-      inserted = true;
-    }
-  }
-  if (!inserted) {
-    Object.assign(result, testMessageFields, testAlertFields);
-  }
-
-  fs.writeFileSync(outPath, JSON.stringify(result, null, 2), "utf-8");
-  console.log("Wrote", outPath);
-  console.log("Test message buttons:", messageKeys.length);
-  console.log("Test alert buttons:", alertKeys.length);
-}
-
-/**
- * Генерирует fields.json из TS/JS модуля, экспортирующего default AdvancedField[].
- * Использует tsx для загрузки .ts файлов.
- */
-export function runGenerateFieldsFromModule(fieldsModulePath: string): void {
-  const absPath = path.resolve(fieldsModulePath);
-  const outPath = path.join(path.dirname(absPath), "fields.json");
-  const runnerPath = path.join(
-    __dirname,
-    "..",
-    "src",
-    "generate-fields-from-module-runner.ts",
-  );
-  const r = spawnSync("npx", ["tsx", runnerPath, absPath, outPath], {
-    stdio: "inherit",
-    shell: true,
-    cwd: path.dirname(absPath),
-  });
-  if (r.status !== 0) {
-    throw new Error(`Failed to generate fields from ${fieldsModulePath}`);
-  }
-}
+import fs from "node:fs";
+import path from "node:path";
+import { getWmakeDepsWithVersions } from "./vite-config.js";
+
+export interface GenerateFieldsOptions {
+  skipWmakeVersions?: boolean;
+  skipTestAlerts?: boolean;
+  skipTestMessages?: boolean;
+}
+
+/** Merges base fields with dynamic WMake version fields and testing tools. */
+export function generateMergedFields(
+  cwd: string = process.cwd(), 
+  seDir?: string,
+  options: GenerateFieldsOptions = {}
+): any {
+  const baseFieldsPath = seDir 
+    ? path.join(cwd, seDir, "fields.json")
+    : path.join(cwd, "fields.json");
+
+  const legacyPath = path.join(cwd, "fields.base.json");
+  
+  let finalBaseFieldsPath = baseFieldsPath;
+  if (!fs.existsSync(baseFieldsPath) && fs.existsSync(legacyPath)) {
+    finalBaseFieldsPath = legacyPath;
+  }
+
+  if (!fs.existsSync(finalBaseFieldsPath)) {
+    console.error(`Fields file not found at ${finalBaseFieldsPath}`);
+    return {};
+  }
+
+  const baseFields = JSON.parse(fs.readFileSync(finalBaseFieldsPath, "utf-8"));
+  const finalFields: any = { ...baseFields };
+  const mergedFields: any = {};
+
+  // 1. Prepare WMake versions
+  const wmakeFields: any = {};
+  if (!options.skipWmakeVersions) {
+    const wmakeVersions = getWmakeDepsWithVersions(cwd);
+    Object.keys(wmakeVersions).forEach(pkg => {
+      const name = pkg.replace("@allior/wmake-", "");
+      const pascalName = pascalCase(name);
+      const fieldKey = `wmake${pascalName}Version`;
+      wmakeFields[fieldKey] = {
+        type: "text",
+        label: `${pascalName} version`,
+        value: wmakeVersions[pkg],
+        group: "WMake"
+      };
+    });
+  }
+
+  // 2. Prepare Testing fields
+  const testFields: any = {};
+  if (!options.skipTestAlerts) {
+    testFields["testAlert"] = {
+      type: "button",
+      label: "Test Alert",
+      value: "testAlert",
+      group: "Testing"
+    };
+  }
+  if (!options.skipTestMessages) {
+    testFields["testMessage"] = {
+      type: "button",
+      label: "Test Message",
+      value: "testMessage",
+      group: "Testing"
+    };
+  }
+
+  const dynamicFields = { ...wmakeFields, ...testFields };
+  const dynamicKeys = Object.keys(dynamicFields).sort();
+  const sortedDynamic: any = {};
+  dynamicKeys.forEach(k => sortedDynamic[k] = dynamicFields[k]);
+
+  let dynamicInserted = false;
+  for (const key in finalFields) {
+      if (key.startsWith("testMessage") && !dynamicInserted) {
+          Object.assign(mergedFields, sortedDynamic);
+          dynamicInserted = true;
+      }
+      mergedFields[key] = finalFields[key];
+  }
+  
+  if (!dynamicInserted) {
+      Object.assign(mergedFields, sortedDynamic);
+  }
+
+  return mergedFields;
+}
+
+/** Standalone command entry point */
+export function runGenerateFields(cwd: string = process.cwd()) {
+    const fields = generateMergedFields(cwd);
+    const fieldsPath = path.join(cwd, "fields.json");
+    fs.writeFileSync(fieldsPath, JSON.stringify(fields, null, 2), "utf-8");
+    console.log(`Wrote ${fieldsPath}`);
+}
+
+function pascalCase(str: string): string {
+    return str.split("-").map(w => w.charAt(0).toUpperCase() + w.slice(1)).join("");
+}