@prosopo/config 3.1.3 → 3.1.21

package/CHANGELOG.md

@@ -1,5 +1,101 @@
 # @prosopo/config
 
+## 3.1.21
+### Patch Changes
+
+- b8185a4: feat/uap-rules-syncer
+
+## 3.1.20
+### Patch Changes
+
+- 1e3a838: making webpack stuff external in vite config
+
+## 3.1.19
+### Patch Changes
+
+- 5659b24: Release 3.4.4
+
+## 3.1.18
+### Patch Changes
+
+- 50c4120: Release 3.4.3
+
+## 3.1.17
+### Patch Changes
+
+- 618703f: Release 3.4.2
+
+## 3.1.16
+### Patch Changes
+
+- 11303d9: Release 3.4.0
+- 18cb28b: Release 3.4.1
+
+## 3.1.15
+### Patch Changes
+
+- f3f7aec: Release 3.4.0
+
+## 3.1.14
+### Patch Changes
+
+- Release 3.3.1
+- 0824221: Release 3.2.4
+
+## 3.1.13
+### Patch Changes
+
+- 008d112: Release 3.3.0
+
+## 3.1.12
+### Patch Changes
+
+- 0824221: Release 3.2.4
+
+## 3.1.11
+### Patch Changes
+
+- 1a23649: Release 3.2.3
+
+## 3.1.10
+### Patch Changes
+
+- 657a827: Release 3.2.2
+
+## 3.1.9
+### Patch Changes
+
+- 4440947: fix type-only tsc compilation
+- 7bdaca6: Release 3.2.1
+- 809b984: make vite set esbuild jsx config based on env
+- 809b984: set jsx config for esbuild from vite configs to avoid jsxDEV import bug
+
+## 3.1.8
+### Patch Changes
+
+- 6fe8570: Release 3.2.0
+
+## 3.1.7
+### Patch Changes
+
+- f304be9: Release 3.1.13
+
+## 3.1.6
+### Patch Changes
+
+- 9eed772: Release 3.1.12
+
+## 3.1.5
+### Patch Changes
+
+- 30e7d4d: Fixing coverage report and more damn linting
+
+## 3.1.4
+### Patch Changes
+
+- 44ffda2: Dropping monitoring calls
+- a49b538: Extra tests
+
 ## 3.1.3
 ### Patch Changes
 

