main repo

node_modules/next/dist/esm/build/webpack/loaders/next-font-loader/index.js

@@ -0,0 +1,105 @@
+import path from "path";
+import chalk from "next/dist/compiled/chalk";
+import loaderUtils from "next/dist/compiled/loader-utils3";
+import postcssNextFontPlugin from "./postcss-next-font";
+import { promisify } from "util";
+export default async function nextFontLoader() {
+    const nextFontLoaderSpan = this.currentTraceSpan.traceChild("next-font-loader");
+    return nextFontLoaderSpan.traceAsyncFn(async ()=>{
+        const callback = this.async();
+        /**
+     * The next-swc plugin next-transform-font turns font function calls into CSS imports.
+     * At the end of the import, it adds the call arguments and some additional data as a resourceQuery.
+     * e.g:
+     * const inter = Inter({ subset: ['latin'] })
+     * ->
+     * import inter from 'next/font/google/target.css?{"import":"Inter","subsets":["latin"]}'
+     *
+     * Here we parse the resourceQuery to get the font function name, call arguments, and the path to the file that called the font function.
+     */ const { path: relativeFilePathFromRoot, import: functionName, arguments: data, variableName } = JSON.parse(this.resourceQuery.slice(1));
+        // Throw error if @next/font is used in _document.js
+        if (/pages[\\/]_document\./.test(relativeFilePathFromRoot)) {
+            const err = new Error(`${chalk.bold("Cannot")} be used within ${chalk.cyan("pages/_document.js")}.`);
+            err.name = "NextFontError";
+            callback(err);
+            return;
+        }
+        const { isDev, isServer, assetPrefix, fontLoaderPath, postcss: getPostcss } = this.getOptions();
+        if (assetPrefix && !/^\/|https?:\/\//.test(assetPrefix)) {
+            const err = new Error("assetPrefix must start with a leading slash or be an absolute URL(http:// or https://)");
+            err.name = "NextFontError";
+            callback(err);
+            return;
+        }
+        /**
+     * Emit font files to .next/static/media as [hash].[ext].
+     *
+     * If the font should be preloaded, add .p to the filename: [hash].p.[ext]
+     * NextFontManifestPlugin adds these files to the next/font manifest.
+     *
+     * If the font is using a size-adjust fallback font, add -s to the filename: [hash]-s.[ext]
+     * NextFontManifestPlugin uses this to see if fallback fonts are being used.
+     * This is used to collect stats on fallback fonts usage by the Google Aurora team.
+     */ const emitFontFile = (content, ext, preload, isUsingSizeAdjust)=>{
+            const opts = {
+                context: this.rootContext,
+                content
+            };
+            const interpolatedName = loaderUtils.interpolateName(this, `static/media/[hash]${isUsingSizeAdjust ? "-s" : ""}${preload ? ".p" : ""}.${ext}`, opts);
+            const outputPath = `${assetPrefix}/_next/${interpolatedName}`;
+            // Only the client emits the font file
+            if (!isServer) {
+                this.emitFile(interpolatedName, content, null);
+            }
+            // But both the server and client must get the resulting path
+            return outputPath;
+        };
+        try {
+            // Import the font loader function from either next/font/local or next/font/google
+            // The font loader function emits font files and returns @font-faces and fallback font metrics
+            const fontLoader = require(fontLoaderPath).default;
+            let { css, fallbackFonts, adjustFontFallback, weight, style, variable } = await nextFontLoaderSpan.traceChild("font-loader").traceAsyncFn(()=>fontLoader({
+                    functionName,
+                    variableName,
+                    data,
+                    emitFontFile,
+                    resolve: (src)=>promisify(this.resolve)(path.dirname(path.join(this.rootContext, relativeFilePathFromRoot)), src.startsWith(".") ? src : `./${src}`),
+                    isDev,
+                    isServer,
+                    loaderContext: this
+                }));
+            const { postcss } = await getPostcss();
+            // Exports will be exported as is from css-loader instead of a CSS module export
+            const exports = [];
+            // Generate a hash from the CSS content. Used to generate classnames and font families
+            const fontFamilyHash = loaderUtils.getHashDigest(Buffer.from(css), "sha1", "hex", 6);
+            // Add CSS classes, exports and make the font-family locally scoped by turning it unguessable
+            const result = await nextFontLoaderSpan.traceChild("postcss").traceAsyncFn(()=>postcss(postcssNextFontPlugin({
+                    exports,
+                    fontFamilyHash,
+                    fallbackFonts,
+                    weight,
+                    style,
+                    adjustFontFallback,
+                    variable
+                })).process(css, {
+                    from: undefined
+                }));
+            const ast = {
+                type: "postcss",
+                version: result.processor.version,
+                root: result.root
+            };
+            // Return the resulting CSS and send the postcss ast, font exports and the hash to the css-loader in the meta argument.
+            callback(null, result.css, null, {
+                exports,
+                ast,
+                fontFamilyHash
+            });
+        } catch (err) {
+            callback(err);
+        }
+    });
+}
+
+//# sourceMappingURL=index.js.map

