@graphcommerce/next-config 9.0.4-canary.0 → 9.0.4-canary.10

package/dist/interceptors/parseStructure.js

@@ -1,84 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseStructure = parseStructure;
-const get_1 = __importDefault(require("lodash/get"));
-const zod_1 = require("zod");
-const extractExports_1 = require("./extractExports");
-const pluginConfigParsed = zod_1.z.object({
-    type: zod_1.z.enum(['component', 'function', 'replace']),
-    module: zod_1.z.string(),
-    export: zod_1.z.string(),
-    ifConfig: zod_1.z.union([zod_1.z.string(), zod_1.z.tuple([zod_1.z.string(), zod_1.z.unknown()])]).optional(),
-});
-function nonNullable(value) {
-    return value !== null && value !== undefined;
-}
-const isObject = (input) => typeof input === 'object' && input !== null && !Array.isArray(input);
-function parseStructure(ast, gcConfig, sourceModule) {
-    const [exports, errors] = (0, extractExports_1.extractExports)(ast);
-    if (errors.length)
-        console.error('Plugin error for', errors.join('\n'));
-    const { config: moduleConfig, component, func, exported, ifConfig, plugin, Plugin, ...rest } = exports;
-    const exportVals = Object.keys(rest);
-    if (component && !moduleConfig)
-        exportVals.push('Plugin');
-    if (func && !moduleConfig)
-        exportVals.push('plugin');
-    const pluginConfigs = exportVals
-        .map((exportVal) => {
-        let config = isObject(moduleConfig) ? moduleConfig : {};
-        if (!moduleConfig && component) {
-            config = { type: 'component', module: exported, ifConfig, export: 'Plugin' };
-        }
-        else if (!moduleConfig && func) {
-            config = { type: 'function', module: exported, ifConfig, export: 'plugin' };
-        }
-        else if (isObject(moduleConfig)) {
-            config = { ...moduleConfig, export: exportVal };
-        }
-        else {
-            console.error(`Plugin configuration invalid! See ${sourceModule}`);
-            return null;
-        }
-        const parsed = pluginConfigParsed.safeParse(config);
-        if (!parsed.success) {
-            if (errors.length)
-                console.error(parsed.error.errors.map((e) => `${e.path} ${e.message}`).join('\n'));
-            return undefined;
-        }
-        let enabled = true;
-        if (parsed.data.ifConfig) {
-            if (Array.isArray(parsed.data.ifConfig)) {
-                const isBoolean = typeof parsed.data.ifConfig[1] === 'boolean';
-                let confValue = (0, get_1.default)(gcConfig, parsed.data.ifConfig[0]);
-                confValue = isBoolean ? Boolean(confValue) : confValue;
-                enabled = confValue === parsed.data.ifConfig[1];
-            }
-            else {
-                enabled = Boolean((0, get_1.default)(gcConfig, parsed.data.ifConfig));
-            }
-        }
-        const val = {
-            targetExport: exports.component || exports.func || parsed.data.export,
-            sourceModule,
-            sourceExport: parsed.data.export,
-            targetModule: parsed.data.module,
-            type: parsed.data.type,
-            enabled,
-        };
-        if (parsed.data.ifConfig)
-            val.ifConfig = parsed.data.ifConfig;
-        return val;
-    })
-        .filter(nonNullable);
-    const newPluginConfigs = pluginConfigs.reduce((acc, pluginConfig) => {
-        if (!acc.find((accPluginConfig) => accPluginConfig.sourceExport === pluginConfig.sourceExport)) {
-            acc.push(pluginConfig);
-        }
-        return acc;
-    }, []);
-    return newPluginConfigs;
-}

package/dist/interceptors/swc.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseSync = parseSync;
-exports.printSync = printSync;
-const core_1 = require("@swc/core");
-function parseSync(src) {
-    return (0, core_1.parseSync)(src, {
-        syntax: 'typescript',
-        tsx: true,
-        comments: true,
-    });
-}
-function printSync(m) {
-    return (0, core_1.printSync)(m);
-}

