@prosopo/config 2.5.3 → 3.1.0

package/CHANGELOG.md

@@ -0,0 +1,34 @@
+# @prosopo/config
+
+## 3.1.0
+### Minor Changes
+
+- 745cc89: Remove plugins from test config
+
+## 3.0.1
+### Patch Changes
+
+- 5619b4b: Updating tsconfig paths
+
+## 3.0.0
+### Major Changes
+
+- 64b5bcd: Access Controls
+
+## 2.6.1
+### Patch Changes
+
+- 86c22b8: structured logging
+
+## 2.6.0
+
+### Minor Changes
+
+- a0bfc8a: bump all pkg versions since independent versioning applied
+
+### Patch Changes
+
+- Updated dependencies [a0bfc8a]
+  - @prosopo/common@2.6.0
+  - @prosopo/types@2.6.0
+  - @prosopo/util@2.6.0

package/dist/cjs/dependencies.cjs

@@ -0,0 +1,155 @@
+"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}`);
+  }
+  const { stdout, stderr } = await exec(cmd);
+  if (stderr) {
+    throw new Error("CONFIG.INVALID_PACKAGE_DIR");
+  }
+  const deps = [];
+  const peerDeps = [];
+  for (const line of stdout.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]);
+      }
+    }
+  }
+  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,65 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+require("./vite/index.cjs");
+const dependencies = require("./dependencies.cjs");
+const projectInfo = require("./projectInfo.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 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 vitePluginRemoveUnusedTranslations = require("./vite/vite-plugin-remove-unused-translations.cjs");
+const TsNoCheckPlugin = require("./vite/TsNoCheckPlugin.cjs");
+exports.filterDependencies = dependencies.filterDependencies;
+exports.getDependencies = dependencies.getDependencies;
+exports.getExternalsFromReferences = dependencies.getExternalsFromReferences;
+exports.getTsConfigs = dependencies.getTsConfigs;
+exports.getAccountPkgDir = projectInfo.getAccountPkgDir;
+exports.getApiPkgDir = projectInfo.getApiPkgDir;
+exports.getCacheDir = projectInfo.getCacheDir;
+exports.getCliPkgDir = projectInfo.getCliPkgDir;
+exports.getClientBundleExampleDir = projectInfo.getClientBundleExampleDir;
+exports.getClientExampleDir = projectInfo.getClientExampleDir;
+exports.getClientExampleServerDir = projectInfo.getClientExampleServerDir;
+exports.getCommonPkgDir = projectInfo.getCommonPkgDir;
+exports.getConfigPkgDir = projectInfo.getConfigPkgDir;
+exports.getDappExampleDir = projectInfo.getDappExampleDir;
+exports.getDatabasePkgDir = projectInfo.getDatabasePkgDir;
+exports.getDatasetsFsPkgDir = projectInfo.getDatasetsFsPkgDir;
+exports.getDatasetsPkgDir = projectInfo.getDatasetsPkgDir;
+exports.getDemosDir = projectInfo.getDemosDir;
+exports.getDevDir = projectInfo.getDevDir;
+exports.getDotEnvPkgDir = projectInfo.getDotEnvPkgDir;
+exports.getEnvPkgDir = projectInfo.getEnvPkgDir;
+exports.getFileServerPkgDir = projectInfo.getFileServerPkgDir;
+exports.getLocalePkgDir = projectInfo.getLocalePkgDir;
+exports.getNodeModulesDir = projectInfo.getNodeModulesDir;
+exports.getPackagesDir = projectInfo.getPackagesDir;
+exports.getProcaptchaBundlePkgDir = projectInfo.getProcaptchaBundlePkgDir;
+exports.getProcaptchaCommonPkgDir = projectInfo.getProcaptchaCommonPkgDir;
+exports.getProcaptchaFrictionlessPkgDir = projectInfo.getProcaptchaFrictionlessPkgDir;
+exports.getProcaptchaPkgDir = projectInfo.getProcaptchaPkgDir;
+exports.getProcaptchaPoWPkgDir = projectInfo.getProcaptchaPoWPkgDir;
+exports.getProcaptchaReactPkgDir = projectInfo.getProcaptchaReactPkgDir;
+exports.getProviderPkgDir = projectInfo.getProviderPkgDir;
+exports.getRootDir = projectInfo.getRootDir;
+exports.getScriptsPkgDir = projectInfo.getScriptsPkgDir;
+exports.getServerPkgDir = projectInfo.getServerPkgDir;
+exports.getTestResultsDir = projectInfo.getTestResultsDir;
+exports.getTypesDatabasePkgDir = projectInfo.getTypesDatabasePkgDir;
+exports.getTypesEnvPkgDir = projectInfo.getTypesEnvPkgDir;
+exports.getTypesPkgDir = projectInfo.getTypesPkgDir;
+exports.getUtilPkgDir = projectInfo.getUtilPkgDir;
+exports.getWidgetSkeletonPkgDir = projectInfo.getWidgetSkeletonPkgDir;
+exports.VitePluginCloseAndCopy = vitePluginCloseAndCopy;
+exports.ViteTestConfig = vite_test_config;
+exports.VitePluginSourceMapExclude = vitePluginSourcemapExclude;
+exports.ViteFrontendConfig = vite_frontend_config;
+exports.ViteBackendConfig = vite_backend_config;
+exports.VitePluginFixAbsoluteImports = vitePluginFixAbsoluteImports;
+exports.ViteCommonJSConfig = vite_commonjs_config;
+exports.VitePluginRemoveUnusedTranslations = vitePluginRemoveUnusedTranslations.default;
+exports.tsNoCheckPlugin = TsNoCheckPlugin.tsNoCheckPlugin;

package/dist/cjs/projectInfo.cjs

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const getRootDir = () => new URL("../../..", module).pathname.slice(0, -1);
+const getCacheDir = () => `${getRootDir()}/.cache`;
+const getTestResultsDir = () => `${getCacheDir()}/test-results`;
+const getDevDir = () => `${getRootDir()}/dev`;
+const getDemosDir = () => `${getRootDir()}/demos`;
+const getPackagesDir = () => `${getRootDir()}/packages`;
+const getNodeModulesDir = () => `${getRootDir()}/node_modules`;
+const getConfigPkgDir = () => `${getDevDir()}/config`;
+const getScriptsPkgDir = () => `${getDevDir()}/scripts`;
+const getClientExampleDir = () => `${getDemosDir()}/client-example`;
+const getClientExampleServerDir = () => `${getDemosDir()}/client-example-server`;
+const getClientBundleExampleDir = () => `${getDemosDir()}/client-bundle-example`;
+const getDappExampleDir = () => `${getDemosDir()}/dapp-example`;
+const getAccountPkgDir = () => `${getPackagesDir()}/account`;
+const getApiPkgDir = () => `${getPackagesDir()}/api`;
+const getCliPkgDir = () => `${getPackagesDir()}/cli`;
+const getCommonPkgDir = () => `${getPackagesDir()}/common`;
+const getDatabasePkgDir = () => `${getPackagesDir()}/database`;
+const getDatasetsPkgDir = () => `${getPackagesDir()}/datasets`;
+const getDatasetsFsPkgDir = () => `${getPackagesDir()}/datasets-fs`;
+const getDotEnvPkgDir = () => `${getPackagesDir()}/dotenv`;
+const getEnvPkgDir = () => `${getPackagesDir()}/env`;
+const getFileServerPkgDir = () => `${getPackagesDir()}/file-server`;
+const getProcaptchaPkgDir = () => `${getPackagesDir()}/procaptcha`;
+const getProcaptchaBundlePkgDir = () => `${getPackagesDir()}/procaptcha-bundle`;
+const getProcaptchaCommonPkgDir = () => `${getPackagesDir()}/procaptcha-common`;
+const getProcaptchaFrictionlessPkgDir = () => `${getPackagesDir()}/procaptcha-frictionless`;
+const getProcaptchaPoWPkgDir = () => `${getPackagesDir()}/procaptcha-pow`;
+const getProcaptchaReactPkgDir = () => `${getPackagesDir()}/procaptcha-react`;
+const getProviderPkgDir = () => `${getPackagesDir()}/provider`;
+const getServerPkgDir = () => `${getPackagesDir()}/server`;
+const getTypesPkgDir = () => `${getPackagesDir()}/types`;
+const getTypesDatabasePkgDir = () => `${getPackagesDir()}/types-database`;
+const getTypesEnvPkgDir = () => `${getPackagesDir()}/types-env`;
+const getUtilPkgDir = () => `${getPackagesDir()}/util`;
+const getWidgetSkeletonPkgDir = () => `${getPackagesDir()}/widget-skeleton`;
+const getLocalePkgDir = () => `${getPackagesDir()}/locale`;
+exports.getAccountPkgDir = getAccountPkgDir;
+exports.getApiPkgDir = getApiPkgDir;
+exports.getCacheDir = getCacheDir;
+exports.getCliPkgDir = getCliPkgDir;
+exports.getClientBundleExampleDir = getClientBundleExampleDir;
+exports.getClientExampleDir = getClientExampleDir;
+exports.getClientExampleServerDir = getClientExampleServerDir;
+exports.getCommonPkgDir = getCommonPkgDir;
+exports.getConfigPkgDir = getConfigPkgDir;
+exports.getDappExampleDir = getDappExampleDir;
+exports.getDatabasePkgDir = getDatabasePkgDir;
+exports.getDatasetsFsPkgDir = getDatasetsFsPkgDir;
+exports.getDatasetsPkgDir = getDatasetsPkgDir;
+exports.getDemosDir = getDemosDir;
+exports.getDevDir = getDevDir;
+exports.getDotEnvPkgDir = getDotEnvPkgDir;
+exports.getEnvPkgDir = getEnvPkgDir;
+exports.getFileServerPkgDir = getFileServerPkgDir;
+exports.getLocalePkgDir = getLocalePkgDir;
+exports.getNodeModulesDir = getNodeModulesDir;
+exports.getPackagesDir = getPackagesDir;
+exports.getProcaptchaBundlePkgDir = getProcaptchaBundlePkgDir;
+exports.getProcaptchaCommonPkgDir = getProcaptchaCommonPkgDir;
+exports.getProcaptchaFrictionlessPkgDir = getProcaptchaFrictionlessPkgDir;
+exports.getProcaptchaPkgDir = getProcaptchaPkgDir;
+exports.getProcaptchaPoWPkgDir = getProcaptchaPoWPkgDir;
+exports.getProcaptchaReactPkgDir = getProcaptchaReactPkgDir;
+exports.getProviderPkgDir = getProviderPkgDir;
+exports.getRootDir = getRootDir;
+exports.getScriptsPkgDir = getScriptsPkgDir;
+exports.getServerPkgDir = getServerPkgDir;
+exports.getTestResultsDir = getTestResultsDir;
+exports.getTypesDatabasePkgDir = getTypesDatabasePkgDir;
+exports.getTypesEnvPkgDir = getTypesEnvPkgDir;
+exports.getTypesPkgDir = getTypesPkgDir;
+exports.getUtilPkgDir = getUtilPkgDir;
+exports.getWidgetSkeletonPkgDir = getWidgetSkeletonPkgDir;

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,20 @@
+"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 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 vitePluginRemoveUnusedTranslations = require("./vite-plugin-remove-unused-translations.cjs");
+const TsNoCheckPlugin = require("./TsNoCheckPlugin.cjs");
+exports.VitePluginCloseAndCopy = vitePluginCloseAndCopy;
+exports.ViteTestConfig = vite_test_config;
+exports.VitePluginSourceMapExclude = vitePluginSourcemapExclude;
+exports.ViteFrontendConfig = vite_frontend_config;
+exports.ViteBackendConfig = vite_backend_config;
+exports.VitePluginFixAbsoluteImports = vitePluginFixAbsoluteImports;
+exports.ViteCommonJSConfig = vite_commonjs_config;
+exports.VitePluginRemoveUnusedTranslations = vitePluginRemoveUnusedTranslations.default;
+exports.tsNoCheckPlugin = TsNoCheckPlugin.tsNoCheckPlugin;

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-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 glob = 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 glob(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,98 @@
+"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`
+        },
+        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;