@freshpack/webpack 0.0.0-stage → 1.0.0

package/prefresh-forked/loader/runtime.js

@@ -0,0 +1,70 @@
+// declare const __prefresh_utils__: any;
+// declare const __prefresh_errors__: any;
+// declare const __webpack_module__: any;
+// declare const __webpack_modules__: any;
+// declare const error: any;
+
+const isPrefreshComponent = __prefresh_utils__.shouldBind(__webpack_module__);
+
+// `@vanilla-extract/webpack` does some custom preprocessing where
+// `module.hot` is partially replaced. This leads to our injected
+// code being executed although it shouldn't be:
+//
+// Intermediate result:
+//
+//   if (true) { // <- inlined by intermediate compile step
+//     const previousHotModuleExports = module.hot.data && ...
+//                    // Crash happens here ---^
+//
+// It crashes at that line because some intermediate compiler isn't
+// running in hot mode, but the overall guard condition was compiled
+// down to being truthy. By moving `module.hot` outside of the
+// condition of the if-statement, it will be left as is.
+const moduleHot = __webpack_module__.hot;
+
+if (moduleHot) {
+  const currentExports = __prefresh_utils__.getExports(__webpack_module__);
+  const previousHotModuleExports = moduleHot.data &&
+    moduleHot.data.moduleExports;
+
+  __prefresh_utils__.registerExports(currentExports, __webpack_module__.id);
+
+  if (isPrefreshComponent) {
+    if (previousHotModuleExports) {
+      try {
+        __prefresh_utils__.flush();
+        if (
+          typeof __prefresh_errors__ !== "undefined" &&
+          __prefresh_errors__ &&
+          __prefresh_errors__.clearRuntimeErrors
+        ) {
+          __prefresh_errors__.clearRuntimeErrors();
+        }
+      } catch (e) {
+        // Only available in newer webpack versions.
+        if (moduleHot.invalidate) {
+          moduleHot.invalidate();
+        } else {
+          console.log("[PREFRESH] Failed to flush updates:", e);
+          self.location.reload();
+        }
+      }
+    }
+
+    moduleHot.dispose((data) => {
+      data.moduleExports = __prefresh_utils__.getExports(__webpack_module__);
+    });
+
+    moduleHot.accept(function errorRecovery() {
+      if (
+        typeof __prefresh_errors__ !== "undefined" &&
+        __prefresh_errors__ &&
+        __prefresh_errors__.handleRuntimeError
+      ) {
+        __prefresh_errors__.handleRuntimeError(error);
+      }
+
+      __webpack_modules__[__webpack_module__.id].hot.accept(errorRecovery);
+    });
+  }
+}

package/prefresh-forked/utils/Runtime.ts

@@ -0,0 +1,79 @@
+import Webpack from "webpack";
+
+const NAMESPACE = "__PREFRESH__";
+
+const beforeModule = `
+self.$RefreshSig$ = function() {
+  var status = 'begin';
+  var savedType;
+
+  return function(type, key, forceReset, getCustomHooks) {
+    if (!savedType) savedType = type;
+    status = self.${NAMESPACE}.sign(type || savedType, key, forceReset, getCustomHooks, status);
+    return type;
+  }
+}
+`;
+
+export class PrefreshRuntimeModule extends Webpack.RuntimeModule {
+  constructor() {
+    super("prefresh", 5);
+  }
+
+  override generate() {
+    const { runtimeTemplate } = this.compilation as any;
+    const declare = runtimeTemplate.supportsConst() ? "const" : "var";
+
+    return Webpack.Template.asString([
+      `${Webpack.RuntimeGlobals.interceptModuleExecution}.push(${
+        runtimeTemplate.basicFunction("options", [
+          `${declare} originalFactory = options.factory;`,
+          `options.factory = ${
+            runtimeTemplate.basicFunction(
+              "moduleObject, moduleExports, webpackRequire",
+              [
+                `if (typeof self !== "undefined" && typeof self.${NAMESPACE} !== "undefined") {`,
+                Webpack.Template.indent([
+                  `${declare} prevRefreshReg = self.$RefreshReg$;`,
+                  `${declare} prevRefreshSig = self.$RefreshSig$;`,
+                  beforeModule,
+                  `${declare} reg = ${
+                    runtimeTemplate.basicFunction(
+                      "currentModuleId",
+                      [
+                        "self.$RefreshReg$ = function(type, id) {",
+                        Webpack.Template.indent(
+                          `self.${NAMESPACE}.register(type, currentModuleId + ' ' + id);`,
+                        ),
+                        "};",
+                      ],
+                    )
+                  }`,
+                  "reg()",
+                  "try {",
+                  Webpack.Template.indent(
+                    "originalFactory.call(this, moduleObject, moduleExports, webpackRequire);",
+                  ),
+                  "} finally {",
+                  Webpack.Template.indent(
+                    "self.$RefreshReg$ = prevRefreshReg;",
+                  ),
+                  Webpack.Template.indent(
+                    "self.$RefreshSig$ = prevRefreshSig;",
+                  ),
+                  "}",
+                ]),
+                "} else {",
+                Webpack.Template.indent(
+                  "originalFactory.call(this, moduleObject, moduleExports, webpackRequire);",
+                ),
+                "}",
+              ],
+            )
+          }`,
+        ])
+      })`,
+      "",
+    ]);
+  }
+}

