@freshpack/webpack 0.0.0-stage → 1.0.0

package/unmap.ts

@@ -0,0 +1,154 @@
+import type * as Webpack from "webpack";
+import { assert } from "@std/assert";
+
+interface UnmapCompilation extends Webpack.Compilation {
+  unmapping: Record<string, string>;
+}
+
+export function assertUnmapCompilation(
+  compilation: Webpack.Compilation,
+): asserts compilation is UnmapCompilation {
+  assert(
+    "unmapping" in compilation,
+    "missing fresh data in compilation, did you add WebpackFreshEntries plugin?",
+  );
+}
+export class UnmapPlugin {
+  apply(compiler: Webpack.Compiler) {
+    const mappings = new Map<
+      string,
+      { name: string; module: Webpack.Module; loc: Webpack.Dependency["loc"] }
+    >();
+    const nameToRequest = new Map<string, string>();
+    const nameToAsset = new Map<string, string>();
+
+    compiler.hooks.compilation.tap(
+      UnmapPlugin.name,
+      (compilation, { normalModuleFactory }) => {
+        normalModuleFactory.hooks.parser.for("javascript/auto").tap(
+          UnmapPlugin.name,
+          (parser) => {
+            parser.hooks.call.for("unmap").tap(UnmapPlugin.name, (expr) => {
+              const error = (msg: string) => {
+                const err = new compiler.webpack.WebpackError(msg);
+                err.loc = expr.loc!;
+                parser.state.module.addError(
+                  err,
+                );
+              };
+              if (expr.arguments.length !== 2) {
+                return error(`unmap requires (name, new URL()) arguments`);
+              }
+
+              const nameArg = parser.evaluateExpression(expr.arguments[0]);
+              if (!nameArg.isString()) {
+                return error(
+                  `first argument for unmap should be a static string`,
+                );
+              }
+
+              const urlExpr = expr.arguments[1];
+              if (
+                urlExpr.type !== "NewExpression" ||
+                urlExpr.callee.type !== "Identifier" ||
+                urlExpr.callee.name !== "URL"
+              ) {
+                return error(
+                  `second argument for unmap should be new URL() expression`,
+                );
+              }
+              const key = `${parser.state.module.identifier()}:${
+                urlExpr.range![0]
+              }`;
+              mappings.set(key, {
+                name: nameArg.string!,
+                module: parser.state.module,
+                loc: expr.loc!,
+              });
+            });
+          },
+        );
+
+        compilation.hooks.afterOptimizeModules.tap(
+          UnmapPlugin.name,
+          () => {
+            for (const module of compilation.modules) {
+              if (!module.dependencies) return;
+
+              for (const dep of module.dependencies) {
+                if (dep.constructor.name !== "URLDependency") continue;
+                const dep_ = dep as unknown as { outerRange: [number, number] };
+
+                const key = `${module.identifier()}:${dep_.outerRange[0]}`;
+                const name = mappings.get(key);
+
+                if (!name) continue;
+
+                const error = (msg: string) => {
+                  const err = new compiler.webpack.WebpackError(
+                    msg,
+                  );
+                  err.module = name.module;
+                  err.loc = name.loc;
+                  compilation.errors.push(err);
+                };
+
+                const connection = compilation.moduleGraph.getConnection(
+                  dep,
+                );
+                if (!connection || !connection.module) {
+                  error("unable to find connection for url dependency");
+                  continue;
+                }
+                const mod = connection.module as {
+                  resource?: string;
+                  userRequest?: string;
+                };
+                const request = mod.resource ?? mod.userRequest;
+                if (!request) {
+                  error(`unable to resolve unmap request`);
+                  continue;
+                }
+
+                {
+                  const oldV = nameToRequest.get(name.name);
+                  if (oldV !== undefined && oldV !== request) {
+                    error(
+                      `ResolutionConflict: unmap(${
+                        JSON.stringify(name.name)
+                      }, ${
+                        JSON.stringify(request)
+                      }) was previously resolved to ${oldV}, use a different unmapping`,
+                    );
+                    continue;
+                  }
+                }
+                nameToRequest.set(name.name, request);
+              }
+            }
+          },
+        );
+        compilation.hooks.processAssets.tap(UnmapPlugin.name, (assets) => {
+          for (const [name, request] of nameToRequest.entries()) {
+            for (const [assetName, _asset] of Object.entries(assets)) {
+              const info = compilation.assetsInfo.get(assetName);
+              if (
+                info?.sourceFilename && request.endsWith(info.sourceFilename)
+              ) {
+                nameToAsset.set(name, assetName);
+                break;
+              }
+            }
+          }
+          const unmapping = Object.fromEntries(nameToAsset);
+          const json = JSON.stringify(unmapping);
+          compilation.emitAsset(
+            "mapped.json",
+            new compiler.webpack.sources.RawSource(json),
+          );
+          (compilation as UnmapCompilation).unmapping = unmapping;
+        });
+      },
+    );
+  }
+}