node_modules/next/dist/esm/build/webpack/loaders/next-font-loader/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/build/webpack/loaders/next-font-loader/index.ts"],"names":["path","chalk","loaderUtils","postcssNextFontPlugin","promisify","nextFontLoader","nextFontLoaderSpan","currentTraceSpan","traceChild","traceAsyncFn","callback","async","relativeFilePathFromRoot","import","functionName","arguments","data","variableName","JSON","parse","resourceQuery","slice","test","err","Error","bold","cyan","name","isDev","isServer","assetPrefix","fontLoaderPath","postcss","getPostcss","getOptions","emitFontFile","content","ext","preload","isUsingSizeAdjust","opts","context","rootContext","interpolatedName","interpolateName","outputPath","emitFile","fontLoader","require","default","css","fallbackFonts","adjustFontFallback","weight","style","variable","resolve","src","dirname","join","startsWith","loaderContext","exports","fontFamilyHash","getHashDigest","Buffer","from","result","process","undefined","ast","type","version","processor","root"],"mappings":"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"}

node_modules/next/dist/esm/build/webpack/loaders/next-font-loader/postcss-next-font.js

@@ -0,0 +1,151 @@
+import postcss from "postcss";
+/**
+ * The next/font postcss plugin recieves the @font-face declarations returned from the next/font loaders.
+ *
+ * It hashes the font-family name to make it unguessable, it shouldn't be globally accessible.
+ * If it were global, we wouldn't be able to tell which pages are using which fonts when generating preload tags.
+ *
+ * If the font loader returned fallback metrics, generate a fallback @font-face.
+ *
+ * If the font loader returned a variable name, add a CSS class that declares a variable containing the font and fallback fonts.
+ *
+ * Lastly, it adds the font-family to the exports object.
+ * This enables you to access the actual font-family name, not just through the CSS class.
+ * e.g:
+ * const inter = Inter({ subsets: ['latin'] })
+ * inter.style.fontFamily // => '__Inter_123456'
+ */ const postcssNextFontPlugin = ({ exports, fontFamilyHash, fallbackFonts = [], adjustFontFallback, variable, weight, style })=>{
+    return {
+        postcssPlugin: "postcss-next-font",
+        Once (root) {
+            let fontFamily;
+            const normalizeFamily = (family)=>{
+                return family.replace(/['"]/g, "");
+            };
+            const formatFamily = (family)=>{
+                // Turn the font family unguessable to make it locally scoped
+                return `'__${family.replace(/ /g, "_")}_${fontFamilyHash}'`;
+            };
+            // Hash font-family names
+            for (const node of root.nodes){
+                if (node.type === "atrule" && node.name === "font-face") {
+                    const familyNode = node.nodes.find((decl)=>decl.prop === "font-family");
+                    if (!familyNode) {
+                        continue;
+                    }
+                    if (!fontFamily) {
+                        fontFamily = normalizeFamily(familyNode.value);
+                    }
+                    familyNode.value = formatFamily(fontFamily);
+                }
+            }
+            if (!fontFamily) {
+                throw new Error("Font loaders must return one or more @font-face's");
+            }
+            // Add fallback @font-face with the provided override values
+            let adjustFontFallbackFamily;
+            if (adjustFontFallback) {
+                adjustFontFallbackFamily = formatFamily(`${fontFamily} Fallback`);
+                const fallbackFontFace = postcss.atRule({
+                    name: "font-face"
+                });
+                const { fallbackFont, ascentOverride, descentOverride, lineGapOverride, sizeAdjust } = adjustFontFallback;
+                fallbackFontFace.nodes = [
+                    new postcss.Declaration({
+                        prop: "font-family",
+                        value: adjustFontFallbackFamily
+                    }),
+                    new postcss.Declaration({
+                        prop: "src",
+                        value: `local("${fallbackFont}")`
+                    }),
+                    ...ascentOverride ? [
+                        new postcss.Declaration({
+                            prop: "ascent-override",
+                            value: ascentOverride
+                        })
+                    ] : [],
+                    ...descentOverride ? [
+                        new postcss.Declaration({
+                            prop: "descent-override",
+                            value: descentOverride
+                        })
+                    ] : [],
+                    ...lineGapOverride ? [
+                        new postcss.Declaration({
+                            prop: "line-gap-override",
+                            value: lineGapOverride
+                        })
+                    ] : [],
+                    ...sizeAdjust ? [
+                        new postcss.Declaration({
+                            prop: "size-adjust",
+                            value: sizeAdjust
+                        })
+                    ] : []
+                ];
+                root.nodes.push(fallbackFontFace);
+            }
+            // Variable fonts can define ranges of values
+            const isRange = (value)=>value.trim().includes(" ");
+            // Format the font families to be used in the CSS
+            const formattedFontFamilies = [
+                formatFamily(fontFamily),
+                ...adjustFontFallbackFamily ? [
+                    adjustFontFallbackFamily
+                ] : [],
+                ...fallbackFonts
+            ].join(", ");
+            // Add class with family, weight and style
+            const classRule = new postcss.Rule({
+                selector: ".className"
+            });
+            classRule.nodes = [
+                new postcss.Declaration({
+                    prop: "font-family",
+                    value: formattedFontFamilies
+                }),
+                // If the font only has one weight or style, we can set it on the class
+                ...weight && !isRange(weight) ? [
+                    new postcss.Declaration({
+                        prop: "font-weight",
+                        value: weight
+                    })
+                ] : [],
+                ...style && !isRange(style) ? [
+                    new postcss.Declaration({
+                        prop: "font-style",
+                        value: style
+                    })
+                ] : []
+            ];
+            root.nodes.push(classRule);
+            // Add CSS class that defines a variable with the font families
+            if (variable) {
+                const varialbeRule = new postcss.Rule({
+                    selector: ".variable"
+                });
+                varialbeRule.nodes = [
+                    new postcss.Declaration({
+                        prop: variable,
+                        value: formattedFontFamilies
+                    })
+                ];
+                root.nodes.push(varialbeRule);
+            }
+            // Export @font-face values as is
+            exports.push({
+                name: "style",
+                value: {
+                    fontFamily: formattedFontFamilies,
+                    fontWeight: !Number.isNaN(Number(weight)) ? Number(weight) : undefined,
+                    fontStyle: style && !isRange(style) ? style : undefined
+                }
+            });
+        }
+    };
+};
+postcssNextFontPlugin.postcss = true;
+export default postcssNextFontPlugin;
+
+//# sourceMappingURL=postcss-next-font.js.map

node_modules/next/dist/esm/build/webpack/loaders/next-font-loader/postcss-next-font.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/build/webpack/loaders/next-font-loader/postcss-next-font.ts"],"names":["postcss","postcssNextFontPlugin","exports","fontFamilyHash","fallbackFonts","adjustFontFallback","variable","weight","style","postcssPlugin","Once","root","fontFamily","normalizeFamily","family","replace","formatFamily","node","nodes","type","name","familyNode","find","decl","prop","value","Error","adjustFontFallbackFamily","fallbackFontFace","atRule","fallbackFont","ascentOverride","descentOverride","lineGapOverride","sizeAdjust","Declaration","push","isRange","trim","includes","formattedFontFamilies","join","classRule","Rule","selector","varialbeRule","fontWeight","Number","isNaN","undefined","fontStyle"],"mappings":"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"}