@k8slens/package-build 2.2.3

package/index.js

@@ -0,0 +1,2 @@
+export { globImportPlugin } from "./src/glob-import-plugin";
+export { packageBuild } from "./src/package-build";

package/package.json

@@ -0,0 +1,93 @@
+{
+  "name": "@k8slens/package-build",
+  "version": "2.2.3",
+  "lens": {
+    "env": "agnostic",
+    "layer": "infrastructure",
+    "role": "library",
+    "visibility": "public-for-all"
+  },
+  "private": false,
+  "description": "Build script for constituent packages of Lens Desktop",
+  "homepage": "https://k8slens.dev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lensapp/lens-desktop-monorepo.git"
+  },
+  "license": "MIT",
+  "author": "Mirantis Inc. <info@k8slens.dev>",
+  "type": "commonjs",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./transformer": {
+      "require": "./src/glob-import-transformer.js",
+      "import": "./src/glob-import-transformer.js",
+      "default": "./src/glob-import-transformer.js"
+    },
+    "./svg-transformer": {
+      "require": "./src/svg-transformer.js",
+      "import": "./src/svg-transformer.js",
+      "default": "./src/svg-transformer.js"
+    },
+    "./png-transformer": {
+      "require": "./src/image-transformer.js",
+      "import": "./src/image-transformer.js",
+      "default": "./src/image-transformer.js"
+    }
+  },
+  "bin": {
+    "lens-package-build": "bin/package-build"
+  },
+  "files": [
+    "index.js",
+    "src",
+    "bin",
+    "dist"
+  ],
+  "scripts": {
+    "build:infrastructure:code": "esbuild --bundle index.ts --outfile=dist/index.js --external:node:* --external:postcss --external:esbuild --external:fast-glob --external:esbuild-sass-plugin --external:yargs --external:tailwindcss --format=cjs",
+    "build:infrastructure:types": "tsc --project .",
+    "build:infrastructure": "npm run build:infrastructure:code; npm run build:infrastructure:types",
+    "lint": "lens-verify-code-style",
+    "clean": "exit 0",
+    "check-types:tests": "lens-types-build --checkTypesTests"
+  },
+  "dependencies": {
+    "esbuild": "^0.25.4",
+    "esbuild-sass-plugin": "^3.3.1",
+    "fast-glob": "^3.3.3",
+    "lodash": "^4.17.21",
+    "postcss": "^8.5.18",
+    "postcss-modules": "^6.0.1",
+    "tailwindcss": "^3.4.17",
+    "yargs": "^17.7.2"
+  },
+  "devDependencies": {
+    "@async-fn/jest": "^1.6.4",
+    "@k8slens/typescript": "^7.2.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "nx": {
+    "targets": {
+      "build:infrastructure": {
+        "inputs": [
+          "{projectRoot}/bin/package-build",
+          "{projectRoot}/index.ts",
+          "{projectRoot}/src/**/*.ts"
+        ],
+        "outputs": [
+          "{projectRoot}/dist/index.js",
+          "{projectRoot}/bin/package-build"
+        ]
+      }
+    }
+  }
+}

package/src/glob-import-plugin.js

@@ -0,0 +1,46 @@
+import glob from "fast-glob";
+import { randomUUID } from "node:crypto";
+import { resolve as resolvePath } from "node:path";
+export const globImportPlugin = () => ({
+    name: "glob-import-plugin",
+    setup: (build) => {
+        const uniquenessCache = new Map();
+        build.onResolve({ filter: /\*/ }, async (args) => {
+            const { resolveDir, path } = args;
+            if (resolveDir === "") {
+                return; // Ignore unresolvable paths
+            }
+            const cacheKey = resolvePath(resolveDir, path);
+            const uniqueId = getOrInsertWith(uniquenessCache, cacheKey, getRandomUniqueId);
+            return {
+                path: `${path}/proof-of-uniqueness/${uniqueId}`,
+                namespace: "import-glob",
+                pluginData: { resolveDir },
+            };
+        });
+        build.onLoad({ filter: /.*/, namespace: "import-glob" }, async (args) => {
+            const { path, pluginData: { resolveDir }, } = args;
+            const [globImportString] = path.split("/proof-of-uniqueness/");
+            const files = (await glob(globImportString, { cwd: resolveDir })).sort();
+            const contents = [
+                files.map((module, index) => `import * as module${index} from './${module}'`).join(";"),
+                "",
+                `const modules = [${files.map((_, index) => `module${index}`).join(",")}];`,
+                "",
+                "export default modules;",
+                `export const filenames = [${files.map((module) => `'${module}'`).join(",")}]`,
+                "",
+            ].join("\n");
+            return { contents, resolveDir };
+        });
+    },
+});
+const getRandomUniqueId = () => randomUUID();
+const getOrInsertWith = (map, key, builder) => {
+    if (map.has(key)) {
+        return map.get(key);
+    }
+    const value = builder();
+    map.set(key, value);
+    return value;
+};