package/prefresh-forked/utils/constants.ts

@@ -0,0 +1,35 @@
+import Webpack from "webpack";
+
+export const prefreshUtils = "__prefresh_utils__";
+export const NAME = "PrefreshWebpackPlugin";
+
+export const matcherOptions = {
+  include: /\.([jt]sx?)$/,
+  exclude: /node_modules|\/deno\/npm\//,
+};
+
+export function injectRefreshFunctions(compilation: Webpack.Compilation) {
+  const hookVars = compilation.mainTemplate.hooks.localVars;
+
+  hookVars.tap(
+    "ReactFreshWebpackPlugin",
+    (source) =>
+      Webpack.Template.asString([
+        source,
+        "",
+        "// noop fns to prevent runtime errors during initialization",
+        'if (typeof self !== "undefined") {',
+        Webpack.Template.indent("self.$RefreshReg$ = function () {};"),
+        Webpack.Template.indent("self.$RefreshSig$ = function () {"),
+        Webpack.Template.indent(
+          Webpack.Template.indent("return function (type) {"),
+        ),
+        Webpack.Template.indent(
+          Webpack.Template.indent(Webpack.Template.indent("return type;")),
+        ),
+        Webpack.Template.indent(Webpack.Template.indent("};")),
+        Webpack.Template.indent("};"),
+        "}",
+      ]),
+  );
+}

package/prefresh-forked/utils/createTemplate.ts

@@ -0,0 +1,76 @@
+const { Template } = require("webpack");
+
+const NAMESPACE = "__PREFRESH__";
+
+const beforeModule = `
+var prevRefreshReg = self.$RefreshReg$;
+var prevRefreshSig = self.$RefreshSig$;
+
+self.$RefreshSig$ = function() {
+  var status = 'begin';
+  var savedType;
+  return function(type, key, forceReset, getCustomHooks) {
+    if (!savedType) savedType = type;
+    status = self.${NAMESPACE}.sign(type || savedType, key, forceReset, getCustomHooks, status);
+    return type;
+  };
+};
+
+self.$RefreshReg$ = function(type, id) {
+  self.${NAMESPACE}.register(type, module.id + ' ' + id);
+};
+
+try {
+`;
+
+const afterModule = `
+} finally {
+  self.$RefreshReg$ = prevRefreshReg;
+  self.$RefreshSig$ = prevRefreshSig;
+}
+`;
+
+export function createRefreshTemplate(
+  source,
+  chunk,
+  hash,
+  mainTemplate,
+  options,
+) {
+  let filename = mainTemplate.outputOptions.filename;
+  if (typeof filename === "function") {
+    filename = filename({
+      chunk,
+      hash,
+      contentHashType: "javascript",
+      hashWithLength: (length) =>
+        mainTemplate.renderCurrentHashCode(hash, length),
+      noChunkHash: mainTemplate.useChunkHash(chunk),
+    });
+  }
+
+  if (!filename || !filename.includes(".js")) {
+    return source;
+  }
+
+  const lines = source.split("\n");
+
+  // Webpack generates this line whenever the mainTemplate is called
+  const moduleInitializationLineNumber = lines.findIndex((line) =>
+    options.runsInNextJs
+      ? line.includes("modules[moduleId].call(")
+      : line.startsWith("modules[moduleId].call")
+  );
+
+  if (moduleInitializationLineNumber === -1) {
+    return source;
+  }
+
+  return Template.asString([
+    ...lines.slice(0, moduleInitializationLineNumber),
+    beforeModule,
+    Template.indent(lines[moduleInitializationLineNumber]),
+    afterModule,
+    ...lines.slice(moduleInitializationLineNumber + 1, lines.length),
+  ]);
+}

