@keload/node-red-dxp 1.5.0 → 1.7.0

package/dist/builder/index.js

@@ -0,0 +1,705 @@
+import fs, { readFileSync } from 'node:fs';
+import path2, { sep } from 'node:path';
+import { cosmiconfigSync } from 'cosmiconfig';
+import { globSync } from 'fast-glob';
+import { dash, pascal } from 'radash';
+import fsPromise from 'node:fs/promises';
+import esbuild from 'esbuild';
+import { minify } from 'html-minifier-terser';
+import purgeCss from '@fullhuman/postcss-purgecss';
+import autoprefixer from 'autoprefixer';
+import cssnano from 'cssnano';
+import postcss from 'postcss';
+import * as sass from 'sass';
+import tailwindcss from 'tailwindcss';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// node_modules/.pnpm/is-what@5.0.2/node_modules/is-what/dist/getType.js
+function getType(payload) {
+  return Object.prototype.toString.call(payload).slice(8, -1);
+}
+
+// node_modules/.pnpm/is-what@5.0.2/node_modules/is-what/dist/isPlainObject.js
+function isPlainObject(payload) {
+  if (getType(payload) !== "Object")
+    return false;
+  const prototype = Object.getPrototypeOf(payload);
+  return !!prototype && prototype.constructor === Object && prototype === Object.prototype;
+}
+
+// node_modules/.pnpm/is-what@5.0.2/node_modules/is-what/dist/isSymbol.js
+function isSymbol(payload) {
+  return getType(payload) === "Symbol";
+}
+
+// node_modules/.pnpm/merge-anything@6.0.2/node_modules/merge-anything/dist/merge.js
+function assignProp(carry, key, newVal, originalObject) {
+  const propType = {}.propertyIsEnumerable.call(originalObject, key) ? "enumerable" : "nonenumerable";
+  if (propType === "enumerable")
+    carry[key] = newVal;
+  if (propType === "nonenumerable") {
+    Object.defineProperty(carry, key, {
+      value: newVal,
+      enumerable: false,
+      writable: true,
+      configurable: true
+    });
+  }
+}
+function mergeRecursively(origin, newComer, compareFn) {
+  if (!isPlainObject(newComer))
+    return newComer;
+  let newObject = {};
+  if (isPlainObject(origin)) {
+    const props2 = Object.getOwnPropertyNames(origin);
+    const symbols2 = Object.getOwnPropertySymbols(origin);
+    newObject = [...props2, ...symbols2].reduce((carry, key) => {
+      const targetVal = origin[key];
+      if (!isSymbol(key) && !Object.getOwnPropertyNames(newComer).includes(key) || isSymbol(key) && !Object.getOwnPropertySymbols(newComer).includes(key)) {
+        assignProp(carry, key, targetVal, origin);
+      }
+      return carry;
+    }, {});
+  }
+  const props = Object.getOwnPropertyNames(newComer);
+  const symbols = Object.getOwnPropertySymbols(newComer);
+  const result = [...props, ...symbols].reduce((carry, key) => {
+    let newVal = newComer[key];
+    const targetVal = isPlainObject(origin) ? origin[key] : void 0;
+    if (targetVal !== void 0 && isPlainObject(newVal)) {
+      newVal = mergeRecursively(targetVal, newVal);
+    }
+    const propToAssign = newVal;
+    assignProp(carry, key, propToAssign, newComer);
+    return carry;
+  }, newObject);
+  return result;
+}
+function merge(object, ...otherObjects) {
+  return otherObjects.reduce((result, newComer) => {
+    return mergeRecursively(result, newComer);
+  }, object);
+}
+
+// src/default-config.ts
+var defaultConfig = {
+  libCacheDir: ".node-red-dx",
+  srcDir: "src",
+  nodesDirName: "nodes",
+  nodes: {
+    controllerName: "controller",
+    localesDirName: "locales",
+    editor: {
+      dirName: "editor",
+      htmlName: "index",
+      tsName: "index"
+    }
+  },
+  builder: {
+    outputDir: "dist"
+  },
+  watcher: {
+    nodeRed: {
+      enabled: true,
+      path: "~/.node-red",
+      url: "http://localhost:1880"
+    }
+  }
+};
+
+// src/current-context.ts
+var CONFIG_FILE_NAME = "node-red-dx";
+var cleanPkgName = (pkgName) => pkgName.replace("@", "").replace("/", "-");
+function getConfig() {
+  const explorerSync = cosmiconfigSync(CONFIG_FILE_NAME);
+  try {
+    const result = explorerSync.search();
+    return merge(defaultConfig, result ? result.config : {});
+  } catch (error) {
+    console.error("Error while loading configuration", error);
+    throw error;
+  }
+}
+var currentConfig = getConfig();
+var currentDir = process.cwd();
+var jsonPackage = JSON.parse(readFileSync(`${currentDir}/package.json`, "utf-8"));
+var pathSrcDir = `${currentDir}/${currentConfig.srcDir}`;
+var additionalResourcesDir = `${currentDir}/resources`;
+var pathSrcNodesDir = `${pathSrcDir}/${currentConfig.nodesDirName}`;
+var pathLibCacheDir = `${currentDir}/${currentConfig.libCacheDir}`;
+var currentPackagedDistPath = `${path2.resolve(__dirname, "..")}`;
+var packageNameSlug = cleanPkgName(jsonPackage.name);
+function listNodeFolders(rawNodes = []) {
+  return rawNodes.map((entry) => {
+    const fullPath = entry.path;
+    const fullEditorPath = `${fullPath}/${currentConfig.nodes.editor.dirName}`;
+    const relativePath = fullPath.replace(currentDir, "").slice(1);
+    const relativeEditorPath = `${relativePath}/${currentConfig.nodes.editor.dirName}`;
+    const scssFiles = globSync(`${fullEditorPath}/**/*.scss`);
+    const mdxFiles = globSync(`${fullPath}/doc.mdx`);
+    const mdFiles = globSync(`${fullPath}/doc.md`);
+    const dashName = dash(entry.name);
+    return {
+      fullEditorPath,
+      fullPath,
+      name: entry.name,
+      pascalName: pascal(entry.name),
+      dashName,
+      relativeEditorPath,
+      relativePath,
+      resolvedLocalesPaths: globSync(`${fullPath}/${currentConfig.nodes.localesDirName}/*.json`),
+      nodeIdentifier: `${packageNameSlug}-${dashName}`,
+      fullControllerPath: `${fullPath}/controller.ts`,
+      editor: {
+        tsPath: `${fullEditorPath}/${currentConfig.nodes.editor.tsName}.ts`,
+        htmlPath: `${fullEditorPath}/${currentConfig.nodes.editor.htmlName}.html`,
+        scssFiles
+      },
+      doc: {
+        mdxFiles,
+        mdFiles
+      }
+    };
+  });
+}
+function getCurrentContext() {
+  const resolvedNodesPaths = globSync(`${pathSrcNodesDir}/**/*`, { onlyDirectories: true, deep: 1, objectMode: true });
+  const listNodesFull = listNodeFolders(resolvedNodesPaths);
+  const listNodesFullNames = listNodesFull.map((node) => node.name);
+  return {
+    currentDir,
+    pathSrcDir,
+    pathSrcNodesDir,
+    additionalResourcesDir,
+    pathDist: `${currentDir}/${currentConfig.builder.outputDir}`,
+    currentPackagedDistPath,
+    cacheDirFiles: {
+      controllerIndex: `${pathLibCacheDir}/controller-index.ts`,
+      editorIndex: `${pathLibCacheDir}/editor-index.ts`
+    },
+    pathLibCacheDir,
+    packageName: jsonPackage.name,
+    packageNameSlug,
+    config: currentConfig,
+    resolvedSrcPathsScss: globSync(`${pathSrcDir}/**/*.scss`, { ignore: [`${pathSrcNodesDir}/**/*.scss`] }),
+    resolvedNodesPaths: resolvedNodesPaths.map((entry) => entry.path),
+    resolvedSrcLocalesPaths: globSync(`${pathSrcDir}/locales/*.json`),
+    listNodesFull,
+    listNodesFullNames
+  };
+}
+var currentContext = getCurrentContext();
+var distributionPackagePath = `${path2.resolve(__dirname, "..")}`;
+function createFolderIfNotExists(folderPath) {
+  if (!fs.existsSync(folderPath)) {
+    fs.mkdirSync(folderPath, { recursive: true });
+  }
+}
+function writeFile(path3, content) {
+  return __async(this, null, function* () {
+    try {
+      yield fsPromise.writeFile(path3, content);
+    } catch (error) {
+      console.error("Error writing controller index:", error);
+    }
+  });
+}
+function cleanPaths(paths) {
+  return __async(this, null, function* () {
+    for (const dirPath of paths) {
+      try {
+        const resolvedPath = path2.resolve(dirPath);
+        const stats = yield fsPromise.stat(resolvedPath).catch(() => null);
+        if (stats == null ? void 0 : stats.isDirectory()) {
+          yield fsPromise.rm(resolvedPath, { recursive: true, force: true });
+        }
+      } catch (error) {
+        console.error(`Error cleaning path (${dirPath}): ${error}`);
+      }
+    }
+  });
+}
+var addCredentialsExportPlugin = {
+  name: "add-credentials-export",
+  setup(build) {
+    build.onLoad({ filter: /controller\.ts$/ }, (args) => __async(this, null, function* () {
+      const source = yield fsPromise.readFile(args.path, "utf8");
+      const hasCredentialsExport = /export\s+const\s+credentials\s*=/.test(source);
+      if (!hasCredentialsExport) {
+        return {
+          contents: `${source}
+export const credentials = {};`,
+          loader: "ts"
+        };
+      }
+      return { contents: source, loader: "ts" };
+    }));
+  }
+};
+
+// src/builder/controller/BuilderController.class.ts
+var BuilderController = class {
+  constructor(params) {
+    __publicField(this, "params");
+    this.params = __spreadValues({ minify: false }, params);
+  }
+  getControllerIndexContent() {
+    return __async(this, null, function* () {
+      return `
+import type { NodeAPI } from 'node-red';
+${currentContext.listNodesFull.map((node) => `import ${node.pascalName}, {credentials as cred${node.pascalName}} from '${node.fullControllerPath}';`).join("\n")}
+
+
+export default async (RED: NodeAPI): Promise<void> => {
+    global.RED = RED;
+
+    ${currentContext.listNodesFull.map(
+        (node) => `// @ts-ignore
+global.RED.nodes.registerType('${node.name}', ${node.pascalName}, {
+        credentials: cred${node.pascalName}
+    });`
+      ).join("\n")}
+};
+`.trim();
+    });
+  }
+  buildScript() {
+    return esbuild.build({
+      entryPoints: [currentContext.cacheDirFiles.controllerIndex],
+      outfile: `${currentContext.pathDist}/index.js`,
+      bundle: true,
+      minify: this.params.minify,
+      minifyWhitespace: this.params.minify,
+      minifyIdentifiers: this.params.minify,
+      minifySyntax: this.params.minify,
+      platform: "node",
+      format: "cjs",
+      target: "es2018",
+      loader: { ".ts": "ts" },
+      packages: "external",
+      plugins: [addCredentialsExportPlugin]
+    });
+  }
+  getControllerTask() {
+    return __async(this, null, function* () {
+      return this.getControllerIndexContent().then((content) => {
+        writeFile(`${currentContext.cacheDirFiles.controllerIndex}`, content).then(() => {
+          this.buildScript();
+        });
+      });
+    });
+  }
+};
+var BuildDoc = class {
+  // TODO need to refactor
+  getAllDocContent() {
+    const result = [];
+    for (const node of currentContext.listNodesFull) {
+      const fileMd = node.doc.mdFiles[0];
+      if (fileMd) {
+        const htmlMd = fs.readFileSync(node.doc.mdFiles[0], "utf-8");
+        const inner = `
+<script type="text/markdown" data-help-name="${node.name}">
+${htmlMd}
+</script>
+      `;
+        result.push(inner);
+      }
+    }
+    return result.length ? result.join("\n") : "";
+  }
+};
+function cleanSpaces(str) {
+  return str.trim().replace(/\n\s+/g, "");
+}
+
+// src/builder/editor/i18n.ts
+function updateI18nAttributes(nodeName = "", htmlContent = "") {
+  if (!nodeName || !htmlContent) {
+    return htmlContent;
+  }
+  return htmlContent.replace(/data-i18n="([^"]+)"/g, (match, i18nValue) => {
+    const updatedValue = i18nValue.replace(/(\[.*?\])?(node-red:[^;]+|[^;]+)/g, (_, prefix, key) => {
+      let res = key;
+      if (!key.startsWith("node-red:")) {
+        res = `${nodeName}.${key}`;
+      }
+      return (prefix || "") + res;
+    });
+    return `data-i18n="${updatedValue}"`;
+  });
+}
+
+// src/builder/editor/html.ts
+function minifyHtml(content) {
+  return __async(this, null, function* () {
+    return minify(content, {
+      collapseWhitespace: true,
+      removeComments: true,
+      removeRedundantAttributes: false,
+      useShortDoctype: true,
+      removeEmptyAttributes: false,
+      minifyCSS: false,
+      minifyJS: false
+    });
+  });
+}
+function wrapHtml(nodeName, html) {
+  return `
+    <script type="text/html" data-template-name="${nodeName}">
+        ${html}
+    </script>
+`;
+}
+function processNodeHtml(node, packageNameSlug2, minify2 = false) {
+  return __async(this, null, function* () {
+    const htmlContent = readFileSync(node.editor.htmlPath, "utf8");
+    const htmlContentWithAdditionalDiv = `
+  <div class="${packageNameSlug2}">
+    <div class="${node.nodeIdentifier}">${htmlContent}</div>
+  </div>
+  `;
+    let html = minify2 ? yield minifyHtml(htmlContentWithAdditionalDiv) : htmlContentWithAdditionalDiv;
+    html = updateI18nAttributes(node.name, html);
+    const wrappedHtml = wrapHtml(node.name, html);
+    return {
+      nodeName: node.name,
+      nodeIdentifier: node.nodeIdentifier,
+      html,
+      wrappedHtml
+    };
+  });
+}
+function getNodesHtml(params) {
+  return __async(this, null, function* () {
+    const { nodes, minify: minify2 = false } = params;
+    const res = yield Promise.all(nodes.map((node) => processNodeHtml(node, params.packageNameSlug, minify2)));
+    const allHtml = res.map((node) => node.html).join("").trim();
+    return {
+      html: allHtml,
+      allWrappedHtml: res.map((node) => minify2 ? cleanSpaces(node.wrappedHtml) : node.wrappedHtml).join("").trim()
+    };
+  });
+}
+function processCSS(cssString, htmlString) {
+  return __async(this, null, function* () {
+    const result = yield postcss([
+      purgeCss({
+        content: [{ raw: htmlString, extension: "html" }]
+        // Analyse directe du HTML
+      }),
+      autoprefixer,
+      cssnano({ preset: "default" })
+    ]).process(cssString, { from: void 0 });
+    return result.css;
+  });
+}
+function compileScss(filePath) {
+  const result = sass.compile(filePath, { style: "expanded" });
+  return result.css;
+}
+function buildStyles(files) {
+  const styles = {};
+  for (let i = 0; i < files.length; i++) {
+    const filePath = files[i];
+    styles[filePath] = compileScss(filePath);
+  }
+  return styles;
+}
+function getNodesStyles(nodes) {
+  const hasStyles = nodes.some((node) => node.editor.scssFiles.length);
+  if (!hasStyles) {
+    return [];
+  }
+  return nodes.filter((node) => node.editor.scssFiles.length).map((node) => {
+    const nodeStyles = buildStyles(node.editor.scssFiles);
+    const mergedCompiledStyles = Object.values(nodeStyles).join("");
+    return {
+      name: node.name,
+      mergedCompiledStyles,
+      scssFinal: `
+        #${node.nodeIdentifier}{
+          ${mergedCompiledStyles}
+        }`
+    };
+  });
+}
+function generateCSSFromHTMLWithTailwind(_0) {
+  return __async(this, arguments, function* (htmlString, tailwindConfig = {}) {
+    const defaultConfig2 = {
+      content: [{ raw: htmlString }],
+      theme: {}
+    };
+    const finalConfig = __spreadValues(__spreadValues({}, defaultConfig2), tailwindConfig);
+    const tailwindScssFilePath = globSync(
+      `${distributionPackagePath}/${currentContext.config.nodes.editor.dirName}/assets/tailwind.scss`
+    )[0];
+    const scssString = tailwindScssFilePath.length ? fs.readFileSync(tailwindScssFilePath, "utf8") : "";
+    const result = yield postcss([tailwindcss(finalConfig), __require("autoprefixer")]).process(scssString, {
+      from: void 0
+    });
+    return result.css;
+  });
+}
+function getSrcStyles() {
+  const srcStyles = currentContext.resolvedSrcPathsScss;
+  const srcStylesCompiled = buildStyles([...srcStyles]);
+  return Object.values(srcStylesCompiled).join("");
+}
+function getAllCompiledStyles(params) {
+  return __async(this, null, function* () {
+    const { rawHtml, minify: minify2 = false, nodes } = params || {};
+    const srcStyles = getSrcStyles();
+    const nodesStyles = getNodesStyles(nodes);
+    const twCss = yield generateCSSFromHTMLWithTailwind(rawHtml);
+    const getSrcWrapper = (content) => `.${currentContext.packageNameSlug}{${content}}`;
+    const allNodesStyles = nodesStyles.map((node) => node.scssFinal).join("\n");
+    const result = getSrcWrapper(`${twCss}${srcStyles}${allNodesStyles}`);
+    return minify2 ? processCSS(result, rawHtml) : result;
+  });
+}
+
+// src/builder/editor/BuilderEditor.class.ts
+var BuilderEditor = class {
+  constructor(params) {
+    __publicField(this, "params");
+    this.params = __spreadValues({ minify: false }, params);
+  }
+  getEditorIndexContent() {
+    return __async(this, null, function* () {
+      return `
+import type { NodeAPI } from 'node-red';
+${currentContext.listNodesFull.map((node) => `import ${node.pascalName} from '${node.editor.tsPath}';`).join("\n")}
+
+declare const RED: NodeAPI;
+
+${currentContext.listNodesFull.map((node) => `// @ts-ignore
+window.RED.nodes.registerType('${node.name}', ${node.pascalName});`).join("\n")}
+`.trim();
+    });
+  }
+  getBuiltScript() {
+    return __async(this, null, function* () {
+      const result = yield esbuild.build({
+        entryPoints: [currentContext.cacheDirFiles.editorIndex],
+        bundle: true,
+        platform: "browser",
+        format: "iife",
+        target: "es6",
+        sourcemap: false,
+        minify: this.params.minify,
+        minifyWhitespace: this.params.minify,
+        minifySyntax: this.params.minify,
+        minifyIdentifiers: this.params.minify,
+        legalComments: "none",
+        inject: [`${currentContext.currentPackagedDistPath}/editor/global-solid.ts`],
+        write: false,
+        loader: { ".ts": "ts" }
+      });
+      if (result.outputFiles && result.outputFiles.length > 0) {
+        return result.outputFiles[0].text;
+      }
+      return "";
+    });
+  }
+  prepareEditorIndex() {
+    return __async(this, null, function* () {
+      const js = yield this.getBuiltScript();
+      const html = yield getNodesHtml({
+        minify: this.params.minify,
+        nodes: currentContext.listNodesFull,
+        packageNameSlug: currentContext.packageNameSlug
+      });
+      const css = yield getAllCompiledStyles({
+        rawHtml: html.html,
+        minify: this.params.minify,
+        nodes: currentContext.listNodesFull
+      });
+      const builderDoc = new BuildDoc();
+      const docs = builderDoc.getAllDocContent();
+      const wrappedJs = `<script type="application/javascript">${js.trim()}</script>`;
+      const wrappedCss = `<style>${css}</style>`;
+      return `
+${html.allWrappedHtml}
+${wrappedCss}
+${wrappedJs}
+${docs}`.trim();
+    });
+  }
+  getEditorTask() {
+    return __async(this, null, function* () {
+      return this.getEditorIndexContent().then((content) => {
+        writeFile(`${currentContext.cacheDirFiles.editorIndex}`, content).then(() => {
+          this.prepareEditorIndex().then((contentFinalIndexHtml) => __async(this, null, function* () {
+            yield writeFile(
+              `${currentContext.pathDist}/${currentContext.config.nodes.editor.htmlName}.html`,
+              contentFinalIndexHtml
+            );
+          }));
+        });
+      });
+    });
+  }
+};
+function getWithContent(path3) {
+  return __async(this, null, function* () {
+    const codeLang = path3.split("/").pop().split(".").shift();
+    const content = yield fsPromise.readFile(path3, "utf-8");
+    return {
+      codeLang,
+      content
+    };
+  });
+}
+function getGlobalLocales() {
+  return __async(this, null, function* () {
+    const nodesList = currentContext.listNodesFullNames;
+    const srcLocales = currentContext.resolvedSrcLocalesPaths;
+    const srcLocalesWithContent = yield Promise.all(srcLocales.map(getWithContent));
+    const grouped = {};
+    nodesList.forEach((nodeName) => {
+      for (const { codeLang, content } of srcLocalesWithContent) {
+        if (!grouped[codeLang]) {
+          grouped[codeLang] = [];
+        }
+        grouped[codeLang].push(`"${nodeName}":${content}`);
+      }
+    });
+    let allContent = "";
+    for (const [lang, locales] of Object.entries(grouped)) {
+      const content = locales.map((innerContent) => innerContent).join(",").slice(0, -1);
+      allContent += `"${lang}":{${content}},`;
+    }
+    return `{${allContent.slice(0, -1)}}`;
+  });
+}
+function processNode(path3) {
+  return __async(this, null, function* () {
+    const cleanPath = path3.replace(`${currentContext.pathSrcNodesDir}${sep}`, "");
+    const [nodeName, , fileName] = cleanPath.split(sep);
+    const [codeLang] = fileName.split(".");
+    const content = yield fsPromise.readFile(path3, "utf-8");
+    return {
+      nodeName,
+      codeLang,
+      path: path3,
+      content
+    };
+  });
+}
+function getScopedNodesLocales() {
+  return __async(this, null, function* () {
+    const toto = globSync(`${currentContext.pathSrcNodesDir}/**/locales/*.json`);
+    const res = yield Promise.all(toto.map(processNode));
+    const grouped = {};
+    res.forEach(({ nodeName, codeLang, content }) => {
+      if (!grouped[codeLang]) {
+        grouped[codeLang] = [];
+      }
+      grouped[codeLang].push(`"${nodeName}":${content}`);
+    });
+    let allContent = "";
+    for (const [lang, locales] of Object.entries(grouped)) {
+      const content = locales.map((innerContent) => innerContent).join(",").slice(0, -1);
+      allContent += `"${lang}":{${content}},`;
+    }
+    return `{${allContent.slice(0, -1)}}`;
+  });
+}
+
+// src/builder/locales/getLocales.ts
+function writeAllLocales() {
+  return __async(this, null, function* () {
+    const [globalLocales, scopedLocales] = yield Promise.all([getGlobalLocales(), getScopedNodesLocales()]);
+    const res = merge(JSON.parse(globalLocales), JSON.parse(scopedLocales));
+    const toResolveCreateDirs = [];
+    const toResolve = [];
+    for (const [folderName, locales] of Object.entries(res)) {
+      toResolveCreateDirs.push(createFolderIfNotExists(`${currentContext.pathDist}/locales/${folderName}`));
+      toResolve.push(writeFile(`${currentContext.pathDist}/locales/${folderName}/index.json`, JSON.stringify(locales)));
+    }
+    yield Promise.all(toResolveCreateDirs);
+    yield Promise.all(toResolve);
+  });
+}
+
+// src/builder/Builder.class.ts
+var Builder = class {
+  constructor(params) {
+    __publicField(this, "params");
+    __publicField(this, "builderController");
+    __publicField(this, "builderEditor");
+    this.params = __spreadValues({ minify: false }, params);
+    this.builderController = new BuilderController({
+      minify: this.params.minify
+    });
+    this.builderEditor = new BuilderEditor({
+      minify: this.params.minify
+    });
+  }
+  prepare() {
+    createFolderIfNotExists(currentContext.pathLibCacheDir);
+    const runs = [
+      cleanPaths([currentContext.pathDist]),
+      writeFile(`${currentContext.pathLibCacheDir}/config.json`, JSON.stringify(currentContext.config, null, 2))
+    ];
+    return Promise.all(runs);
+  }
+  buildAll() {
+    return __async(this, null, function* () {
+      yield this.prepare();
+      return Promise.all([
+        this.builderController.getControllerTask(),
+        this.builderEditor.getEditorTask(),
+        writeAllLocales()
+      ]);
+    });
+  }
+};
+
+export { Builder };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map