@k8slens/package-build 2.2.3

package/src/package-build.ts

@@ -0,0 +1,231 @@
+import { type Plugin, 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: string) => module.startsWith("_");
+const alsoAddNodeRefs = (module: string) => [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: string) => {
+  const [firstPart, secondPart] = path.split("/");
+
+  if (path.startsWith("@")) {
+    return [firstPart, secondPart].join("/");
+  }
+
+  return firstPart;
+};
+
+const bundleDependency = null;
+
+const ensureCorrectImportsPlugin: Plugin = {
+  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"] as const,
+      default: "cjs" as const,
+      description: `Transpilation output format, defaults to "cjs"`,
+    },
+  })
+  .parseSync(process.argv);
+
+// Copied from https://github.com/evanw/esbuild/issues/1051
+const nativeNodeModulesPlugin: Plugin = {
+  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: Plugin = {
+  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);
+  }
+};

package/src/svg-transformer.js

@@ -0,0 +1,7 @@
+module.exports = {
+  process(sourceText, sourcePath, options) {
+    return {
+      code: `module.exports = '<svg></svg>';`,
+    };
+  },
+};