@freshpack/webpack 1.0.0 → 1.0.1

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/prefresh-forked/utils/prefresh.ts

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

@@ -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,
-              }];
-            }
-          }
-        });
-      },
-    );
-  }
-}

package/requireHook.ts

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