package/src/glob-import-plugin.ts

@@ -0,0 +1,63 @@
+import type { Plugin } from "esbuild";
+import glob from "fast-glob";
+import { randomUUID } from "node:crypto";
+import { resolve as resolvePath } from "node:path";
+
+export const globImportPlugin = (): Plugin => ({
+  name: "glob-import-plugin",
+
+  setup: (build) => {
+    const uniquenessCache = new Map<string, string>();
+
+    build.onResolve({ filter: /\*/ }, async (args) => {
+      const { resolveDir, path } = args;
+
+      if (resolveDir === "") {
+        return; // Ignore unresolvable paths
+      }
+
+      const cacheKey = resolvePath(resolveDir, path);
+      const uniqueId = getOrInsertWith(uniquenessCache, cacheKey, getRandomUniqueId);
+
+      return {
+        path: `${path}/proof-of-uniqueness/${uniqueId}`,
+        namespace: "import-glob",
+        pluginData: { resolveDir },
+      };
+    });
+
+    build.onLoad({ filter: /.*/, namespace: "import-glob" }, async (args) => {
+      const {
+        path,
+        pluginData: { resolveDir },
+      } = args;
+      const [globImportString] = path.split("/proof-of-uniqueness/");
+      const files = (await glob(globImportString, { cwd: resolveDir })).sort();
+
+      const contents = [
+        files.map((module, index) => `import * as module${index} from './${module}'`).join(";"),
+        "",
+        `const modules = [${files.map((_, index) => `module${index}`).join(",")}];`,
+        "",
+        "export default modules;",
+        `export const filenames = [${files.map((module) => `'${module}'`).join(",")}]`,
+        "",
+      ].join("\n");
+
+      return { contents, resolveDir };
+    });
+  },
+});
+
+const getRandomUniqueId = () => randomUUID();
+const getOrInsertWith = <K, V>(map: Map<K, V>, key: K, builder: () => V) => {
+  if (map.has(key)) {
+    return map.get(key) as V;
+  }
+
+  const value = builder();
+
+  map.set(key, value);
+
+  return value;
+};

package/src/glob-import-transformer.js