package/prefresh-forked/utils/injectEntry.ts

@@ -0,0 +1,28 @@
+export function injectEntry(originalEntry: any): any {
+  const entryInjects = [require.resolve("@prefresh/core")];
+
+  if (typeof originalEntry === "string") {
+    return [...entryInjects, originalEntry];
+  }
+
+  if (Array.isArray(originalEntry)) {
+    return [...entryInjects, ...originalEntry];
+  }
+
+  if (typeof originalEntry === "object") {
+    return Object.entries(originalEntry).reduce(
+      (acc, [curKey, curEntry]) => ({
+        ...acc,
+        [curKey]: injectEntry(curEntry),
+      }),
+      {},
+    );
+  }
+
+  if (typeof originalEntry === "function") {
+    return (...args: any[]) =>
+      Promise.resolve(originalEntry(...args)).then(injectEntry);
+  }
+
+  throw new Error("Can't detect valid entry point.");
+}

package/prefresh-forked/utils/prefresh.ts

@@ -0,0 +1,59 @@
+import { flush, isComponent } from "@prefresh/utils";
+
+// eslint-disable-next-line
+export const getExports = (m: any) => m.exports || m.__proto__.exports;
+
+function isSafeExport(key: string) {
+  return (
+    key === "__esModule" ||
+    key === "__N_SSG" ||
+    key === "__N_SSP" ||
+    key === "config"
+  );
+}
+
+export function registerExports(moduleExports: any, moduleId: string) {
+  if (
+    typeof self !== "undefined" && typeof self["__PREFRESH__"] !== "undefined"
+  ) {
+    self["__PREFRESH__"].register(moduleExports, moduleId + " %exports%");
+    if (moduleExports == null || typeof moduleExports !== "object") return;
+
+    for (const key in moduleExports) {
+      if (isSafeExport(key)) continue;
+      const exportValue = moduleExports[key];
+      const typeID = moduleId + " %exports% " + key;
+      self["__PREFRESH__"].register(exportValue, typeID);
+    }
+  }
+}
+
+export const shouldBind = (m: any) => {
+  let isCitizen = false;
+  const moduleExports = getExports(m);
+
+  if (isComponent(moduleExports)) {
+    isCitizen = true;
+  }
+
+  if (
+    moduleExports === undefined ||
+    moduleExports === null ||
+    typeof moduleExports !== "object"
+  ) {
+    isCitizen = isCitizen || false;
+  } else {
+    for (const key in moduleExports) {
+      if (key === "__esModule") continue;
+
+      const exportValue = moduleExports[key];
+      if (isComponent(exportValue)) {
+        isCitizen = isCitizen || true;
+      }
+    }
+  }
+
+  return isCitizen;
+};
+
+export { flush };

package/quasiquote.ts

@@ -0,0 +1,44 @@
+export type JsRaw = { _jsRaw: string };
+type ToJsRaw =
+  | string
+  | JsRaw
+  | (ToJsRaw[])
+  | Record<string, string | JsRaw>
+  | Map<string, JsRaw>
+  | undefined;
+export function toJsRaw(v: ToJsRaw): JsRaw {
+  if (typeof v === "string") {
+    return { _jsRaw: JSON.stringify(v) };
+  }
+  if (v instanceof Array) {
+    return {
+      _jsRaw: "[" + v.map((v) =>
+        toJsRaw(v)._jsRaw
+      ).join(v.length > 5 ? ",\n" : ",") +
+        "]",
+    };
+  }
+  if (v instanceof Map) {
+    return js`new Map(${
+      v.entries().map(([name, v]) => js`[${name},${v}]`).toArray()
+    })`;
+  }
+  if (typeof v === "object" && !("_jsRaw" in v)) {
+    const entries = Object.entries(v);
+    return {
+      _jsRaw: "{" + entries.map(([name, v]) =>
+        `${name}:${toJsRaw(v)._jsRaw}`
+      ).join(entries.length > 10 ? ",\n" : ",") + "}",
+    };
+  }
+  if (typeof v === "undefined") {
+    return js`undefined`;
+  }
+  if (v === null) {
+    return js`null`;
+  }
+  return v as JsRaw;
+}
+export const js = (template: TemplateStringsArray, ...subs: ToJsRaw[]) => ({
+  _jsRaw: String.raw(template, ...subs.map((v) => toJsRaw(v)._jsRaw)),
+});

