@freshpack/webpack 1.0.0 → 1.0.2

package/prefresh-forked/index.ts

@@ -1,114 +0,0 @@
-/* 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

@@ -1,10 +0,0 @@
-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);
-}

package/prefresh-forked/utils/Runtime.ts

@@ -1,79 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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/quasiquote.ts

@@ -1,44 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,85 +0,0 @@
-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,
-              }];
-            }
-          }
-        });
-      },
-    );
-  }
-}