@freshpack/webpack 0.0.0-stage → 1.0.1

package/prefresh-forked/utils/Runtime.d.ts

@@ -0,0 +1,5 @@
+import Webpack from "webpack";
+export declare class PrefreshRuntimeModule extends Webpack.RuntimeModule {
+    constructor();
+    generate(): string;
+}

package/prefresh-forked/utils/Runtime.js

@@ -0,0 +1,52 @@
+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);
+    }
+    generate() {
+        const { runtimeTemplate } = this.compilation;
+        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.d.ts

@@ -0,0 +1,8 @@
+import Webpack from "webpack";
+export declare const prefreshUtils = "__prefresh_utils__";
+export declare const NAME = "PrefreshWebpackPlugin";
+export declare const matcherOptions: {
+    include: RegExp;
+    exclude: RegExp;
+};
+export declare function injectRefreshFunctions(compilation: Webpack.Compilation): void;

package/prefresh-forked/utils/constants.js

@@ -0,0 +1,23 @@
+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) {
+    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/prefresh.d.ts

@@ -0,0 +1,5 @@
+import { flush } from "@prefresh/utils";
+export declare const getExports: (m: any) => any;
+export declare function registerExports(moduleExports: any, moduleId: string): void;
+export declare const shouldBind: (m: any) => boolean;
+export { flush };

package/prefresh-forked/utils/prefresh.js

@@ -0,0 +1,47 @@
+import { flush, isComponent } from "@prefresh/utils";
+// eslint-disable-next-line
+export const getExports = (m) => m.exports || m.__proto__.exports;
+function isSafeExport(key) {
+    return (key === "__esModule" ||
+        key === "__N_SSG" ||
+        key === "__N_SSP" ||
+        key === "config");
+}
+export function registerExports(moduleExports, moduleId) {
+    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) => {
+    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.d.ts

@@ -0,0 +1,9 @@
+export type JsRaw = {
+    _jsRaw: string;
+};
+type ToJsRaw = string | JsRaw | (ToJsRaw[]) | Record<string, string | JsRaw> | Map<string, JsRaw> | undefined;
+export declare function toJsRaw(v: ToJsRaw): JsRaw;
+export declare const js: (template: TemplateStringsArray, ...subs: ToJsRaw[]) => {
+    _jsRaw: string;
+};
+export {};

package/quasiquote.js

@@ -0,0 +1,30 @@
+export function toJsRaw(v) {
+    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;
+}
+export const js = (template, ...subs) => ({
+    _jsRaw: String.raw(template, ...subs.map((v) => toJsRaw(v)._jsRaw)),
+});

package/rawBytesLoader.d.ts

@@ -0,0 +1,5 @@
+import type { LoaderContext } from "webpack";
+type Context = LoaderContext<Record<never, never>>;
+export declare function pitch(this: Context): string;
+export default function rawBytesLoader(this: Context, source: string): string;
+export {};

package/rawBytesLoader.js

@@ -0,0 +1,12 @@
+export function pitch() {
+    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(source) {
+    return source;
+}

package/rawImports.d.ts

@@ -0,0 +1,13 @@
+import type { Compiler } from "webpack";
+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";
+}
+export declare class RawImportsPlugin {
+    options: RawImportsOptions;
+    constructor(options?: RawImportsOptions);
+    apply(compiler: Compiler): void;
+}

package/rawImports.js

@@ -0,0 +1,44 @@
+import { defineRequire } from "./requireHook.js";
+const NAME = "RawImportsPlugin";
+const internalRawBytesLoader = defineRequire("@freshpack/webpack/internal-raw-bytes-loader", await import("./rawBytesLoader.js"));
+function setModuleType(factory, data, type) {
+    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 {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    apply(compiler) {
+        compiler.hooks.compilation.tap(NAME, (_compilation, { normalModuleFactory }) => {
+            normalModuleFactory.hooks.afterResolve.tap(NAME, (resolveData) => {
+                const attributes = resolveData.dependencies[0]?.attributes;
+                const data = resolveData.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.d.ts

@@ -0,0 +1 @@
+export declare function defineRequire(name: string, module: Record<string, unknown>): string;

package/requireHook.js

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

package/resolve.d.ts

@@ -0,0 +1,11 @@
+import { type Loader, Workspace, type WorkspaceOptions } from "@deno/loader";
+import { type Compiler } from "webpack";
+export declare class DenoLoaderPlugin {
+    #private;
+    opts: WorkspaceOptions;
+    patchImport: (f: string, v: string) => string;
+    workspace: Workspace;
+    get loader(): Promise<Loader>;
+    constructor(opts: WorkspaceOptions, patchImport?: (f: string, v: string) => string);
+    apply(compiler: Compiler): void;
+}