@@ -0,0 +1,171 @@
+const { transformSync } = require("esbuild");
+const { glob, sync: globSync } = require("fast-glob");
+const path = require("path");
+const crypto = require("crypto");
+
+const loaders = ["js", "jsx", "ts", "tsx"];
+const globImportRegex = /import (?<dynamicImportVariableName>(?:[^,{}\s]+(?:\s*,\s*)?)?(?:\{[^}]*\})?[^,{}\s]*) from "(?<dynamicImportGlob>.*?\*.*?)";/g;
+
+const discoverGlobFilesSync = (sourcePath, globText) => globSync(globText, {
+  cwd: path.dirname(sourcePath),
+}).sort();
+const discoverGlobFiles = async (sourcePath, globText) => {
+  const files = await glob(globText, {
+    cwd: path.dirname(sourcePath),
+  });
+
+  return files.sort();
+};
+const cacheLength = process.platform === 'win32' ? 16 : 32;
+
+// Salts the cache key so that changing this transformer or its esbuild options
+// invalidates entries jest has already written to disk. Bump on every change to
+// generateReplacementCode or getEsbuildTransformOptions.
+const transformerVersion = "2";
+
+const generateReplacementCode = (files, dynamicImportVariableName) => {
+  // Parse import names inline
+  const trimmed = dynamicImportVariableName.trim();
+  const defaultImport = trimmed.match(/^([^,{}\s]+)(?:\s*,)?/)?.[1]?.trim();
+  const destructuredMatch = trimmed.match(/\{([^}]*)\}/);
+  const destructuredImports = destructuredMatch 
+    ? destructuredMatch[1].split(',').map(name => name.trim()).filter(Boolean)
+    : [];
+
+  const imports = files
+    .map(
+      (module, index) =>
+        `import * as ${defaultImport}Module${index} from "./${module}";`,
+    )
+    .join("\n");
+
+  const moduleEntries = files.map((file, index) => `${defaultImport}Module${index}`);
+  
+  const declarations = [];
+  if (defaultImport) {
+    declarations.push(`const ${defaultImport} = [${moduleEntries.join(", ")}];\n`);
+  }
+  if (destructuredImports.length > 0) {
+    const filenamesArray = files.map(file => `"${path.basename(file, path.extname(file))}"`);
+    declarations.push(`const { ${destructuredImports.join(', ')} } = { filenames: [${filenamesArray.join(', ')}] };\n`);
+  }
+
+  return `${imports}\n${declarations.join("\n")}`;
+};
+
+// Deliberately not salted with NODE_ENV: getEsbuildTransformOptions is a pure function of the
+// file extension, so the output cannot vary with it, and salting only fragmented the cache
+// between local runs (where jest sets NODE_ENV=test) and CI.
+const computeCacheKey = (globImportedFiles, sourceText, sourcePath, options) => {
+  return crypto.createHash("sha1")
+    .update(transformerVersion)
+    .update('\0', 'utf8')
+    .update(globImportedFiles.join(","))
+    .update('\0', 'utf8')
+    .update(sourceText)
+    .update('\0', 'utf8')
+    .update(options.config.rootDir ? path.relative(options.config.rootDir, sourcePath) : "")
+    .update('\0', 'utf8')
+    .update(options.instrument ? 'instrument' : '')
+    .update('\0', 'utf8')
+    .digest('hex')
+    .substring(0, cacheLength);
+};
+
+module.exports = {
+  createTransformer: () => ({
+    getCacheKey: (sourceText, sourcePath, options) => {
+      const matches = sourceText.matchAll(globImportRegex);
+      const globImportedFiles = [];
+
+      for (const match of matches) {
+        const { dynamicImportGlob } = match.groups;
+
+        globImportedFiles.push(...discoverGlobFilesSync(sourcePath, dynamicImportGlob));
+      }
+
+      return computeCacheKey(globImportedFiles, sourceText, sourcePath, options);
+    },
+    getCacheKeyAsync: async (sourceText, sourcePath, options) => {
+      const matches = sourceText.matchAll(globImportRegex);
+      const globImportedFiles = [];
+
+      for (const match of matches) {
+        const { dynamicImportGlob } = match.groups;
+
+        globImportedFiles.push(...await discoverGlobFiles(sourcePath, dynamicImportGlob));
+      }
+
+      return computeCacheKey(globImportedFiles, sourceText, sourcePath, options);
+    },
+    process: (sourceText, sourcePath) => {
+      const inputWithNormalImports = replaceGlobImportsWithNormalImportsSync({
+        sourceText,
+        sourcePath,
+      });
+
+      return transformSync(inputWithNormalImports, getEsbuildTransformOptions(sourcePath));
+    },
+    processAsync: async (sourceText, sourcePath) => {
+      const inputWithNormalImports = await replaceGlobImportsWithNormalImports({
+        sourceText,
+        sourcePath,
+      });
+
+      return transformSync(inputWithNormalImports, getEsbuildTransformOptions(sourcePath));
+    },
+  }),
+}
+
+const getEsbuildTransformOptions = (sourcePath) => {
+  const extname = path.extname(sourcePath);
+
+  return ({
+    target: "node16",
+    platform: "browser",
+    format: "cjs",
+    loader: loaders.find((x) => `.${x}` === extname),
+    // External rather than inline: esbuild then returns the map separately, so
+    // jest caches it as its own file and resolves it lazily for stack traces
+    // instead of compiling a base64 copy into every suite that loads the module.
+    sourcemap: true,
+    sourcefile: sourcePath,
+    tsconfigRaw: {
+      compilerOptions: { experimentalDecorators: true },
+    },
+  });
+};
+
+const replaceGlobImportsWithNormalImportsSync = ({ sourceText, sourcePath }) =>
+  sourceText.replace(
+    globImportRegex,
+    (all, dynamicImportVariableName, dynamicImportGlob) => {
+      const files = discoverGlobFilesSync(sourcePath, dynamicImportGlob);
+      return generateReplacementCode(files, dynamicImportVariableName);
+    },
+  );
+
+async function replaceAsync(text, matcher, replacer) {
+  const substrings = [];
+    let match;
+    let i = 0;
+    while ((match = matcher.exec(text)) !== null) {
+        substrings.push(text.slice(i, match.index));
+        substrings.push(replacer(...match));
+        i = matcher.lastIndex;
+    }
+    // put the rest of text
+    substrings.push(text.slice(i));
+    // wait for aReplacer calls to finish and join them back into string
+    return (await Promise.all(substrings)).join('');
+}
+
+const replaceGlobImportsWithNormalImports = async ({ sourceText, sourcePath }) =>
+  replaceAsync(
+    sourceText,
+    globImportRegex,
+    async (all, dynamicImportVariableName, dynamicImportGlob) => {
+      const files = await discoverGlobFiles(sourcePath, dynamicImportGlob);
+      return generateReplacementCode(files, dynamicImportVariableName);
+    },
+  );