package/dist/cjs/dependencies.cjs

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const child_process = require("node:child_process");
+const fs = require("node:fs");
+const path = require("node:path");
+const util = require("node:util");
+const exec = util.promisify(child_process.exec);
+const tsConfigRegex = /\/[A-Za-z.]*\.json$/;
+const peerDepsRegex = /UNMET\sOPTIONAL\sDEPENDENCY\s+(@*[\w\-/.]+)@/;
+const depsRegex = /\s+(@*[\w\-/.]+)@/;
+async function getPackageDir(packageName) {
+  let pkg = packageName;
+  if (packageName && !packageName.startsWith("@prosopo/")) {
+    pkg = `@prosopo/${packageName}`;
+  }
+  const pkgCommand = `npm list ${pkg} -ap`;
+  console.info(`Running command ${pkgCommand}`);
+  const { stdout: packageDir, stderr } = await exec(pkgCommand);
+  if (stderr) {
+    if (stderr.includes("ERR!")) {
+      throw new Error("CONFIG.INVALID_PACKAGE_DIR");
+    }
+  }
+  return packageDir.trim() || path.resolve();
+}
+function getReferenceTsConfigPath(initialTsConfigPath, reference) {
+  let refTSConfigPath = path.resolve(
+    initialTsConfigPath.replace(tsConfigRegex, ""),
+    reference.path
+  );
+  if (!refTSConfigPath.endsWith(".json")) {
+    refTSConfigPath = path.resolve(refTSConfigPath, "tsconfig.json");
+  }
+  return refTSConfigPath;
+}
+function getTsConfigs(tsConfigPath, ignorePatterns = [], tsConfigPaths = [], includeInitialTsConfig = true) {
+  let tsConfigs = [...tsConfigPaths];
+  const references = JSON.parse(
+    fs.readFileSync(tsConfigPath).toString()
+  ).references;
+  if (!tsConfigs.includes(tsConfigPath)) {
+    if (references) {
+      const ignore = ignorePatterns && ignorePatterns.length > 0 ? new RegExp(`${ignorePatterns.join("|")}`) : void 0;
+      if (includeInitialTsConfig) {
+        tsConfigs.push(tsConfigPath);
+      }
+      const filteredReferences = references.filter(
+        (reference) => ignore ? !ignore.test(reference.path) : false
+      );
+      for (const reference of filteredReferences) {
+        const refTSConfigPath = getReferenceTsConfigPath(
+          tsConfigPath,
+          reference
+        );
+        const newTsConfigs = getTsConfigs(
+          refTSConfigPath,
+          ignorePatterns,
+          tsConfigs
+        );
+        if (newTsConfigs.length > 0) {
+          const distinctTsConfigPaths = new Set(tsConfigs.concat(newTsConfigs));
+          tsConfigs = [...distinctTsConfigPaths];
+        }
+      }
+    }
+  }
+  return tsConfigs;
+}
+async function getExternalsFromReferences(tsConfigPath, ignorePatterns = []) {
+  const tsConfigPaths = getTsConfigs(tsConfigPath, ignorePatterns, [], false);
+  console.debug({ tsConfigPaths });
+  const promises = [];
+  for (const refTsConfigPath of tsConfigPaths) {
+    const packageJsonPath = path.resolve(
+      refTsConfigPath.replace(tsConfigRegex, ""),
+      "package.json"
+    );
+    promises.push(
+      new Promise((resolve, reject) => {
+        fs.stat(packageJsonPath, (err) => {
+          if (err) {
+            reject(err);
+          }
+          fs.readFile(
+            new URL(packageJsonPath, module),
+            (err2, buffer) => {
+              if (err2) {
+                reject(err2);
+              } else {
+                const packageJson = JSON.parse(buffer.toString());
+                const pkg = packageJson.name;
+                resolve(pkg);
+              }
+            }
+          );
+        });
+      })
+    );
+  }
+  const externals = await Promise.all(promises);
+  console.debug({ externals });
+  return externals;
+}
+async function getDependencies(packageName, production) {
+  let cmd = production ? "npm ls -a --silent --omit=dev --package-lock-only" : "npm ls --silent -a --package-lock-only";
+  if (packageName) {
+    const packageDir = await getPackageDir(packageName);
+    cmd = `cd ${packageDir.trim()} && ${cmd}`;
+    console.info(`Running command ${cmd} in ${packageDir}`);
+  }
+  let concat = "";
+  const { stdout, stderr } = await exec(cmd);
+  concat = stdout + stderr;
+  let deps = [];
+  let peerDeps = [];
+  for (const line of concat.split("\n")) {
+    if (line.includes("UNMET OPTIONAL DEPENDENCY")) {
+      const parts = line.match(peerDepsRegex);
+      if (parts && parts.length > 1) {
+        peerDeps.push(parts[1]);
+      }
+    } else {
+      const parts = line.match(depsRegex);
+      if (parts && parts.length > 1) {
+        deps.push(parts[1]);
+      }
+    }
+  }
+  deps = [...new Set(deps)];
+  peerDeps = [...new Set(peerDeps)];
+  return {
+    dependencies: deps.filter((x, i) => i === deps.indexOf(x)),
+    optionalPeerDependencies: peerDeps.filter(
+      (x, i) => i === peerDeps.indexOf(x)
+    )
+  };
+}
+function filterDependencies(deps, filters) {
+  const depsDeduped = deps.filter((x, i) => i === deps.indexOf(x));
+  const depsWithLength = depsDeduped.filter((dep) => dep.length > 0).sort();
+  const exclude = new RegExp(`${filters.join("|")}`);
+  const internal = [];
+  const external = [];
+  for (const dep of depsWithLength) {
+    if (exclude.test(dep)) {
+      external.push(dep);
+    } else {
+      internal.push(dep);
+    }
+  }
+  return { internal, external };
+}
+exports.filterDependencies = filterDependencies;
+exports.getDependencies = getDependencies;
+exports.getExternalsFromReferences = getExternalsFromReferences;
+exports.getTsConfigs = getTsConfigs;

