@freshpack/runtime 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/client-hmr.ts

@@ -0,0 +1,113 @@
+/// <reference types="webpack/module" />
+
+let lastHash: string | undefined;
+function upToDate() {
+  return lastHash!.indexOf(__webpack_hash__) >= 0;
+}
+
+function logUpdate(
+  updatedModules: (string | number)[],
+  renewedModules: (string | number)[] | null,
+) {
+  const unacceptedModules = updatedModules.filter((moduleId) => {
+    return renewedModules && renewedModules.indexOf(moduleId) < 0;
+  });
+
+  if (unacceptedModules.length > 0) {
+    console.warn(
+      "[HMR]",
+      "The following modules couldn't be hot updated: (They would need a full reload!)",
+      unacceptedModules,
+    );
+  }
+
+  if (!renewedModules || renewedModules.length === 0) {
+    console.info("[HMR]", "Nothing hot updated.");
+  } else {
+    console.info("[HMR]", "Updated modules:");
+    renewedModules.forEach(function (moduleId) {
+      if (typeof moduleId === "string" && moduleId.indexOf("!") !== -1) {
+        const parts = moduleId.split("!");
+        console.info("[HMR]", "-", parts.pop());
+        console.info("[HMR]", " ", "-", moduleId);
+      } else {
+        console.info("[HMR]", "-", moduleId);
+      }
+    });
+    const numberIds = renewedModules.every((moduleId) => {
+      return typeof moduleId === "number";
+    });
+    if (numberIds) {
+      console.info(
+        "[HMR]",
+        'Consider using the optimization.moduleIds: "named" for module names.',
+      );
+    }
+  }
+}
+
+async function checkUpdates(fromUpdate = false) {
+  try {
+    const updatedModules = await import.meta.webpackHot.check();
+    if (!updatedModules) {
+      if (fromUpdate) console.info("[HMR]", "Update applied");
+      else console.warn("[HMR]", "Promised update was not found");
+      return;
+    }
+    const renewedModules = await import.meta.webpackHot.apply({
+      ignoreUnaccepted: true,
+      onUnaccepted(data) {
+        console.warn(
+          "[HMR]",
+          "Update was not accepted:",
+          data.chain.join(" => "),
+        );
+      },
+    });
+
+    logUpdate(updatedModules, renewedModules);
+
+    if (!upToDate()) {
+      await checkUpdates(true);
+    }
+  } catch (e) {
+    const status = import.meta.webpackHot.status();
+    if (["abort", "fail"].indexOf(status) >= 0) {
+      console.warn("[HMR]", "Can't apply update, restart required!", e);
+    } else {
+      console.warn("[HMR]", "Update failed", e);
+    }
+  }
+}
+
+async function signalled() {
+  if (import.meta.webpackHot.status() !== "idle") {
+    console.warn(
+      "[HMR]",
+      `Bundle update, but state is not idle: ${import.meta.webpackHot.status()}`,
+    );
+    return;
+  }
+  await checkUpdates();
+}
+
+if (import.meta.webpackHot) {
+  const ws = new WebSocket("/_freshpack_hmr");
+  ws.addEventListener("open", () => {
+    console.info("[HMR]", "opened");
+  });
+  ws.addEventListener("message", (msg) => {
+    const data = JSON.parse(msg.data);
+    if (data === "invalid") {
+      console.info("[HMR]", "webpack is working...");
+    } else if ("done" in data) {
+      const hash = data.done.hash;
+      lastHash = hash;
+      console.info("[HMR]", "webpack rebuilt", hash);
+      signalled();
+    }
+  });
+  ws.addEventListener("close", () => {
+    console.info("[HMR]", "closed");
+  });
+}

package/internal.ts

@@ -0,0 +1,5 @@
+export let unmapping: Record<string, URL | string> | undefined = undefined;
+
+export function setUnmapping(newUnmapping: Record<string, URL | string>) {
+  unmapping = newUnmapping;
+}

package/mod.ts

@@ -0,0 +1,20 @@
+import { unmapping } from "./internal.ts";
+
+const IS_BROWSER = typeof document !== "undefined";
+
+export function unmap(name: string, url: URL): string {
+  if (IS_BROWSER) {
+    console.error("browser unmapping should be done using webpack plugin");
+    return url.href;
+  }
+  if (!unmapping) {
+    console.error("missing unmapping registration");
+    return url.href;
+  }
+  const unmapped = unmapping[name];
+  if (!unmapped) {
+    console.error("missing unmapping registration for", name);
+    return url.href;
+  }
+  return unmapped.toString();
+}