package/src/image-transformer.js

@@ -0,0 +1,9 @@
+module.exports = {
+  process(sourceText, sourcePath, options) {
+    const parts = sourcePath.split("/");
+
+    return {
+      code: `module.exports = '${parts[parts.length - 1]}';`,
+    };
+  },
+};

package/src/package-build.js

@@ -0,0 +1,193 @@
+import { build } from "esbuild";
+import path from "node:path";
+import { sassPlugin, postcssModules } from "esbuild-sass-plugin";
+import { readFileSync } from "node:fs";
+import { builtinModules as rawBuiltinModules } from "node:module";
+import yargs from "yargs";
+import { globImportPlugin } from "./glob-import-plugin";
+import tailwindcss from "tailwindcss";
+import { partition } from "lodash";
+const CWD = process.cwd();
+const packageJson = JSON.parse(readFileSync(path.resolve(CWD, "package.json"), "utf-8"));
+const isExperimentalModule = (module) => module.startsWith("_");
+const alsoAddNodeRefs = (module) => [module, `node:${module}`];
+const { builtinModules, disallowedBuiltinModules } = (() => {
+    const [disallowed, allowed] = partition(rawBuiltinModules, isExperimentalModule);
+    const disallowedBuiltinModules = new Set(disallowed.flatMap(alsoAddNodeRefs));
+    const builtinModules = new Set(allowed.flatMap(alsoAddNodeRefs));
+    return { disallowedBuiltinModules, builtinModules };
+})();
+const getPackageName = (path) => {
+    const [firstPart, secondPart] = path.split("/");
+    if (path.startsWith("@")) {
+        return [firstPart, secondPart].join("/");
+    }
+    return firstPart;
+};
+const bundleDependency = null;
+const ensureCorrectImportsPlugin = {
+    name: "ensure-correct-imports",
+    setup: (build) => {
+        build.onResolve({ filter: /^\./ }, (args) => {
+            const fullPath = path.resolve(args.resolveDir, args.path);
+            const relativePathToImporter = path.relative(CWD, args.importer);
+            const relativePath = path.relative(CWD, fullPath);
+            if (relativePath.startsWith("..") && !relativePathToImporter.startsWith("..")) {
+                throw new Error(`Tried to import "${args.path}" from "${relativePathToImporter}" but it is outside of the package.`);
+            }
+            return bundleDependency;
+        });
+        build.onResolve({ filter: /^[^.]/ }, async (args) => {
+            // Enforce declared imports only for the package's own sources (.ts/.tsx/.js/.jsx).
+            // Anything imported from outside the package directory — node_modules files or
+            // other workspace packages' dists (whose realpaths live outside node_modules) —
+            // belongs to an already-bundled dependency and must keep bundling freely.
+            const relativePathToImporter = path.relative(CWD, args.importer);
+            const importerIsOwnFile = !relativePathToImporter.startsWith("..") &&
+                !relativePathToImporter.split(path.sep).includes("node_modules");
+            const importerIsSourceFile = /\.(t|j)sx?$/.test(args.importer);
+            if (!importerIsOwnFile || !importerIsSourceFile) {
+                return bundleDependency;
+            }
+            if (disallowedBuiltinModules.has(args.path)) {
+                throw new Error(`Tried to import "${args.path}" from "${args.importer}" but it is a disallowed builtin module.`);
+            }
+            if (builtinModules.has(args.path)) {
+                return {
+                    external: true,
+                    path: args.path,
+                };
+            }
+            const packageName = getPackageName(args.path);
+            const isExplicitDependency = packageName in (packageJson.dependencies ?? {});
+            const isExplicitDevDependency = packageName in (packageJson.devDependencies ?? {});
+            if (isExplicitDependency) {
+                // Note: Return the full path since we assume that it is a "exports" entry of the dependency found in package.json
+                return {
+                    external: true,
+                    path: args.path,
+                };
+            }
+            if (isExplicitDevDependency) {
+                return bundleDependency;
+            }
+            throw new Error(`Tried to import "${args.path}" from "${relativePathToImporter}" but it is not a dependency of the package.`);
+        });
+    },
+};
+const parsedArgs = yargs()
+    .options({
+    tsconfig: {
+        type: "string",
+        default: "tsconfig.json",
+        description: 'Custom tsconfig.json -file, defaults to "tsconfig.json"',
+    },
+    "entry-point": {
+        type: "string",
+        default: "index.ts",
+        description: 'Custom entry-point, defaults to "index.ts"',
+    },
+    outfile: {
+        type: "string",
+        default: path.resolve(CWD, "dist/index.js"),
+        description: `Custom outfile, defaults to "dist/index.js"`,
+    },
+    format: {
+        choices: ["cjs", "esm"],
+        default: "cjs",
+        description: `Transpilation output format, defaults to "cjs"`,
+    },
+})
+    .parseSync(process.argv);
+// Copied from https://github.com/evanw/esbuild/issues/1051
+const nativeNodeModulesPlugin = {
+    name: "native-node-modules",
+    setup(build) {
+        // If a ".node" file is imported within a module in the "file" namespace, resolve
+        // it to an absolute path and put it into the "node-file" virtual namespace.
+        build.onResolve({ filter: /\.node$/, namespace: "file" }, (args) => ({
+            path: require.resolve(args.path, { paths: [args.resolveDir] }),
+            namespace: "node-file",
+        }));
+        // Files in the "node-file" virtual namespace call "require()" on the
+        // path from esbuild of the ".node" file in the output directory.
+        build.onLoad({ filter: /.*/, namespace: "node-file" }, (args) => ({
+            contents: `
+        import path from ${JSON.stringify(args.path)}
+        try { module.exports = require(path) }
+        catch {}
+      `,
+        }));
+        // If a ".node" file is imported within a module in the "node-file" namespace, put
+        // it in the "file" namespace where esbuild's default loading behavior will handle
+        // it. It is already an absolute path since we resolved it to one above.
+        build.onResolve({ filter: /\.node$/, namespace: "node-file" }, (args) => ({
+            path: args.path,
+            namespace: "file",
+        }));
+        // Tell esbuild's default loading behavior to use the "file" loader for
+        // these ".node" files.
+        const opts = build.initialOptions;
+        opts.loader = opts.loader || {};
+        opts.loader[".node"] = "file";
+    },
+};
+// Keep .png imports as require() calls in the dist bundle instead of inlining
+// them as base64 data urls, so images ship as files loaded on demand rather
+// than megabytes of string literals in every consuming bundle. The import
+// path is rewritten to stay correct relative to the output file, since the
+// application build resolves it from there with its "file" loader.
+const externalImagesPlugin = {
+    name: "external-images",
+    setup(build) {
+        build.onResolve({ filter: /\.png$/ }, (args) => {
+            const absolutePath = path.resolve(args.resolveDir, args.path);
+            const outputDirectory = path.dirname(path.resolve(CWD, parsedArgs.outfile));
+            const relativePath = path.relative(outputDirectory, absolutePath).split(path.sep).join("/");
+            return {
+                path: relativePath.startsWith(".") ? relativePath : `./${relativePath}`,
+                external: true,
+            };
+        });
+    },
+};
+export const packageBuild = async () => {
+    try {
+        await build({
+            entryPoints: [parsedArgs.entryPoint],
+            tsconfig: parsedArgs.tsconfig,
+            outfile: parsedArgs.outfile,
+            format: parsedArgs.format,
+            bundle: true,
+            platform: "node",
+            target: "node16",
+            sourcemap: "inline",
+            plugins: [
+                ensureCorrectImportsPlugin,
+                externalImagesPlugin,
+                globImportPlugin(),
+                sassPlugin({
+                    filter: /\.module\.scss$/,
+                    transform: postcssModules({
+                        basedir: __dirname,
+                        generateScopedName: "[name]__[local]___[hash:base64:5]",
+                    }, [tailwindcss]),
+                }),
+                sassPlugin({
+                    filter: /\.scss$/,
+                }),
+                nativeNodeModulesPlugin,
+            ],
+            loader: {
+                ".ttf": "dataurl",
+                ".svg": "text",
+                ".yaml": "text",
+                ".yml": "text",
+                ".yml.hb": "text",
+            },
+        });
+    }
+    catch {
+        process.exit(1);
+    }
+};