package/util.ts

@@ -0,0 +1,58 @@
+import { assert } from "@std/assert";
+
+export function stripFileUrl(u: string) {
+  assert(u.startsWith("file://"), `not a file url: ${u}`);
+  return u.slice(7);
+}
+export function resolveNpm(u: string) {
+  const path = import.meta.resolve(`npm:${u}`);
+  return stripFileUrl(path);
+}
+
+export function manglePath(path: string) {
+  const tokens = path.replaceAll(/\\/g, "/").split(/([^a-zA-Z0-9_]+)/).filter((
+    s,
+  ) => s);
+
+  return "_" + tokens.map((s) => {
+    if (/^[a-zA-Z0-9_]+$/.test(s)) {
+      return s.length + s;
+    }
+    return s.split("").map((c) => "_" + c.charCodeAt(0).toString(16)).join("");
+  }).join("");
+}
+
+export function assertAbsolutePath(path: string) {
+  // TODO: Windows
+  assert(path.startsWith("/"), `path is not absolute: ${path}`);
+}
+
+export function assertDirURL(path: URL) {
+  const stat = Deno.statSync(path);
+  assert(stat.isDirectory, `path is not a directory: ${path}`);
+}
+export function ensureModPath(path: string) {
+  if (path.endsWith("/fakeMod.ts")) return path;
+  if (!path.startsWith("https://")) {
+    const stat = Deno.statSync(path);
+    if (stat.isFile) return path;
+    assert(stat.isDirectory, `path is not a directory: ${path}`);
+  }
+  if (path.endsWith(".ts") || path.endsWith(".js") || path.endsWith(".mjs")) {
+    return path;
+  }
+  if (!path.endsWith("/")) path += "/fakeMod.ts";
+  return path;
+}
+export function ensureFilePath(path: string) {
+  const stat = Deno.statSync(path);
+  assert(stat.isFile, `path is not a file: ${path}`);
+  assert(!path.endsWith("/"), "file paths shouldn't end with /");
+  return path;
+}
+export function assertResolved(path: string) {
+  assert(path.startsWith("https://"), `path is not https: ${path}`);
+}
+export function ensureFileUrl(path: string) {
+  return new URL(`file://${ensureFilePath(path)}`);
+}

package/viteComment.ts

@@ -0,0 +1,41 @@
+import type Webpack from "webpack";
+import type { Compiler } from "webpack";
+
+type JavascriptParser = Webpack.javascript.JavascriptParser;
+
+const NAME = "ViteIgnorePlugin";
+
+const PARSER_TYPES = [
+  "javascript/auto",
+  "javascript/dynamic",
+  "javascript/esm",
+] as const;
+
+/**
+ * ViteIgnorePlugin skips parsing of `import` calls that contain `@vite-inore` in inline comment, similarly
+ * to webpack built-in `webpackIgnore: true` annotation
+ */
+export class ViteIgnorePlugin {
+  apply(compiler: Compiler) {
+    compiler.hooks.compilation.tap(
+      NAME,
+      (_compilation, { normalModuleFactory }) => {
+        const handler = (parser: JavascriptParser) => {
+          parser.hooks.importCall.tap({ name: NAME, stage: -10 }, (expr) => {
+            const ignored = parser.getComments([
+              expr.range![0],
+              expr.source.range![1],
+            ]).some((comment) =>
+              comment.type === "Block" &&
+              comment.value.includes("@vite-ignore")
+            );
+            if (ignored) return false;
+          });
+        };
+        for (const type of PARSER_TYPES) {
+          normalModuleFactory.hooks.parser.for(type).tap(NAME, handler);
+        }
+      },
+    );
+  }
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.