package/dist/cjs/index.cjs

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./vite/index.cjs");
+const dependencies = require("./dependencies.cjs");
+require("./webpack/index.cjs");
+const vitePluginCloseAndCopy = require("./vite/vite-plugin-close-and-copy.cjs");
+const vite_test_config = require("./vite/vite.test.config.cjs");
+const vite_threads_test_config = require("./vite/vite.threads.test.config.cjs");
+const vitePluginSourcemapExclude = require("./vite/vite-plugin-sourcemap-exclude.cjs");
+const vite_frontend_config = require("./vite/vite.frontend.config.cjs");
+const vite_backend_config = require("./vite/vite.backend.config.cjs");
+const vitePluginFixAbsoluteImports = require("./vite/vite-plugin-fix-absolute-imports.cjs");
+const vite_commonjs_config = require("./vite/vite.commonjs.config.cjs");
+const vite_esm_config = require("./vite/vite.esm.config.cjs");
+const vitePluginRemoveUnusedTranslations = require("./vite/vite-plugin-remove-unused-translations.cjs");
+const vitePluginCopy = require("./vite/vite-plugin-copy.cjs");
+const TsNoCheckPlugin = require("./vite/TsNoCheckPlugin.cjs");
+exports.filterDependencies = dependencies.filterDependencies;
+exports.getDependencies = dependencies.getDependencies;
+exports.getExternalsFromReferences = dependencies.getExternalsFromReferences;
+exports.getTsConfigs = dependencies.getTsConfigs;
+exports.VitePluginCloseAndCopy = vitePluginCloseAndCopy;
+exports.ViteTestConfig = vite_test_config;
+exports.ViteThreadsTestConfig = vite_threads_test_config;
+exports.VitePluginSourceMapExclude = vitePluginSourcemapExclude;
+exports.ViteFrontendConfig = vite_frontend_config;
+exports.ViteBackendConfig = vite_backend_config;
+exports.VitePluginFixAbsoluteImports = vitePluginFixAbsoluteImports;
+exports.ViteCommonJSConfig = vite_commonjs_config;
+exports.ViteEsmConfig = vite_esm_config;
+exports.VitePluginRemoveUnusedTranslations = vitePluginRemoveUnusedTranslations.default;
+exports.VitePluginCopy = vitePluginCopy;
+exports.tsNoCheckPlugin = TsNoCheckPlugin.tsNoCheckPlugin;

package/dist/cjs/vite/TsNoCheckPlugin.cjs

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+function tsNoCheckPlugin() {
+  return {
+    name: "vite-plugin-ts-nocheck",
+    // biome-ignore lint/suspicious/noExplicitAny: TODO not sure of options/bundle type (same as NodejsPolarsNativeFilePlugin)
+    generateBundle(_, bundle) {
+      for (const fileName in bundle) {
+        const chunk = bundle[fileName];
+        if (chunk.type === "chunk" && chunk.code) {
+          chunk.code = `// @ts-nocheck
+${chunk.code}`;
+        }
+      }
+    }
+  };
+}
+exports.tsNoCheckPlugin = tsNoCheckPlugin;