package/package.json

@@ -1,6 +1,17 @@
 {
   "name": "@freshpack/runtime",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.0.0",
+  "type": "module",
+  "exports": {
+    ".": "./mod.ts",
+    "./internal": "./internal.ts",
+    "./client-hmr": "./client-hmr.ts",
+    "./server-middleware": "./server-middleware.ts"
+  },
+  "dependencies": {
+    "@freshpack/core": "3.0.1",
+    "@freshpack/webpack": "1.0.0",
+    "memfs": "^4.80.0",
+    "webpack": "^5.111.1"
+  }
 }

package/server-middleware.ts

@@ -0,0 +1,100 @@
+import type { App, Context, Middleware } from "@freshpack/core";
+import { setBuildCache } from "@freshpack/core/internal";
+import type Webpack from "webpack";
+import { assertFreshCompilation } from "@freshpack/webpack/fresh";
+import { assertUnmapCompilation } from "@freshpack/webpack/unmap";
+import { setUnmapping } from "./internal.ts";
+import * as memfs from "memfs";
+
+export function webpackHandler<State>(
+  app: App<State>,
+  compiler: Webpack.Compiler,
+): (ctx: Context<State>) => Promise<Response | Middleware<State>> {
+  compiler.outputFileSystem = memfs.createFsFromVolume(
+    new memfs.Volume(),
+  ) as any;
+
+  const hmrWatchers = new Set<WebSocket>();
+  const broadcast = (v: unknown) => {
+    const json = JSON.stringify(v);
+    for (const watcher of hmrWatchers) {
+      watcher.send(json);
+    }
+  };
+
+  compiler.hooks.failed.tap("FreshpackHMR", (e) => {
+    console.error("webpack failed", e);
+  });
+  compiler.hooks.invalid.tap("FreshpackHMR", () => {
+    console.error("webpack invalid");
+    broadcast("invalid");
+  });
+  // deno-ignore: require-await
+  compiler.hooks.done.tapPromise({
+    name: "FreshpackHMR",
+    before: "FreshpackCompilingWait",
+  }, async (stats) => {
+    console.info(stats.toString(compiler.options.stats));
+
+    assertFreshCompilation(stats.compilation);
+    assertUnmapCompilation(stats.compilation);
+
+    setBuildCache(
+      app as App<unknown>,
+      stats.compilation.prodBuildCache,
+      // development cache works not the way we want to
+      "production",
+    );
+    setUnmapping(stats.compilation.unmapping);
+    broadcast({ done: { hash: stats.hash } });
+  });
+
+  if (compiler.options.watch) {
+    compiler.watch(compiler.options.watchOptions, () => {
+      // Failure/success is handled by hooks
+    });
+  } else {
+    console.warn(
+      "watching is disabled, server won't be reloaded automatically!",
+    );
+    compiler.compile(() => {
+      // Failure/success is handled by hooks
+    });
+  }
+
+  return (ctx) => {
+    if (ctx.url.pathname.endsWith("/_freshpack_hmr")) {
+      const { response, socket } = Deno.upgradeWebSocket(ctx.req);
+
+      socket.addEventListener("open", () => {
+        hmrWatchers.add(socket);
+      });
+      socket.addEventListener("close", () => {
+        hmrWatchers.delete(socket);
+      });
+      return Promise.resolve(response);
+    }
+    if (ctx.req.method !== "GET" && ctx.req.method !== "HEAD") {
+      return ctx.next();
+    }
+    return ctx.next();
+  };
+}
+
+export function mkCompilingWaiter(
+  compiler: Webpack.Compiler,
+): () => Promise<void> {
+  let waiter = Promise.withResolvers<void>();
+
+  compiler.hooks.failed.tap("FreshpackCompilingWait", () => {
+    waiter.resolve();
+  });
+  compiler.hooks.invalid.tap("FreshpackCompilingWait", () => {
+    waiter = Promise.withResolvers();
+  });
+  compiler.hooks.done.tap("FreshpackCompilingWait", () => {
+    waiter.resolve();
+  });
+
+  return () => waiter.promise;
+}

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.