@freshpack/webpack 0.0.0-stage → 1.0.0

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2026 Lach and Fresh authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/buildCacheUtil.ts

@@ -0,0 +1,11 @@
+import type { IslandPreparer, setBuildCache } from "@freshpack/core/internal";
+import type * as Webpack from "webpack";
+
+export type OriginalBuildCache<State> = Parameters<
+  typeof setBuildCache<State>
+>[1];
+export type ServerIslandRegistry = Parameters<IslandPreparer["prepare"]>[0];
+export type OriginalStaticFile = ReturnType<
+  OriginalBuildCache<unknown>["readFile"]
+>;
+export type WebpackFS = Exclude<Webpack.Compiler["outputFileSystem"], null>;

package/denoEnv.ts

@@ -0,0 +1,78 @@
+import Webpack, { type Compiler } from "webpack";
+
+type JavascriptParser = Webpack.javascript.JavascriptParser;
+
+const NAME = "DenoEnvPlugin";
+
+const PARSER_TYPES = [
+  "javascript/auto",
+  "javascript/dynamic",
+  "javascript/esm",
+] as const;
+
+export type DenoEnvOptions = {
+  allowedEnv?: (string | RegExp)[];
+};
+
+/**
+ * DenoEnvPlugin replaces calls to `Deno.env.get` with a constant expression of environment variable name.
+ */
+export class DenoEnvPlugin {
+  #allowed: (string | RegExp)[];
+  constructor(opts: DenoEnvOptions = {}) {
+    this.#allowed = [
+      ...opts.allowedEnv ?? [],
+      /^FRESH_PUBLIC_/,
+      "NODE_ENV",
+      "DENO_DEPLOYMENT_ID",
+      "GITHUB_SHA",
+      "CI_COMMIT_SHA",
+      "CI",
+    ];
+  }
+  #isAllowed(name: string) {
+    return this.#allowed.some((allowed) =>
+      allowed instanceof RegExp ? allowed.test(name) : allowed === name
+    );
+  }
+  #value(name: string, compiler: Compiler) {
+    if (name === "NODE_ENV") {
+      const mode = compiler.options.mode;
+      if (mode !== undefined && mode !== "none") return mode;
+    }
+    return Deno.env.get(name);
+  }
+  apply(compiler: Compiler) {
+    compiler.hooks.compilation.tap(
+      NAME,
+      (_compilation, { normalModuleFactory }) => {
+        const handler = (parser: JavascriptParser) => {
+          parser.hooks.call.for("Deno.env.get").tap(NAME, (expr) => {
+            const [arg] = expr.arguments;
+            if (
+              expr.arguments.length !== 1 || arg.type !== "Literal" ||
+              typeof arg.value !== "string"
+            ) {
+              return;
+            }
+            const name = arg.value;
+            if (!this.#isAllowed(name)) {
+              throw new Error(`Env var is not allowed in bundling: ${name}`);
+            }
+            const value = this.#value(name, compiler);
+            const dep = new Webpack.dependencies.ConstDependency(
+              value === undefined ? "undefined" : JSON.stringify(value),
+              expr.range!,
+            );
+            if (expr.loc) dep.loc = expr.loc;
+            parser.state.module.addPresentationalDependency(dep);
+            return true;
+          });
+        };
+        for (const type of PARSER_TYPES) {
+          normalModuleFactory.hooks.parser.for(type).tap(NAME, handler);
+        }
+      },
+    );
+  }
+}

package/fresh.ts