package/dist/cjs/vite/index.cjs

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const vitePluginCloseAndCopy = require("./vite-plugin-close-and-copy.cjs");
+const vite_test_config = require("./vite.test.config.cjs");
+const vite_threads_test_config = require("./vite.threads.test.config.cjs");
+const vitePluginSourcemapExclude = require("./vite-plugin-sourcemap-exclude.cjs");
+const vite_frontend_config = require("./vite.frontend.config.cjs");
+const vite_backend_config = require("./vite.backend.config.cjs");
+const vitePluginFixAbsoluteImports = require("./vite-plugin-fix-absolute-imports.cjs");
+const vite_commonjs_config = require("./vite.commonjs.config.cjs");
+const vite_esm_config = require("./vite.esm.config.cjs");
+const vitePluginRemoveUnusedTranslations = require("./vite-plugin-remove-unused-translations.cjs");
+const TsNoCheckPlugin = require("./TsNoCheckPlugin.cjs");
+const vitePluginCopy = require("./vite-plugin-copy.cjs");
+exports.VitePluginCloseAndCopy = vitePluginCloseAndCopy;
+exports.ViteTestConfig = vite_test_config;
+exports.ViteThreadsTestConfig = vite_threads_test_config;
+exports.VitePluginSourceMapExclude = vitePluginSourcemapExclude;
+exports.ViteFrontendConfig = vite_frontend_config;
+exports.ViteBackendConfig = vite_backend_config;
+exports.VitePluginFixAbsoluteImports = vitePluginFixAbsoluteImports;
+exports.ViteCommonJSConfig = vite_commonjs_config;
+exports.ViteEsmConfig = vite_esm_config;
+exports.VitePluginRemoveUnusedTranslations = vitePluginRemoveUnusedTranslations.default;
+exports.tsNoCheckPlugin = TsNoCheckPlugin.tsNoCheckPlugin;
+exports.VitePluginCopy = vitePluginCopy;

package/dist/cjs/vite/vite-plugin-close-and-copy.cjs

@@ -0,0 +1,46 @@
+"use strict";
+const fs = require("node:fs");
+const path = require("node:path");
+function VitePluginCloseAndCopy(options) {
+  const __dirname = path.resolve();
+  return {
+    name: "close-plugin",
+    // required, will show up in warnings and errors
+    buildStart() {
+      console.info("Bundle build started");
+    },
+    buildEnd(error) {
+      console.info("Build end");
+      if (error) {
+        console.log(error);
+        console.error(error);
+      }
+    },
+    closeBundle() {
+      if (options) {
+        for (const destDir of options.destDir) {
+          clearOutputDirJS(__dirname, destDir);
+          console.info(`Bundle cleared from ${options.destDir}`);
+          copyBundle(__dirname, options.srcDir, destDir);
+          console.info(`Bundle copied to ${options.destDir}`);
+        }
+        console.info("Bundle closed");
+      }
+    }
+  };
+}
+const clearOutputDirJS = (__dirname, destDir) => fs.readdirSync(path.resolve(__dirname, destDir)).filter((file) => file.endsWith("js")).map((file) => {
+  fs.rmSync(path.resolve(__dirname, destDir, file));
+});
+const copyBundle = (__dirname, srcDir, destDir) => {
+  console.info(
+    "Copying",
+    path.resolve(__dirname, srcDir),
+    "to",
+    path.resolve(__dirname, destDir)
+  );
+  fs.cpSync(path.resolve(__dirname, srcDir), path.resolve(__dirname, destDir), {
+    recursive: true
+  });
+};
+module.exports = VitePluginCloseAndCopy;

package/dist/cjs/vite/vite-plugin-copy.cjs