package/rawBytesLoader.ts

@@ -0,0 +1,17 @@
+import type { LoaderContext } from "webpack";
+
+type Context = LoaderContext<Record<never, never>>;
+
+export function pitch(this: Context): string {
+  const resource = this.resourcePath;
+  this.addDependency(resource);
+  const request = `${resource}.webpack[asset/resource]!=!${resource}`;
+  return [
+    `import url from ${JSON.stringify(request)};`,
+    `export default new Uint8Array(await (await fetch(url)).arrayBuffer());`,
+  ].join("\n");
+}
+
+export default function rawBytesLoader(this: Context, source: string): string {
+  return source;
+}

package/rawImports.ts

@@ -0,0 +1,85 @@
+import type { Compiler } from "webpack";
+import { defineRequire } from "./requireHook.ts";
+
+const NAME = "RawImportsPlugin";
+
+const internalRawBytesLoader = defineRequire(
+  "@freshpack/webpack/internal-raw-bytes-loader",
+  await import("./rawBytesLoader.ts"),
+);
+
+type ModuleFactory = {
+  getParser(type: string): unknown;
+  getGenerator(type: string): unknown;
+};
+
+type CreateData = {
+  type: string;
+  settings: { type?: string };
+  parser?: unknown;
+  parserOptions?: unknown;
+  generator?: unknown;
+  generatorOptions?: unknown;
+  loaders?: {
+    loader: string;
+    options: unknown;
+    ident: string | null;
+    type: string | null;
+  }[];
+};
+
+export interface RawImportsOptions {
+  /**
+   * "resource" (default) emits a bytes import as a standalone asset fetched at runtime,
+   * "inline" embeds it into the importing chunk as base64.
+   */
+  bytes?: "resource" | "inline";
+}
+
+function setModuleType(
+  factory: ModuleFactory,
+  data: CreateData,
+  type: string,
+) {
+  data.type = type;
+  data.settings.type = type;
+  data.parser = factory.getParser(type);
+  data.parserOptions = undefined;
+  data.generator = factory.getGenerator(type);
+  data.generatorOptions = undefined;
+}
+
+export class RawImportsPlugin {
+  constructor(public options: RawImportsOptions = {}) {}
+
+  apply(compiler: Compiler) {
+    compiler.hooks.compilation.tap(
+      NAME,
+      (_compilation, { normalModuleFactory }) => {
+        normalModuleFactory.hooks.afterResolve.tap(NAME, (resolveData) => {
+          const attributes = (resolveData.dependencies[0] as undefined | {
+            attributes?: { type?: string };
+          })?.attributes;
+          const data = resolveData.createData as unknown as CreateData;
+          if (attributes?.type === "text") {
+            setModuleType(normalModuleFactory, data, "asset/source");
+            data.loaders = [];
+          } else if (attributes?.type === "bytes") {
+            if (this.options.bytes === "inline") {
+              setModuleType(normalModuleFactory, data, "asset/bytes");
+              data.loaders = [];
+            } else {
+              setModuleType(normalModuleFactory, data, "javascript/esm");
+              data.loaders = [{
+                loader: internalRawBytesLoader,
+                options: {},
+                ident: null,
+                type: null,
+              }];
+            }
+          }
+        });
+      },
+    );
+  }
+}

package/requireHook.ts

@@ -0,0 +1,22 @@
+import Module from "node:module";
+
+const overrides = new Map<string, Record<string, unknown>>();
+let overrideId = 0;
+
+const originalLoad = Module.prototype.require;
+Module.prototype.require = function hookedRequire(id: string) {
+  const override = overrides.get(id);
+  if (override) {
+    return override;
+  }
+  return originalLoad.apply(this, arguments as any);
+};
+
+export function defineRequire(
+  name: string,
+  module: Record<string, unknown>,
+): string {
+  const generatedName = `override:${name}/${overrideId++}`;
+  overrides.set(generatedName, module);
+  return generatedName;
+}