package/dist/interceptors/writeInterceptors.js

@@ -1,44 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeInterceptors = writeInterceptors;
-// eslint-disable-next-line import/no-extraneous-dependencies
-const glob_1 = require("glob");
-const promises_1 = __importDefault(require("node:fs/promises"));
-const path_1 = __importDefault(require("path"));
-const resolveDependenciesSync_1 = require("../utils/resolveDependenciesSync");
-function checkFileExists(file) {
-    return promises_1.default
-        .access(file, promises_1.default.constants.F_OK)
-        .then(() => true)
-        .catch(() => false);
-}
-async function writeInterceptors(interceptors, cwd = process.cwd()) {
-    const dependencies = (0, resolveDependenciesSync_1.resolveDependenciesSync)(cwd);
-    const existing = new Set();
-    dependencies.forEach((dependency) => {
-        const files = (0, glob_1.sync)([`${dependency}/**/*.interceptor.tsx`, `${dependency}/**/*.interceptor.ts`], { cwd });
-        files.forEach((file) => existing.add(file));
-    });
-    const written = Object.entries(interceptors).map(async ([, plugin]) => {
-        const extension = plugin.sourcePath.endsWith('.tsx') ? '.tsx' : '.ts';
-        const relativeFile = `${plugin.fromRoot}.interceptor${extension}`;
-        if (existing.has(relativeFile)) {
-            existing.delete(relativeFile);
-        }
-        if (existing.has(`./${relativeFile}`)) {
-            existing.delete(`./${relativeFile}`);
-        }
-        const fileToWrite = path_1.default.join(cwd, relativeFile);
-        const isSame = (await checkFileExists(fileToWrite)) &&
-            (await promises_1.default.readFile(fileToWrite, 'utf8')).toString() === plugin.template;
-        if (!isSame)
-            await promises_1.default.writeFile(fileToWrite, plugin.template);
-    });
-    // Cleanup unused interceptors
-    const cleaned = [...existing].map(async (file) => (await checkFileExists(file)) && (await promises_1.default.unlink(file)));
-    await Promise.all(written);
-    await Promise.all(cleaned);
-}

package/dist/utils/PackagesSort.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PackagesSort = void 0;
-const TopologicalSort_1 = require("./TopologicalSort");
-class PackagesSort extends TopologicalSort_1.TopologicalSort {
-}
-exports.PackagesSort = PackagesSort;

package/dist/utils/TopologicalSort.js