@@ -0,0 +1,42 @@
+"use strict";
+const fs = require("node:fs");
+const path = require("node:path");
+const fg = require("fast-glob");
+function ensureDirExists(filePath) {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+function VitePluginCopy(options) {
+  const __dirname = path.resolve();
+  return {
+    name: "copy-plugin",
+    async closeBundle() {
+      const srcAbs = path.resolve(__dirname, options.srcDir);
+      const destAbs = path.resolve(__dirname, options.destDir);
+      const include = options.include && options.include.length > 0 ? options.include : void 0;
+      const exclude = options.exclude || [];
+      if (!include) {
+        console.info(
+          "[copy-plugin] No include globs specified, nothing to copy."
+        );
+        return;
+      }
+      const files = await fg(include, {
+        cwd: srcAbs,
+        ignore: exclude,
+        onlyFiles: true,
+        absolute: false
+      });
+      for (const relFile of files) {
+        const srcFile = path.join(srcAbs, relFile);
+        const destFile = path.join(destAbs, relFile);
+        ensureDirExists(destFile);
+        console.info(`[copy-plugin] copying ${srcFile} to ${destFile}`);
+        fs.copyFileSync(srcFile, destFile);
+      }
+    }
+  };
+}
+module.exports = VitePluginCopy;

package/dist/cjs/vite/vite-plugin-fix-absolute-imports.cjs

@@ -0,0 +1,26 @@
+"use strict";
+const node_module = require("node:module");
+function VitePluginFixAbsoluteImports() {
+  return {
+    name: "fix-absolute-imports",
+    transform(code, id) {
+      for (const module2 of node_module.builtinModules) {
+        const moduleImportRegex = new RegExp(
+          `from "(${module2}(/.*)*/.*.js)";`,
+          "g"
+        );
+        const matches = code.match(moduleImportRegex);
+        if (matches) {
+          for (const match of matches) {
+            code = code.replace(match, `from "${module2}";`);
+          }
+        }
+      }
+      return {
+        code
+      };
+    },
+    enforce: "post"
+  };
+}
+module.exports = VitePluginFixAbsoluteImports;

package/dist/cjs/vite/vite-plugin-remove-unused-translations.cjs

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const fs = require("node:fs/promises");
+const fg = require("fast-glob");
+const used = /* @__PURE__ */ new Set();
+const flatten = (obj, prefix = "") => {
+  const flattenedObj = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (value instanceof Object) {
+      Object.assign(flattenedObj, flatten(value, `${prefix + key}.`));
+    } else {
+      flattenedObj[prefix + key] = value;
+    }
+  }
+  return flattenedObj;
+};
+const unflatten = (obj) => {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    const keys = key.split(".");
+    keys.reduce((acc, k, i) => {
+      if (i === keys.length - 1) {
+        acc[k] = value;
+      } else {
+        if (!acc[k]) {
+          acc[k] = Number.isNaN(Number(keys[i + 1])) ? {} : [];
+        }
+      }
+      return acc[k];
+    }, result);
+  }
+  return result;
+};
+function VitePluginRemoveUnusedTranslations(translationKeys, jsonPattern) {
+  return {
+    name: "remove-unused-translations",
+    transform(code) {
+      for (const key of translationKeys) {
+        if (code.includes(key) && !used.has(key)) {
+          console.info(`Found key: ${key}`);
+          used.add(key);
+        }
+      }
+      return { code };
+    },
+    enforce: "post",
+    async writeBundle() {
+      const jsonFiles = await fg(jsonPattern, { absolute: true });
+      console.info(`Found ${jsonFiles.length} JSON files at ${jsonPattern}`);
+      const filePromises = [];
+      for (const filePath of jsonFiles) {
+        try {
+          const content = await fs.readFile(filePath, "utf-8");
+          const jsonData = JSON.parse(content);
+          const jsonDataFlattened = flatten(jsonData);
+          const filteredData = Object.fromEntries(
+            Object.entries(jsonDataFlattened).filter(([key]) => used.has(key))
+          );
+          const unflattened = unflatten(filteredData);
+          filePromises.push(
+            fs.writeFile(
+              filePath,
+              JSON.stringify(unflattened, null, 2),
+              "utf-8"
+            ).then(() => {
+              console.info(`Updated ${filePath}`);
+            }).catch((e) => {
+              console.error(`Failed to update ${filePath}:`, e);
+            })
+          );
+        } catch (error) {
+          console.error(`Failed to process ${filePath}:`, error);
+        }
+      }
+      await Promise.all(filePromises);
+    }
+  };
+}
+exports.default = VitePluginRemoveUnusedTranslations;
+exports.flatten = flatten;
+exports.unflatten = unflatten;

package/dist/cjs/vite/vite-plugin-sourcemap-exclude.cjs

@@ -0,0 +1,17 @@
+"use strict";
+function VitePluginSourcemapExclude(opts) {
+  return {
+    name: "sourcemap-exclude",
+    transform(code, id) {
+      if (opts?.excludeNodeModules && id.includes("node_modules")) {
+        return {
+          code,
+          // https://github.com/rollup/rollup/blob/master/docs/plugin-development/index.md#source-code-transformations
+          map: { mappings: "" }
+        };
+      }
+      return;
+    }
+  };
+}
+module.exports = VitePluginSourcemapExclude;