@@ -0,0 +1,391 @@
+import {
+  crawlFsItem,
+  type FsRouteFileNoMod,
+} from "@freshpack/core/internal-dev";
+import Webpack from "webpack";
+import {
+  assertAbsolutePath,
+  assertDirURL,
+  manglePath,
+  stripFileUrl,
+} from "./util.ts";
+import { assert } from "@std/assert";
+import { IslandPreparer, ProdBuildCache } from "@freshpack/core/internal";
+import {
+  extname as extnamePosix,
+  join as joinPosix,
+  relative as relativePosix,
+} from "@std/path/posix";
+import { contentType as getStdContentType } from "@std/media-types/content-type";
+import { encodeHex } from "@std/encoding";
+import { UnmapPlugin } from "./unmap.ts";
+import { type DenoEnvOptions, DenoEnvPlugin } from "./denoEnv.ts";
+import { ViteIgnorePlugin } from "./viteComment.ts";
+import { type RawImportsOptions, RawImportsPlugin } from "./rawImports.ts";
+import { js, type JsRaw, toJsRaw } from "./quasiquote.ts";
+
+interface WebpackFreshCompilation extends Webpack.Compilation {
+  freshRoutes: FsRouteFileNoMod<unknown>[];
+  freshIslands: { entryName: string; filePath: string }[];
+  freshRoot: string;
+  buildId: string;
+
+  prodBuildCache: ProdBuildCache<unknown>;
+}
+
+export function assertFreshCompilation(
+  compilation: Webpack.Compilation,
+): asserts compilation is WebpackFreshCompilation {
+  assert(
+    "freshRoutes" in compilation && "freshIslands" in compilation &&
+      "freshRoot" in compilation,
+    "missing fresh data in compilation, did you add WebpackFreshEntries plugin?",
+  );
+}
+
+type CacheStaticFile = {
+  name: string;
+  filePath: string;
+  contentType: string;
+  hash: string;
+  data: Uint8Array;
+  size: number;
+};
+
+function getMainChunkName(
+  basePath: string,
+  e: Webpack.Entrypoint,
+): string {
+  const entryChunk = e.getEntrypointChunk();
+  const files = [...entryChunk.files].map((v) => joinPosix(basePath, v));
+  return files[0];
+}
+function getChunkFiles(
+  basePath: string,
+  e: Webpack.Entrypoint,
+): string[] {
+  return e.getFiles().map((v) => joinPosix(basePath, v));
+}
+
+export class FreshPlugin {
+  /**
+   * @param baseUrl Location of fresh project root directory, you can specify it as `new URL('.', import.meta.url)` in build.ts
+   * @param importHelper JSR dynamic file import workaround: You should pass `(path) => import(path)` here, where the function
+   *                     should be defined anywhere outside of JSR published package. See this for details: https://github.com/denoland/deno/discussions/26266
+   *                     This function will always be called with absolute path.
+   */
+  constructor(
+    public baseUrl: URL,
+    public importHelper: (path: string) => Promise<Record<string, unknown>>,
+    public options: { env?: DenoEnvOptions; rawImports?: RawImportsOptions } =
+      {},
+  ) {
+    assertDirURL(this.baseUrl);
+    if (!importHelper) {
+      console.warn(
+        "[FreshPlugin]",
+        "importHelper is not set, jsr release of @freshpack/webpack doesn't work without it: https://github.com/denoland/deno/discussions/26266#discussioncomment-12198284",
+      );
+      this.importHelper = (path: string) => import(path);
+    }
+  }
+  pathRelativeToBase(path: string) {
+    return relativePosix(this.baseUrl.pathname, path);
+  }
+  #dist?: string;
+  pathRelativeToDist(path: string) {
+    assert(this.#dist, "dist path was not determined yet");
+    return relativePosix(this.#dist, path);
+  }
+
+  apply(compiler: Webpack.Compiler) {
+    {
+      // HACK: Webpack does not export EntryDependency, and it is impossible to use EntryPlugin, as
+      // it wants to modify make stage, yet we have already reached this stage when we want to use
+      // this plugin.
+      //
+      // Solvable by creating custom dependency plugin, or requiring user to manually specify
+      // at least one entry... Or by registering EntryDependency manually as done here.
+      const EntryDependency =
+        Webpack.EntryPlugin.createDependency(`dummy`, {}).constructor;
+
+      compiler.hooks.compilation.tap(
+        FreshPlugin.name,
+        (compilation, { normalModuleFactory }) => {
+          compilation.dependencyFactories.set(
+            EntryDependency as any,
+            normalModuleFactory,
+          );
+        },
+      );
+    }
+
+    (new UnmapPlugin()).apply(compiler);
+    (new DenoEnvPlugin(this.options.env)).apply(compiler);
+    (new ViteIgnorePlugin()).apply(compiler);
+    (new RawImportsPlugin(this.options.rawImports)).apply(compiler);
+    // Some @std and other packages detect deno on presence of Deno global, dead-code-elimnate this stuff
+    (new Webpack.DefinePlugin({ Deno: "undefined" })).apply(compiler);
+
+    compiler.hooks.make.tapPromise(
+      FreshPlugin.name,
+      async (_compilation: Webpack.Compilation) => {
+        const compilation = _compilation as WebpackFreshCompilation;
+        this.#dist = compilation.outputOptions.path;
+
+        const compilationId = Date.now().toString(36);
+
+        // Ensure hot chunks are resolved from correct path, they can't contain compilationId in name
+        compilation.outputOptions.publicPath = "/";
+        {
+          // Chunks are content-addressed in prod, and have readable names using standard fresh cache pruning in dev
+          if (compiler.options.mode === "production") {
+            compilation.outputOptions.filename =
+              `_fresh/js/c/[contenthash].mjs`;
+            compilation.outputOptions.chunkFilename =
+              `_fresh/js/c/[contenthash].mjs`;
+            compilation.outputOptions.workerChunkFilename =
+              `_fresh/js/c/[contenthash].mjs`;
+          } else {
+            compilation.outputOptions.filename =
+              `_fresh/js/${compilationId}/[id].mjs`;
+            compilation.outputOptions.chunkFilename =
+              `_fresh/js/${compilationId}/[id].mjs`;
+            compilation.outputOptions.workerChunkFilename =
+              `_fresh/js/${compilationId}/[id].mjs`;
+          }
+          // Assets are always content-addressed
+          compilation.outputOptions.assetModuleFilename =
+            `_fresh/js/c/[hash][ext][query]`;
+          compilation.outputOptions.webassemblyModuleFilename =
+            `_fresh/js/c/[hash].wasm`;
+        }
+
+        compilation.hooks.processAssets.tapPromise(
+          {
+            name: FreshPlugin.name,
+            stage: compiler.webpack.Compilation.PROCESS_ASSETS_STAGE_SUMMARIZE,
+          },
+          async (assets) => {
+            compilation.getAssets();
+
+            const cacheOut: JsRaw[] = [
+              js`import{IslandPreparer,ProdBuildCache}from"@freshpack/core/internal"`,
+              js`const islands=new Map()`,
+              js`const islandPreparer=new IslandPreparer()`,
+            ];
+
+            const staticFiles = new Map<string, CacheStaticFile>();
+
+            const islands = new Map();
+            const islandPreparer = new IslandPreparer();
+            for (const island of compilation.freshIslands) {
+              const entrypoint = compilation.entrypoints.get(island.entryName);
+              assert(
+                entrypoint,
+                `unable to find island entrypoint: ${island.entryName}`,
+              );
+              const file = getMainChunkName(
+                `/`,
+                entrypoint,
+              );
+
+              islandPreparer.prepare(
+                islands,
+                await this.importHelper(island.filePath),
+                file,
+                island.entryName,
+                [],
+              );
+              const importPath = this.pathRelativeToDist(island.filePath);
+              cacheOut.push(
+                js`islandPreparer.prepare(islands,await import(${importPath}),${file},${island.entryName},[])`,
+              );
+            }
+
+            const fsRoutesOut: JsRaw[] = [];
+            const fsRoutes = await Promise.all(
+              compilation.freshRoutes.map(async (v) => {
+                const importPath = this.pathRelativeToDist(v.filePath);
+                fsRoutesOut.push(toJsRaw({
+                  id: v.id,
+                  mod: v.lazy
+                    ? js`()=>import(${importPath})`
+                    : js`await import(${importPath})`,
+                  type: v.type,
+                  pattern: v.pattern,
+                  routePattern: v.routePattern,
+                }));
+                assertAbsolutePath(v.filePath);
+                return {
+                  ...v,
+                  mod: v.lazy
+                    ? () => this.importHelper(v.filePath)
+                    : await this.importHelper(v.filePath),
+                };
+              }),
+            );
+            cacheOut.push(js`const fsRoutes=${fsRoutesOut}`);
+
+            const clientEntrypoint = compilation.entrypoints.get(
+              "client-entry",
+            );
+            assert(
+              clientEntrypoint,
+              `unable to find client entrypoint`,
+            );
+            const clientEntry = getMainChunkName(
+              `/`,
+              clientEntrypoint,
+            );
+            const clientEntryAssets = getChunkFiles(
+              `/`,
+              clientEntrypoint,
+            );
+            const staticFilesOut = new Map<string, JsRaw>();
+            for (const _asset of compilation.getAssets()) {
+              const asset = compilation.getAsset(_asset.name)!;
+              const file_: Uint8Array<ArrayBufferLike> = assets[asset.name]
+                .buffer();
+              const file = file_ as Uint8Array<ArrayBuffer>;
+              const hash = await crypto.subtle.digest("SHA-1", file.buffer);
+
+              const ext = extnamePosix(asset.name);
+              const contentType = getStdContentType(ext) ?? "text/plain";
+
+              const name = "/" + asset.name;
+              staticFiles.set(name, {
+                name,
+                filePath: asset.name,
+                contentType,
+                hash: encodeHex(hash),
+                data: file,
+                size: file.length,
+              });
+              staticFilesOut.set(
+                name,
+                toJsRaw({
+                  name,
+                  filePath:
+                    js`new URL(${asset.name}, import.meta.url).pathname`,
+                  hash: encodeHex(hash),
+                  contentType,
+                }),
+              );
+            }
+            cacheOut.push(js`const staticFiles=${staticFilesOut}`);
+
+            cacheOut.push(
+              js`export default new ProdBuildCache(${compilation.freshRoot}, ${({
+                version: compilationId,
+                clientEntry,
+                entryAssets: toJsRaw(clientEntryAssets),
+                islands: js`islands`,
+                fsRoutes: js`fsRoutes`,
+                staticFiles: js`staticFiles`,
+              })})`,
+            );
+            // Here ProdBuildCache is being used as MemoryBuildCache from fresh
+            const cache = new ProdBuildCache(compilation.freshRoot, {
+              version: compilationId,
+              clientEntry,
+              fsRoutes,
+              staticFiles,
+              islands,
+              entryAssets: clientEntryAssets,
+            });
+            cache.readFile = (pathname) => {
+              const st = staticFiles.get(pathname);
+              if (!st) {
+                return Promise.resolve(null);
+              }
+              return Promise.resolve({
+                contentType: st.contentType,
+                hash: st.hash,
+                readable: new ReadableStream({
+                  start(v) {
+                    v.enqueue(st.data);
+                    v.close();
+                  },
+                }),
+                size: st.size,
+                close() {},
+              });
+            };
+            compilation.prodBuildCache = cache;
+
+            compilation.emitAsset(
+              "./cache.mjs",
+              new compiler.webpack.sources.RawSource(
+                cacheOut.map((v) => v._jsRaw).join("\n"),
+              ),
+            );
+          },
+        );
+
+        const item = await crawlFsItem({
+          islandDir: stripFileUrl(new URL("islands", this.baseUrl).href),
+          routeDir: stripFileUrl(new URL("routes", this.baseUrl).href),
+          ignore: [],
+        });
+        compilation.freshRoutes = item.routes;
+        compilation.freshIslands = [];
+        compilation.freshRoot = this.pathRelativeToBase(".");
+
+        const addEntryPromises = [];
+        let isId = 0;
+        for (const island of item.islands) {
+          const name = compiler.options.mode === "production"
+            ? `is${isId++}`
+            : manglePath(island);
+          compilation.freshIslands.push({ entryName: name, filePath: island });
+          addEntryPromises.push(
+            new Promise<void>((res, rej) =>
+              compilation.addEntry(
+                "",
+                Webpack.EntryPlugin.createDependency(`${island}`, {
+                  name,
+                }),
+                {
+                  name,
+                  library: {
+                    type: "module",
+                  },
+                },
+                (err) => {
+                  if (err) return rej(err);
+                  res();
+                },
+              )
+            ),
+          );
+        }
+        {
+          const name = "client-entry";
+          const file = stripFileUrl(new URL("./client.ts", this.baseUrl).href);
+          addEntryPromises.push(
+            new Promise<void>((res, rej) =>
+              compilation.addEntry(
+                "",
+                Webpack.EntryPlugin.createDependency(file, {
+                  name,
+                }),
+                {
+                  name,
+                  library: {
+                    type: "module",
+                  },
+                },
+                (e) => {
+                  if (e) return rej(e);
+                  res();
+                },
+              )
+            ),
+          );
+        }
+        await Promise.all(addEntryPromises);
+      },
+    );
+  }
+}

package/mod.ts

@@ -0,0 +1,7 @@
+export { DenoEnvPlugin } from "./denoEnv.ts";
+export { FreshPlugin } from "./fresh.ts";
+export { ViteIgnorePlugin } from "./viteComment.ts";
+export { DenoPreactRefreshPlugin } from "./prefresh-forked/index.ts";
+export { DenoLoaderPlugin } from "./resolve.ts";
+export { type RawImportsOptions, RawImportsPlugin } from "./rawImports.ts";
+export { UnmapPlugin } from "./unmap.ts";

package/package.json

@@ -1,6 +1,22 @@
 {
   "name": "@freshpack/webpack",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.0.0",
+  "type": "module",
+  "exports": {
+    ".": "./mod.ts",
+    "./fresh": "./fresh.ts",
+    "./util": "./util.ts",
+    "./unmap": "./unmap.ts",
+    "./requireHook": "./requireHook.ts"
+  },
+  "dependencies": {
+    "@deno/loader": "npm:@jsr/deno__loader@^0.5.0",
+    "@freshpack/core": "3.0.1",
+    "@prefresh/utils": "^1.2.1",
+    "@std/assert": "npm:@jsr/std__assert@^1.0.19",
+    "@std/encoding": "npm:@jsr/std__encoding@^1.0.11",
+    "@std/media-types": "npm:@jsr/std__media-types@^1.1.0",
+    "@std/path": "npm:@jsr/std__path@^1.1.6",
+    "webpack": "^5.111.1"
+  }
 }

package/prefresh-forked/index.ts

@@ -0,0 +1,114 @@
+/* FIXME: Typings are awful in this file, the port was very crude */
+
+import Webpack from "webpack";
+import {
+  injectRefreshFunctions,
+  matcherOptions,
+  NAME,
+  prefreshUtils,
+} from "./utils/constants.ts";
+import { PrefreshRuntimeModule } from "./utils/Runtime.ts";
+import { defineRequire } from "../requireHook.ts";
+
+type Options = {
+  overlay?: {
+    module: string;
+  };
+  entryOptions?: string | Webpack.EntryOptions;
+};
+
+const internalPrefreshLoader = defineRequire(
+  "@freshpack/webpack/internal-prefresh-loader",
+  await import("./loader/index.ts"),
+);
+
+export class DenoPreactRefreshPlugin {
+  matcher;
+  constructor(public options: Options) {
+    this.matcher = Webpack.ModuleFilenameHelpers.matchObject.bind(
+      undefined,
+      matcherOptions,
+    );
+  }
+
+  webpack5(
+    compiler: Webpack.Compiler,
+    RuntimeGlobals: typeof Webpack.RuntimeGlobals,
+  ) {
+    compiler.hooks.compilation.tap(
+      NAME,
+      (compilation, { normalModuleFactory }) => {
+        if (compilation.compiler !== compiler) {
+          return;
+        }
+
+        injectRefreshFunctions(compilation);
+
+        compilation.hooks.additionalTreeRuntimeRequirements.tap(
+          NAME,
+          (chunk, runtimeRequirements) => {
+            runtimeRequirements.add(RuntimeGlobals.interceptModuleExecution);
+            compilation.addRuntimeModule(chunk, new PrefreshRuntimeModule());
+          },
+        );
+
+        normalModuleFactory.hooks.afterResolve.tap(
+          NAME,
+          ({ createData: data }) => {
+            if (
+              this.matcher(data.resource!) &&
+              !data.resource!.includes("@prefresh") &&
+              !data.resource!.includes("/prefresh-forked/loader/") &&
+              !data.resource!.includes("/prefresh-forked/utils/")
+            ) {
+              data.loaders!.unshift({
+                loader: internalPrefreshLoader,
+                options: undefined,
+              });
+            }
+          },
+        );
+      },
+    );
+  }
+
+  apply(compiler: Webpack.Compiler) {
+    if (
+      compiler.options.mode === "production"
+    ) {
+      return;
+    }
+
+    const provide = {
+      [prefreshUtils]: import.meta.resolve("./utils/prefresh.ts"),
+    };
+
+    if (this.options.overlay) {
+      (provide as any).__prefresh_errors__ = import.meta.resolve(
+        this.options.overlay.module,
+      );
+    }
+
+    const providePlugin = new Webpack.ProvidePlugin(provide);
+    providePlugin.apply(compiler);
+    const dependency = Webpack.EntryPlugin.createDependency(
+      "@prefresh/core",
+      { name: "@prefresh/core" },
+    );
+    compiler.hooks.make.tapAsync(NAME, (compilation, callback) => {
+      compilation.addEntry(
+        compiler.context,
+        dependency,
+        this.options.entryOptions ?? {},
+        callback as any,
+      );
+    });
+
+    this.webpack5(
+      compiler,
+      compiler.webpack
+        ? compiler.webpack.RuntimeGlobals
+        : Webpack.RuntimeGlobals,
+    );
+  }
+}

package/prefresh-forked/loader/index.ts

@@ -0,0 +1,10 @@
+import type Webpack from "webpack";
+import runtimeText from "./runtime.js" with { type: "text" };
+
+export default function RefreshHotLoader(
+  this: any,
+  source: Webpack.sources.SourceMapSource,
+  inputSourceMap: Webpack.sources.SourceMapSource["source"],
+) {
+  this.callback(null, source + "\n\n" + runtimeText, inputSourceMap);
+}