@@ -1,87 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.TopologicalSort = void 0;
-/* eslint-disable @typescript-eslint/no-non-null-assertion */
-const assert_1 = __importDefault(require("assert"));
-class TopologicalSort {
-    #nodes;
-    #visitedNodes;
-    #sortedKeysStack;
-    constructor(nodes) {
-        this.#nodes = new Map();
-        this.addMultipleInternalNodes(nodes);
-    }
-    /** @public */
-    addNode(key, node) {
-        return this.addInternalNode(key, node);
-    }
-    /** @public */
-    addNodes(nodes) {
-        this.addMultipleInternalNodes(nodes);
-    }
-    /** @public */
-    addEdge(fromKey, toKey) {
-        (0, assert_1.default)(this.#nodes.has(fromKey), `Source package with ${fromKey} key should exist`);
-        (0, assert_1.default)(this.#nodes.has(toKey), `Target package with ${toKey} key should exist`);
-        const sourceNode = this.#nodes.get(fromKey);
-        const targetNode = this.#nodes.get(toKey);
-        assert_1.default.strictEqual(sourceNode !== undefined, true, `Source package with key ${fromKey} doesn't exist`);
-        assert_1.default.strictEqual(targetNode !== undefined, true, `Target package with key ${toKey} doesn't exist`);
-        assert_1.default.strictEqual(sourceNode.children.has(toKey), false, `Source package ${fromKey} already has an edge to target node ${toKey}`);
-        sourceNode.children.set(toKey, targetNode);
-    }
-    /** @public */
-    sort() {
-        this.#visitedNodes = new Set();
-        this.#sortedKeysStack = [];
-        const output = new Map();
-        for (const [key] of this.#nodes) {
-            this.exploreNode(key, []);
-        }
-        for (let i = this.#sortedKeysStack.length - 1; i >= 0; i--) {
-            const node = this.#nodes.get(this.#sortedKeysStack[i]);
-            output.set(this.#sortedKeysStack[i], node);
-        }
-        return output;
-    }
-    exploreNode(nodeKey, explorePath) {
-        const newExplorePath = [...explorePath, nodeKey];
-        // we should check circular dependencies starting from node 2
-        if (explorePath.length) {
-            if (explorePath.includes(nodeKey)) {
-                throw Error(`Package ${nodeKey} forms circular dependency: ${newExplorePath
-                    .slice(newExplorePath.indexOf(nodeKey))
-                    .join(' -> ')}`);
-            }
-        }
-        const node = this.#nodes.get(nodeKey);
-        if (this.#visitedNodes.has(node))
-            return;
-        // mark node as visited so that it and its children
-        // won't be explored next time
-        this.#visitedNodes.add(node);
-        for (const [childNodeKey] of node.children) {
-            this.exploreNode(childNodeKey, newExplorePath);
-        }
-        this.#sortedKeysStack.push(nodeKey);
-    }
-    addInternalNode(key, node) {
-        assert_1.default.strictEqual(this.#nodes.has(key), false, `Node ${key} already exists`);
-        this.#nodes.set(key, {
-            children: new Map(),
-            node,
-        });
-        return this;
-    }
-    addMultipleInternalNodes(nodes) {
-        const nodesFlat = [...nodes];
-        for (let i = nodes.size - 1; i >= 0; i--) {
-            const [key, node] = nodesFlat[i];
-            this.addInternalNode(key, node);
-        }
-    }
-}
-exports.TopologicalSort = TopologicalSort;

package/dist/utils/isMonorepo.js

@@ -1,47 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.findParentPath = findParentPath;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const debug = process.env.DEBUG === '1';
-// eslint-disable-next-line no-console
-const log = (message) => debug && console.log(`isMonorepo: ${message}`);
-function findPackageJson(directory) {
-    try {
-        const packageJsonPath = node_path_1.default.join(directory, 'package.json');
-        const content = node_fs_1.default.readFileSync(packageJsonPath, 'utf8');
-        return JSON.parse(content);
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Finds the path of the parent @graphcommerce package if it exists Returns null if no parent
- * package is found
- */
-function findParentPath(directory) {
-    let currentDir = directory;
-    log(`Starting directory: ${currentDir}`);
-    // Start from the parent directory
-    currentDir = node_path_1.default.dirname(currentDir);
-    log(`Looking for parent packages starting from: ${currentDir}`);
-    // Keep going up until we find a root package or hit the filesystem root
-    while (currentDir !== node_path_1.default.parse(currentDir).root) {
-        const packageJson = findPackageJson(currentDir);
-        if (packageJson) {
-            log(`Found package.json in: ${currentDir}`);
-            log(`Package name: ${packageJson.name}`);
-            if (packageJson.name.startsWith('@graphcommerce/')) {
-                log(`Found parent @graphcommerce package at: ${currentDir}`);
-                return currentDir;
-            }
-        }
-        currentDir = node_path_1.default.dirname(currentDir);
-    }
-    log('No parent @graphcommerce package found');
-    return null;
-}

package/dist/utils/packageRoots.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.packageRoots = void 0;
-const packageRoots = (packagePaths) => {
-    const pathMap = {};
-    // Iterate over each path in the array
-    packagePaths.forEach((singlePath) => {
-        const parts = singlePath.split('/');
-        // Iterate through each part of the path
-        for (let i = 1; i < parts.length; i++) {
-            const subPath = parts.slice(0, i + 1).join('/');
-            // Increment the count of this subPath
-            if (pathMap[subPath]) {
-                pathMap[subPath].count += 1;
-            }
-            else {
-                pathMap[subPath] = { path: subPath, count: 1 };
-            }
-        }
-    });
-    // Filter the paths that appear more than once
-    const roots = [];
-    Object.values(pathMap).forEach(({ path, count }) => {
-        if (count > 1) {
-            roots.push(path);
-        }
-    });
-    // Filter out the sub-paths which are part of another longer sub-path
-    return roots.filter((root, index, self) => self.findIndex((r) => r !== root && r.startsWith(`${root}/`)) === -1);
-};
-exports.packageRoots = packageRoots;

package/dist/utils/resolveDependenciesSync.js

@@ -1,78 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.sortDependencies = sortDependencies;
-exports.resolveDependenciesSync = resolveDependenciesSync;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const PackagesSort_1 = require("./PackagesSort");
-const sig_1 = require("./sig");
-const resolveCache = new Map();
-function resolveRecursivePackageJson(dependencyPath, dependencyStructure, root, additionalDependencies = []) {
-    const isRoot = dependencyPath === root;
-    const fileName = require.resolve(node_path_1.default.join(dependencyPath, 'package.json'));
-    const packageJsonFile = node_fs_1.default.readFileSync(fileName, 'utf-8').toString();
-    const packageJson = JSON.parse(packageJsonFile);
-    const e = [atob('QGdyYXBoY29tbWVyY2UvYWRvYmUtY29tbWVyY2U=')].filter((n) => !globalThis.gcl ? true : !globalThis.gcl.includes(n));
-    if (!packageJson.name)
-        throw Error(`Package ${packageJsonFile} does not have a name field`);
-    // Previously processed
-    if (dependencyStructure[packageJson.name])
-        return dependencyStructure;
-    // To have additional namespaces be considered as a graphcommerce package, set PRIVATE_PACKAGE_NAMESPACES
-    const namespaces = process.env.PRIVATE_PACKAGE_NAMESPACES?.split(',') ?? ['graphcommerce'];
-    if (!isRoot && !namespaces.some((namespace) => packageJson.name?.includes(namespace)))
-        return dependencyStructure;
-    const dependencies = [
-        ...new Set([
-            ...Object.keys(packageJson.dependencies ?? []),
-            ...Object.keys(packageJson.devDependencies ?? []),
-            ...additionalDependencies,
-            ...Object.keys(packageJson.peerDependencies ?? {}),
-        ].filter((name) => name.includes('graphcommerce')
-            ? !(e.length >= 0 && e.some((v) => name.startsWith(v)))
-            : false)),
-    ];
-    const name = isRoot ? '.' : packageJson.name;
-    dependencyStructure[name] = {
-        dirName: node_path_1.default.dirname(node_path_1.default.relative(process.cwd(), fileName)),
-        dependencies,
-    };
-    dependencies.forEach((dep) => {
-        resolveRecursivePackageJson(dep, dependencyStructure, root);
-    });
-    return dependencyStructure;
-}
-/**
- * We're sorting all dependencies topologically
- *
- * This can detect dependency cycles and throw an error
- */
-function sortDependencies(dependencyStructure) {
-    const packages = Object.entries(dependencyStructure);
-    const sorter = new PackagesSort_1.PackagesSort(new Map(packages.map(([key, value]) => [key, value.dirName])));
-    packages.forEach(([key, { dependencies }]) => dependencies.forEach((dependency) => sorter.addEdge(key, dependency)));
-    const sortedKeys = [...sorter.sort().keys()];
-    return new Map(sortedKeys.map((key) => [key, dependencyStructure[key].dirName]));
-}
-/**
- * This will return a list of all dependencies that have `graphcommerce` in the name, matching:
- *
- * - `@graphcommerce/package-name`
- * - `@mycompany/graphcommerce-my-feature`
- *
- * It will traverse children until it finds a package that doesn't contain graphcommerce in the name
- * and stop there, not checking children.
- */
-function resolveDependenciesSync(root = process.cwd()) {
-    const cached = resolveCache.get(root);
-    if (cached)
-        return cached;
-    (0, sig_1.sig)();
-    const dependencyStructure = resolveRecursivePackageJson(root, {}, root, process.env.PRIVATE_ADDITIONAL_DEPENDENCIES?.split(',') ?? []);
-    const sorted = sortDependencies(dependencyStructure);
-    resolveCache.set(root, sorted);
-    return sorted;
-}

package/dist/utils/resolveDependency.js

@@ -1,70 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resolveDependency = void 0;
-const node_fs_1 = __importDefault(require("node:fs"));
-const resolveDependenciesSync_1 = require("./resolveDependenciesSync");
-const resolveDependency = (cwd = process.cwd()) => {
-    const dependencies = (0, resolveDependenciesSync_1.resolveDependenciesSync)(cwd);
-    function resolve(dependency, options = {}) {
-        const { includeSources = false } = options;
-        let dependencyPaths = {
-            root: '.',
-            source: '',
-            sourcePath: '',
-            sourcePathRelative: '',
-            dependency,
-            fromRoot: dependency,
-            fromModule: dependency,
-            denormalized: dependency,
-        };
-        dependencies.forEach((root, depCandidate) => {
-            if (dependency === depCandidate || dependency.startsWith(`${depCandidate}/`)) {
-                const relative = dependency.replace(depCandidate, '');
-                const rootCandidate = dependency.replace(depCandidate, root);
-                let source = '';
-                let sourcePath = '';
-                const fromRoot = [
-                    `${rootCandidate}`,
-                    `${rootCandidate}/index`,
-                    `${rootCandidate}/src/index`,
-                ].find((location) => ['ts', 'tsx'].find((extension) => {
-                    const candidatePath = `${location}.${extension}`;
-                    const exists = node_fs_1.default.existsSync(candidatePath);
-                    if (includeSources && exists) {
-                        source = node_fs_1.default.readFileSync(candidatePath, 'utf-8');
-                        sourcePath = candidatePath;
-                    }
-                    return exists;
-                }));
-                if (!fromRoot) {
-                    return;
-                }
-                const denormalized = fromRoot.replace(root, depCandidate);
-                let fromModule = !relative
-                    ? '.'
-                    : `./${relative.split('/')[relative.split('/').length - 1]}`;
-                const sourcePathRelative = !sourcePath
-                    ? '.'
-                    : `./${sourcePath.split('/')[sourcePath.split('/').length - 1]}`;
-                if (dependency.startsWith('./'))
-                    fromModule = `.${relative}`;
-                dependencyPaths = {
-                    root,
-                    dependency,
-                    denormalized,
-                    fromRoot,
-                    fromModule,
-                    source,
-                    sourcePath,
-                    sourcePathRelative,
-                };
-            }
-        });
-        return dependencyPaths;
-    }
-    return resolve;
-};
-exports.resolveDependency = resolveDependency;

package/dist/utils/sig.js

@@ -1,34 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.g = g;
-exports.sig = sig;
-// import necessary modules
-const crypto_1 = __importDefault(require("crypto"));
-// Function to generate a license key based on input data
-function g(data) {
-    const iv = crypto_1.default.randomBytes(16); // Initialization vector
-    const cipher = crypto_1.default.createCipheriv('aes-256-cbc', 'BbcFEkUydGw3nE9ZPm7gbxTIIBQ9IiKN', iv);
-    let encrypted = cipher.update(JSON.stringify(data), 'utf-8', 'hex');
-    encrypted += cipher.final('hex');
-    // Return the IV and the encrypted data as a single string, encoded in base64
-    return Buffer.from(`${iv.toString('hex')}:${encrypted}`).toString();
-}
-// Function to validate and decode the license key
-function sig() {
-    const l = process.env[atob('R0NfTElDRU5TRQ==')];
-    if (!l)
-        return;
-    if (!globalThis.gcl)
-        try {
-            const decipher = crypto_1.default.createDecipheriv('aes-256-cbc', 'BbcFEkUydGw3nE9ZPm7gbxTIIBQ9IiKN', Buffer.from(l.split(':')[0], 'hex'));
-            let decrypted = decipher.update(l.split(':')[1], 'hex', 'utf-8');
-            decrypted += decipher.final('utf-8');
-            globalThis.gcl = JSON.parse(decrypted); // Parse and return the decoded data
-        }
-        catch (error) {
-            // Silent
-        }
-}

package/dist/withGraphCommerce.js

@@ -1,162 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.withGraphCommerce = withGraphCommerce;
-// import CircularDependencyPlugin from 'circular-dependency-plugin'
-const plugin_1 = require("inspectpack/plugin");
-const webpack_1 = require("webpack");
-const loadConfig_1 = require("./config/loadConfig");
-const configToImportMeta_1 = require("./config/utils/configToImportMeta");
-const InterceptorPlugin_1 = require("./interceptors/InterceptorPlugin");
-const resolveDependenciesSync_1 = require("./utils/resolveDependenciesSync");
-let graphcommerceConfig;
-function domains(config) {
-    return Object.values(config.storefront.reduce((acc, loc) => {
-        if (!loc.domain)
-            return acc;
-        acc[loc.domain] = {
-            defaultLocale: loc.locale,
-            locales: [...(acc[loc.domain]?.locales ?? []), loc.locale],
-            domain: loc.domain,
-            http: process.env.NODE_ENV === 'development' || undefined,
-        };
-        return acc;
-    }, {}));
-}
-/**
- * GraphCommerce configuration: .
- *
- * ```ts
- * const { withGraphCommerce } = require('@graphcommerce/next-config')
- *
- * module.exports = withGraphCommerce(nextConfig)
- * ```
- */
-function withGraphCommerce(nextConfig, cwd = process.cwd()) {
-    graphcommerceConfig ??= (0, loadConfig_1.loadConfig)(cwd);
-    const importMetaPaths = (0, configToImportMeta_1.configToImportMeta)(graphcommerceConfig);
-    const { storefront } = graphcommerceConfig;
-    const transpilePackages = [
-        ...[...(0, resolveDependenciesSync_1.resolveDependenciesSync)().keys()].slice(1),
-        ...(nextConfig.transpilePackages ?? []),
-    ];
-    return {
-        ...nextConfig,
-        bundlePagesRouterDependencies: true,
-        experimental: {
-            ...nextConfig.experimental,
-            scrollRestoration: true,
-            swcPlugins: [...(nextConfig.experimental?.swcPlugins ?? []), ['@lingui/swc-plugin', {}]],
-        },
-        i18n: {
-            ...nextConfig.i18n,
-            defaultLocale: storefront.find((locale) => locale.defaultLocale)?.locale ?? storefront[0].locale,
-            locales: storefront.map((locale) => locale.locale),
-            domains: [...domains(graphcommerceConfig), ...(nextConfig.i18n?.domains ?? [])],
-        },
-        images: {
-            ...nextConfig.images,
-            remotePatterns: [
-                { hostname: new URL(graphcommerceConfig.magentoEndpoint).hostname },
-                { hostname: '**.graphassets.com' },
-                { hostname: '*.graphcommerce.org' },
-                ...(nextConfig.images?.remotePatterns ?? []),
-            ],
-        },
-        redirects: async () => {
-            const redirects = (await nextConfig.redirects?.()) ?? [];
-            const destination = `${graphcommerceConfig.productRoute ?? '/p/'}:url*`;
-            redirects.push(...[
-                { source: '/product/bundle/:url*', destination, permanent: true },
-                { source: '/product/configurable/:url*', destination, permanent: true },
-                { source: '/product/downloadable/:url*', destination, permanent: true },
-                { source: '/product/grouped/:url*', destination, permanent: true },
-                { source: '/product/virtual/:url*', destination, permanent: true },
-                { source: '/customer/account', destination: '/account', permanent: true },
-            ]);
-            if (destination !== '/product/:url*')
-                redirects.push({ source: '/product/:url*', destination, permanent: true });
-            return redirects;
-        },
-        rewrites: async () => {
-            let rewrites = (await nextConfig.rewrites?.()) ?? [];
-            if (Array.isArray(rewrites)) {
-                rewrites = { beforeFiles: rewrites, afterFiles: [], fallback: [] };
-            }
-            if (graphcommerceConfig.productRoute && graphcommerceConfig.productRoute !== '/p/') {
-                rewrites.beforeFiles.push({
-                    source: `${graphcommerceConfig.productRoute ?? '/p/'}:path*`,
-                    destination: '/p/:path*',
-                });
-            }
-            return rewrites;
-        },
-        transpilePackages,
-        webpack: (config, options) => {
-            if (!config.module)
-                config.module = { rules: [] };
-            config.module = {
-                ...config.module,
-                rules: [
-                    ...(config.module.rules ?? []),
-                    // Allow importing yml/yaml files for graphql-mesh
-                    { test: /\.ya?ml$/, use: 'js-yaml-loader' },
-                    // @lingui .po file support
-                    { test: /\.po/, use: '@lingui/loader' },
-                ],
-                exprContextCritical: false,
-            };
-            if (!config.plugins)
-                config.plugins = [];
-            // Make import.meta.graphCommerce available for usage.
-            config.plugins.push(new webpack_1.DefinePlugin(importMetaPaths));
-            // To properly properly treeshake @apollo/client we need to define the __DEV__ property
-            config.plugins.push(new webpack_1.DefinePlugin({ 'globalThis.__DEV__': options.dev }));
-            if (!options.isServer) {
-                // if (graphcommerceConfig.debug?.webpackCircularDependencyPlugin) {
-                //   config.plugins.push(
-                //     new CircularDependencyPlugin({
-                //       exclude: /readable-stream|duplexer2|node_modules\/next/,
-                //     }),
-                //   )
-                // }
-                if (graphcommerceConfig.debug?.webpackDuplicatesPlugin) {
-                    config.plugins.push(new plugin_1.DuplicatesPlugin({
-                        ignoredPackages: [
-                            // very small
-                            'react-is',
-                            // build issue
-                            'tslib',
-                            // server
-                            'isarray',
-                            'readable-stream',
-                        ],
-                    }));
-                }
-            }
-            config.snapshot = {
-                ...(config.snapshot ?? {}),
-                managedPaths: [
-                    new RegExp(`^(.+?[\\/]node_modules[\\/])(?!${transpilePackages.join('|')})`),
-                ],
-            };
-            config.watchOptions = {
-                ...(config.watchOptions ?? {}),
-                ignored: new RegExp(`^((?:[^/]*(?:/|$))*)(.(git|next)|(node_modules[\\/](?!${transpilePackages.join('|')})))(/((?:[^/]*(?:/|$))*)(?:$|/))?`),
-            };
-            if (!config.resolve)
-                config.resolve = {};
-            if (!options.isServer && !options.dev) {
-                config.resolve.alias = {
-                    ...config.resolve.alias,
-                    '@mui/base': '@mui/base/modern',
-                    '@mui/lab': '@mui/lab/modern',
-                    '@mui/material': '@mui/material/modern',
-                    '@mui/styled-engine': '@mui/styled-engine/modern',
-                    '@mui/system': '@mui/system/modern',
-                };
-            }
-            config.plugins.push(new InterceptorPlugin_1.InterceptorPlugin(graphcommerceConfig, !options.isServer));
-            return typeof nextConfig.webpack === 'function' ? nextConfig.webpack(config, options) : config;
-        },
-    };
-}