package/dist/cjs/vite/vite.backend.config.cjs

@@ -0,0 +1,99 @@
+"use strict";
+const node_module = require("node:module");
+const path = require("node:path");
+const nodeResolve = require("@rollup/plugin-node-resolve");
+const pluginWasm = require("@rollup/plugin-wasm");
+const css = require("rollup-plugin-import-css");
+const dependencies = require("../dependencies.cjs");
+const vitePluginCloseAndCopy = require("./vite-plugin-close-and-copy.cjs");
+const vitePluginFixAbsoluteImports = require("./vite-plugin-fix-absolute-imports.cjs");
+async function vite_backend_config(packageName, packageVersion, bundleName, packageDir, entry, command, mode, outputDir) {
+  const isProduction = mode === "production";
+  const { dependencies: deps, optionalPeerDependencies } = await dependencies.getDependencies(packageName, true);
+  const outDir = outputDir ? path.resolve(outputDir) : path.resolve(packageDir, "dist/bundle");
+  const { external, internal } = dependencies.filterDependencies(deps, [
+    "aws",
+    "webpack",
+    "vite",
+    "biome"
+  ]);
+  const allExternal = [
+    ...node_module.builtinModules,
+    ...node_module.builtinModules.map((m) => `node:${m}`),
+    ...external,
+    ...optionalPeerDependencies
+  ];
+  console.info(
+    `Bundling. ${JSON.stringify(internal.slice(0, 10), null, 2)}... ${internal.length} deps`
+  );
+  const define = {
+    "process.env.WS_NO_BUFFER_UTIL": "true",
+    "process.env.WS_NO_UTF_8_VALIDATE": "true",
+    "process.env.PROSOPO_PACKAGE_VERSION": JSON.stringify(packageVersion),
+    "process.env.NODE_ENV": JSON.stringify(process.env.NODE_ENV || mode),
+    ...process.env.PROSOPO_DEFAULT_ENVIRONMENT && {
+      "process.env.PROSOPO_DEFAULT_ENVIRONMENT": JSON.stringify(
+        process.env.PROSOPO_DEFAULT_ENVIRONMENT
+      )
+    }
+  };
+  console.info(`Defined vars ${JSON.stringify(define, null, 2)}`);
+  let entriesAbsolute;
+  if (typeof entry === "string") {
+    entriesAbsolute = [path.resolve(packageDir, entry)];
+  } else {
+    entriesAbsolute = entry.map((e) => path.resolve(packageDir, e));
+  }
+  const drop = mode === "production" ? ["console", "debugger"] : void 0;
+  return {
+    ssr: {
+      noExternal: internal,
+      external: allExternal
+    },
+    optimizeDeps: {
+      include: ["linked-dep", "node_modules"],
+      esbuildOptions: {
+        loader: {
+          ".node": "file"
+        }
+      }
+    },
+    esbuild: {
+      platform: "node",
+      target: "node18",
+      // drop,
+      legalComments: "none"
+    },
+    define,
+    build: {
+      outDir,
+      minify: isProduction,
+      ssr: true,
+      target: "node18",
+      lib: {
+        entry: entriesAbsolute,
+        name: bundleName,
+        fileName: `${bundleName}.[name].bundle.js`,
+        formats: ["es"]
+      },
+      modulePreload: { polyfill: false },
+      rollupOptions: {
+        treeshake: "smallest",
+        external: allExternal,
+        watch: false,
+        output: {
+          entryFileNames: `${bundleName}.[name].bundle.js`
+        },
+        // biome-ignore lint/suspicious/noExplicitAny: has to be any to represent object prototype
+        plugins: [css(), pluginWasm.wasm(), nodeResolve.nodeResolve()]
+      }
+    },
+    plugins: [
+      // plugin to replace stuff like import blah from string_encoder/lib/string_encoder.js with import blah from string_encoder
+      vitePluginFixAbsoluteImports(),
+      // plugin to close the bundle after build if not in serve mode
+      command !== "serve" ? vitePluginCloseAndCopy() : void 0
+    ]
+  };
+}
+module.exports = vite_backend_config;