@allior/wmake-cli 0.0.6 → 0.0.7

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("");
+}

package/src/vite-config.ts

@@ -1,156 +1,152 @@
-import type { PluginOption } from "vite";
-import fs from "node:fs";
 import path from "node:path";
+import fs from "node:fs";
+import type { AliasOptions, PluginOption } from "vite";
 
-/** Базовые зависимости, которые всегда выносим в CDN (IIFE) */
-const BASE_GLOBALS: Record<string, string> = {
+export const BASE_GLOBALS: Record<string, string> = {
   react: "React",
   "react-dom": "ReactDOM",
   "react-dom/client": "ReactDOM",
   "react/jsx-runtime": "React",
 };
 
-/**
- * Преобразует @allior/wmake-something в WmakeSomething
- * @allior/wmake-something/react -> WmakeSomethingReact
- */
-function toGlobalName(pkg: string): string {
-  if (pkg.endsWith("/react")) {
-    return toGlobalName(pkg.replace("/react", "")) + "React";
-  }
-  const name = pkg
-    .replace("@allior/", "")
-    .replace(/\//g, "-")
-    .split("-")
-    .map((s) => s.charAt(0).toUpperCase() + s.slice(1))
-    .join("");
-  return name;
-}
-
-/** Получает список @allior/wmake-* пакетов из депенденси текущего проекта */
-function getWmakeDeps(cwd: string): string[] {
-  const pkgPath = path.join(cwd, "package.json");
-  if (!fs.existsSync(pkgPath)) return [];
-  try {
-    const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
-    const deps = { ...pkg.dependencies };
-    return Object.keys(deps).filter((d) => d.startsWith("@allior/wmake-") && d !== "@allior/wmake-cli");
-  } catch {
-    return [];
-  }
-}
-
-/** Генерирует карту глобалов для Rollup. Используем чистые имена. */
-export function getWmakeGlobals(cwd: string = process.cwd()) {
+/** 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) {
-    res[pkg] = toGlobalName(pkg);
-    res[`${pkg}/react`] = toGlobalName(pkg) + "React";
+    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;
 }
 
-/** Вспомогательная функция для получения ЧИСТЫХ имен глобалов (без window.) для проверок */
-export function getRawWmakeGlobals(cwd: string = process.cwd()) {
+/** 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> = { ...BASE_GLOBALS };
+  const res: Record<string, string> = {};
   for (const pkg of deps) {
-    res[pkg] = toGlobalName(pkg);
-    res[`${pkg}/react`] = toGlobalName(pkg) + "React";
+    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;
 }
 
-/** Получает Set внешних зависимостей для CDN режима */
-export function getExternalForCdn(cwd: string = process.cwd()): Set<string> {
-  const deps = getWmakeDeps(cwd);
-  const res = new Set(Object.keys(BASE_GLOBALS));
-  for (const pkg of deps) {
-    res.add(pkg);
-    res.add(`${pkg}/react`);
+/** 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 aliases;
+}
+
+/** 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;
 }
 
-/** Реактивная настройка алиасов для разработки (локальные пути) */
-export function getWmakeAliases(root: string, cwd: string = process.cwd()) {
-  const deps = getWmakeDeps(cwd);
-  const aliases: Record<string, string> = {};
-  for (const pkg of deps) {
-    const name = pkg.replace("@allior/wmake-", "");
-    aliases[pkg] = path.join(root, `${name}/dist/root/index.js`);
-    aliases[`${pkg}/react`] = path.join(root, `${name}/dist/react/index.js`);
+/** 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;
   }
-  return aliases;
+  
+  if (normId.includes("/@allior/wmake-") || normId.includes("/wmake-")) {
+    if (!normId.includes("/wmake-cli/")) return true;
+  }
+  return false;
 }
 
-/** Оптимизация Vite (чтобы он не пересобирал их сто раз) */
-export function getWmakeOptimizeDeps(cwd: string = process.cwd()) {
+/** Legacy helper for external dependencies */
+export function getExternalForCdn(cwd: string = process.cwd()): string[] {
   const deps = getWmakeDeps(cwd);
-  const res = [];
+  const res = [...Object.keys(BASE_GLOBALS)];
   for (const pkg of deps) {
-    res.push(pkg, `${pkg}/react`);
+    res.push(pkg);
+    res.push(`${pkg}/react`);
   }
   return res;
 }
 
-/** Плагин для вставки тегов <script> из CDN в HTML.txt */
-export function wmakeScriptCdnPlugin(options: {
-  useCdn: boolean;
-  projectDir?: string;
-}): PluginOption {
-  const { useCdn, projectDir = process.cwd() } = options;
-
-  return {
-    name: "wmake-script-cdn",
-    transformIndexHtml: {
-      order: "post",
-      handler(html) {
-        if (!useCdn) return html;
-
-        // По требованию пользователя используем React 18.2.0 по умолчанию для совместимости
-        const reactVer = "18.2.0";
-
-        const CDN_BASE = "https://cdn.jsdelivr.net/npm";
-        
-        // Скрипты реакта - ВСЕГДА В НАЧАЛО
-        const reactTags = [
-          `<script src="${CDN_BASE}/react@${reactVer}/umd/react.production.min.js"></script>`,
-          `<script src="${CDN_BASE}/react-dom@${reactVer}/umd/react-dom.production.min.js"></script>`
-        ].join("\n    ");
-
-        // Шим для JSX Runtime, чтобы не падал на React.createElement
-        const shim = `
-    <script>
-      (function() {
-        var r = function() { return window.React; };
-        window.ReactJSXRuntime = {
-          get jsx() { return r().createElement; },
-          get jsxs() { return r().createElement; },
-          get Fragment() { return r().Fragment; }
-        };
-      })();
-    </script>`;
-
-        // Остальные библиотеки @allior/wmake-*
-        const deps = getWmakeDeps(projectDir);
-        const otherTags = deps.map(pkg => {
-          return [
-            `<script src="${CDN_BASE}/${pkg}@latest/dist/root/index.iife.js"></script>`,
-            `<script src="${CDN_BASE}/${pkg}@latest/dist/react/index.iife.js"></script>`
-          ].join("\n    ");
-        }).join("\n    ");
-
-        // Вставляем В НАЧАЛО <head>, чтобы зависимости были первыми
-        let res = html.replace(/(<head[^>]*>)/i, `$1\n    ${reactTags}${shim ? "\n    " + shim : ""}\n    ${otherTags}`);
+/** 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`)];
+}
 
-        // Для работы в Streamelements нам НЕ НУЖЕН тег основного скрипта в HTML, 
-        // так как код живет во вкладке JS. Удаляем его вместе с атрибутами type="module" и crossorigin.
-        res = res.replace(/<script(?=[^>]*src=["']\/assets\/index\.js["'])[\s\S]*?><\/script>/gi, '');
+/** 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 res;
-      },
+  return {
+    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>`
+      );
     },
   };
 }
+
+/** 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;
+    });
+}