@graphcommerce/next-config 8.1.0-canary.2 → 8.1.0-canary.5

package/dist/interceptors/extractExports.js

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractExports = exports.RUNTIME_VALUE = exports.UnsupportedValueError = exports.NoSuchDeclarationError = void 0;
+class NoSuchDeclarationError extends Error {
+}
+exports.NoSuchDeclarationError = NoSuchDeclarationError;
+function isIdentifier(node) {
+    return node.type === 'Identifier';
+}
+function isBooleanLiteral(node) {
+    return node.type === 'BooleanLiteral';
+}
+function isNullLiteral(node) {
+    return node.type === 'NullLiteral';
+}
+function isStringLiteral(node) {
+    return node.type === 'StringLiteral';
+}
+function isNumericLiteral(node) {
+    return node.type === 'NumericLiteral';
+}
+function isArrayExpression(node) {
+    return node.type === 'ArrayExpression';
+}
+function isObjectExpression(node) {
+    return node.type === 'ObjectExpression';
+}
+function isKeyValueProperty(node) {
+    return node.type === 'KeyValueProperty';
+}
+function isRegExpLiteral(node) {
+    return node.type === 'RegExpLiteral';
+}
+function isTemplateLiteral(node) {
+    return node.type === 'TemplateLiteral';
+}
+class UnsupportedValueError extends Error {
+    /** @example `config.runtime[0].value` */
+    path;
+    constructor(message, paths) {
+        super(message);
+        // Generating "path" that looks like "config.runtime[0].value"
+        let codePath;
+        if (Array.isArray(paths)) {
+            codePath = '';
+            for (const path of paths) {
+                if (path[0] === '[') {
+                    // "array" + "[0]"
+                    codePath += path;
+                }
+                else if (codePath === '') {
+                    codePath = path;
+                }
+                else {
+                    // "object" + ".key"
+                    codePath += `.${path}`;
+                }
+            }
+        }
+        this.path = codePath;
+    }
+}
+exports.UnsupportedValueError = UnsupportedValueError;
+exports.RUNTIME_VALUE = Symbol('RUNTIME_VALUE');
+function extractValue(node, path, optional = false) {
+    if (isNullLiteral(node)) {
+        return null;
+    }
+    if (isBooleanLiteral(node)) {
+        // e.g. true / false
+        return node.value;
+    }
+    if (isStringLiteral(node)) {
+        // e.g. "abc"
+        return node.value;
+    }
+    if (isNumericLiteral(node)) {
+        // e.g. 123
+        return node.value;
+    }
+    if (isRegExpLiteral(node)) {
+        // e.g. /abc/i
+        return new RegExp(node.pattern, node.flags);
+    }
+    if (isIdentifier(node)) {
+        switch (node.value) {
+            case 'undefined':
+                return undefined;
+            default:
+                if (optional)
+                    return exports.RUNTIME_VALUE;
+                throw new UnsupportedValueError(`Unknown identifier "${node.value}"`, path);
+        }
+    }
+    else if (isArrayExpression(node)) {
+        // e.g. [1, 2, 3]
+        const arr = [];
+        for (let i = 0, len = node.elements.length; i < len; i++) {
+            const elem = node.elements[i];
+            if (elem) {
+                if (elem.spread) {
+                    // e.g. [ ...a ]
+                    if (optional)
+                        return exports.RUNTIME_VALUE;
+                    throw new UnsupportedValueError('Unsupported spread operator in the Array Expression', path);
+                }
+                arr.push(extractValue(elem.expression, path && [...path, `[${i}]`], optional));
+            }
+            else {
+                // e.g. [1, , 2]
+                //         ^^
+                arr.push(undefined);
+            }
+        }
+        return arr;
+    }
+    else if (isObjectExpression(node)) {
+        // e.g. { a: 1, b: 2 }
+        const obj = {};
+        for (const prop of node.properties) {
+            if (!isKeyValueProperty(prop)) {
+                // e.g. { ...a }
+                if (optional)
+                    return exports.RUNTIME_VALUE;
+                throw new UnsupportedValueError('Unsupported spread operator in the Object Expression', path);
+            }
+            let key;
+            if (isIdentifier(prop.key)) {
+                // e.g. { a: 1, b: 2 }
+                key = prop.key.value;
+            }
+            else if (isStringLiteral(prop.key)) {
+                // e.g. { "a": 1, "b": 2 }
+                key = prop.key.value;
+            }
+            else {
+                if (optional)
+                    return exports.RUNTIME_VALUE;
+                throw new UnsupportedValueError(`Unsupported key type "${prop.key.type}" in the Object Expression`, path);
+            }
+            obj[key] = extractValue(prop.value, path && [...path, key]);
+        }
+        return obj;
+    }
+    else if (isTemplateLiteral(node)) {
+        // e.g. `abc`
+        if (node.expressions.length !== 0) {
+            // TODO: should we add support for `${'e'}d${'g'}'e'`?
+            if (optional)
+                return exports.RUNTIME_VALUE;
+            throw new UnsupportedValueError('Unsupported template literal with expressions', path);
+        }
+        // When TemplateLiteral has 0 expressions, the length of quasis is always 1.
+        // Because when parsing TemplateLiteral, the parser yields the first quasi,
+        // then the first expression, then the next quasi, then the next expression, etc.,
+        // until the last quasi.
+        // Thus if there is no expression, the parser ends at the frst and also last quasis
+        //
+        // A "cooked" interpretation where backslashes have special meaning, while a
+        // "raw" interpretation where backslashes do not have special meaning
+        // https://exploringjs.com/impatient-js/ch_template-literals.html#template-strings-cooked-vs-raw
+        const [{ cooked, raw }] = node.quasis;
+        return cooked ?? raw;
+    }
+    else {
+        if (optional)
+            return exports.RUNTIME_VALUE;
+        throw new UnsupportedValueError(`Unsupported node type "${node.type}"`, path);
+    }
+}
+function extractExports(module) {
+    const exports = {};
+    const errors = [];
+    for (const moduleItem of module.body) {
+        switch (moduleItem.type) {
+            case 'ExportAllDeclaration':
+                errors.push('You can not use export * from a plugin, exports must be explicit');
+                break;
+            case 'ExportDefaultDeclaration':
+                errors.push('You can not use default exports from a plugin, exports must be explicit');
+                break;
+            case 'ExportDeclaration':
+                switch (moduleItem.declaration.type) {
+                    case 'ClassDeclaration':
+                    case 'FunctionDeclaration':
+                        exports[moduleItem.declaration.identifier.value] = exports.RUNTIME_VALUE;
+                        // node.identifier.value
+                        break;
+                    case 'VariableDeclaration':
+                        moduleItem.declaration.declarations.forEach((decl) => {
+                            if (isIdentifier(decl.id) && decl.init) {
+                                exports[decl.id.value] = extractValue(decl.init, undefined, true);
+                            }
+                        });
+                        break;
+                }
+        }
+    }
+    return [exports, errors];
+}
+exports.extractExports = extractExports;

package/dist/interceptors/findOriginalSource.js

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findOriginalSource = void 0;
+const path_1 = __importDefault(require("path"));
+const swc_1 = require("./swc");
+function parseAndFindExport(resolved, findExport, resolve) {
+    if (!resolved?.source)
+        return undefined;
+    const ast = (0, swc_1.parseSync)(resolved.source);
+    for (const node of ast.body) {
+        if (node.type === 'ExportDeclaration') {
+            switch (node.declaration.type) {
+                case 'ClassDeclaration':
+                case 'FunctionDeclaration':
+                    if (node.declaration.identifier.value === findExport)
+                        return resolved;
+                    break;
+                case 'VariableDeclaration':
+                    for (const declaration of node.declaration.declarations) {
+                        if (declaration.type === 'VariableDeclarator') {
+                            if (declaration.id.type === 'Identifier') {
+                                if (declaration.id.value === findExport)
+                                    return resolved;
+                            }
+                            else {
+                                console.log(declaration);
+                            }
+                        }
+                    }
+                    break;
+            }
+        }
+    }
+    const exports = ast.body
+        .filter((node) => node.type === 'ExportAllDeclaration')
+        .sort((a, b) => {
+        const probablyA = a.source.value.includes(findExport);
+        const probablyB = b.source.value.includes(findExport);
+        // eslint-disable-next-line no-nested-ternary
+        return probablyA === probablyB ? 0 : probablyA ? -1 : 1;
+    });
+    for (const node of exports) {
+        const isRelative = node.source.value.startsWith('.');
+        if (isRelative) {
+            const d = resolved.dependency === resolved.denormalized
+                ? resolved.dependency.substring(0, resolved.dependency.lastIndexOf('/'))
+                : resolved.dependency;
+            const newPath = path_1.default.join(d, node.source.value);
+            const resolveResult = resolve(newPath, { includeSources: true });
+            // eslint-disable-next-line no-continue
+            if (!resolveResult)
+                continue;
+            const newResolved = parseAndFindExport(resolveResult, findExport, resolve);
+            if (newResolved && resolved.dependency !== newResolved.dependency)
+                return newResolved;
+        }
+    }
+    return undefined;
+}
+const cachedResults = new Map();
+function findOriginalSource(plug, resolved, resolve) {
+    if (!resolved?.source)
+        return {
+            resolved: undefined,
+            error: new Error(`Could not resolve ${plug.targetModule}`),
+        };
+    // const cacheKey = `${plug.targetModule}#${plug.targetExport}`
+    // if (cachedResults.has(cacheKey)) {
+    //   return {
+    //     resolved: cachedResults.get(cacheKey) as NonNullable<ResolveDependencyReturn>,
+    //     error: undefined,
+    //   }
+    // }
+    const newResolved = parseAndFindExport(resolved, plug.targetExport, resolve);
+    if (!newResolved) {
+        return {
+            resolved: undefined,
+            error: new Error(`Can not find ${plug.targetModule}#${plug.sourceExport} for plugin ${plug.sourceModule}`),
+        };
+    }
+    // cachedResults.set(cacheKey, newResolved)
+    return { resolved: newResolved, error: undefined };
+}
+exports.findOriginalSource = findOriginalSource;

package/dist/interceptors/findPlugins.js

@@ -4,36 +4,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.findPlugins = void 0;
-const core_1 = require("@swc/core");
 // eslint-disable-next-line import/no-extraneous-dependencies
+const core_1 = require("@swc/core");
 const chalk_1 = __importDefault(require("chalk"));
 // eslint-disable-next-line import/no-extraneous-dependencies
-const glob_1 = __importDefault(require("glob"));
-const get_1 = __importDefault(require("lodash/get"));
+const glob_1 = require("glob");
 const resolveDependenciesSync_1 = require("../utils/resolveDependenciesSync");
-const generateInterceptors_1 = require("./generateInterceptors");
-function parseStructure(file) {
-    const ast = (0, core_1.parseFileSync)(file, { syntax: 'typescript', tsx: true });
-    const imports = {};
-    const exports = {};
-    ast.body.forEach((node) => {
-        if (node.type === 'ImportDeclaration') {
-            node.specifiers.forEach((s) => {
-                if (s.type === 'ImportSpecifier') {
-                    imports[s.local.value] = node.source.value;
-                }
-            });
-        }
-        if (node.type === 'ExportDeclaration' && node.declaration.type === 'VariableDeclaration') {
-            node.declaration.declarations.forEach((declaration) => {
-                if (declaration.init?.type === 'StringLiteral' && declaration.id.type === 'Identifier') {
-                    exports[declaration.id.value] = declaration.init.value;
-                }
-            });
-        }
-    });
-    return exports;
-}
+const parseStructure_1 = require("./parseStructure");
 const pluginLogs = {};
 function findPlugins(config, cwd = process.cwd()) {
     const dependencies = (0, resolveDependenciesSync_1.resolveDependenciesSync)(cwd);
@@ -41,30 +18,14 @@ function findPlugins(config, cwd = process.cwd()) {
     const errors = [];
     const plugins = [];
     dependencies.forEach((dependency, path) => {
-        const files = glob_1.default.sync(`${dependency}/plugins/**/*.{ts,tsx}`);
+        const files = (0, glob_1.sync)(`${dependency}/plugins/**/*.{ts,tsx}`, { dotRelative: true });
         files.forEach((file) => {
+            const sourceModule = file.replace(dependency, path).replace('.tsx', '').replace('.ts', '');
             try {
-                const result = parseStructure(file);
-                if (!result)
-                    return;
-                const pluginConfig = {
-                    plugin: file.replace(dependency, path).replace('.tsx', '').replace('.ts', ''),
-                    ...result,
-                    enabled: !result.ifConfig || Boolean((0, get_1.default)(config, result.ifConfig)),
-                };
-                if (!(0, generateInterceptors_1.isPluginConfig)(pluginConfig)) {
-                    if (!(0, generateInterceptors_1.isPluginBaseConfig)(pluginConfig))
-                        errors.push(`Plugin ${file} is not a valid plugin, make it has "export const exported = '@graphcommerce/my-package"`);
-                    else if (file.endsWith('.ts')) {
-                        errors.push(`Plugin ${file} is not a valid plugin, please define the method to create a plugin for "export const method = 'someMethod'"`);
-                    }
-                    else if (file.endsWith('.tsx')) {
-                        errors.push(`Plugin ${file} is not a valid plugin, please define the compoennt to create a plugin for "export const component = 'SomeComponent'"`);
-                    }
-                }
-                else {
-                    plugins.push(pluginConfig);
-                }
+                const ast = (0, core_1.parseFileSync)(file, { syntax: 'typescript', tsx: true });
+                (0, parseStructure_1.parseStructure)(ast, config, sourceModule).forEach((result) => {
+                    plugins.push(result);
+                });
             }
             catch (e) {
                 console.error(`Error parsing ${file}`, e);
@@ -73,9 +34,7 @@ function findPlugins(config, cwd = process.cwd()) {
     });
     if (process.env.NODE_ENV === 'development' && debug) {
         const byExported = plugins.reduce((acc, plugin) => {
-            const componentStr = (0, generateInterceptors_1.isReactPluginConfig)(plugin) ? plugin.component : '';
-            const funcStr = (0, generateInterceptors_1.isMethodPluginConfig)(plugin) ? plugin.func : '';
-            const key = `🔌 ${chalk_1.default.greenBright(`Plugins loaded for ${plugin.exported}#${componentStr}${funcStr}`)}`;
+            const key = `🔌 ${chalk_1.default.greenBright(`Plugins loaded for ${plugin.targetModule}#${plugin.targetExport}`)}`;
             if (!acc[key])
                 acc[key] = [];
             acc[key].push(plugin);
@@ -85,7 +44,15 @@ function findPlugins(config, cwd = process.cwd()) {
         Object.entries(byExported).forEach(([key, p]) => {
             const logStr = p
                 .filter((c) => debug || c.enabled)
-                .map((c) => `${c.enabled ? `🟢` : `⚪️`} ${c.plugin} ${c.ifConfig ? `(${c.ifConfig}: ${c.enabled ? 'true' : 'false'})` : ''}`)
+                .map((c) => {
+                // eslint-disable-next-line no-nested-ternary
+                const ifConfigStr = c.ifConfig
+                    ? Array.isArray(c.ifConfig)
+                        ? `${c.ifConfig[0]}=${c.ifConfig[1]}`
+                        : `${c.ifConfig}`
+                    : '';
+                return `${c.enabled ? `🟢` : `⚪️`} ${c.sourceModule} ${ifConfigStr}`;
+            })
                 .join('\n');
             if (logStr && pluginLogs[key] !== logStr) {
                 toLog.push(`${key}\n${logStr}`);
@@ -93,7 +60,8 @@ function findPlugins(config, cwd = process.cwd()) {
             }
         });
         // eslint-disable-next-line no-console
-        console.log(toLog.join('\n\n'));
+        if (toLog.length)
+            console.log(toLog.join('\n\n'));
     }
     return [plugins, errors];
 }

package/dist/interceptors/generateInterceptor.js

@@ -0,0 +1,200 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateInterceptor = exports.moveRelativeDown = exports.SOURCE_END = exports.SOURCE_START = exports.isPluginConfig = exports.isReplacePluginConfig = exports.isMethodPluginConfig = exports.isReactPluginConfig = exports.isPluginBaseConfig = void 0;
+// eslint-disable-next-line import/no-extraneous-dependencies
+const prettier_config_pwa_1 = __importDefault(require("@graphcommerce/prettier-config-pwa"));
+// eslint-disable-next-line import/no-extraneous-dependencies
+const prettier_1 = __importDefault(require("prettier"));
+const RenameVisitor_1 = require("./RenameVisitor");
+const swc_1 = require("./swc");
+function isPluginBaseConfig(plugin) {
+    return (typeof plugin.type === 'string' &&
+        typeof plugin.sourceModule === 'string' &&
+        typeof plugin.enabled === 'boolean' &&
+        typeof plugin.targetExport === 'string');
+}
+exports.isPluginBaseConfig = isPluginBaseConfig;
+function isReactPluginConfig(plugin) {
+    if (!isPluginBaseConfig(plugin))
+        return false;
+    return plugin.type === 'component';
+}
+exports.isReactPluginConfig = isReactPluginConfig;
+function isMethodPluginConfig(plugin) {
+    if (!isPluginBaseConfig(plugin))
+        return false;
+    return plugin.type === 'function';
+}
+exports.isMethodPluginConfig = isMethodPluginConfig;
+function isReplacePluginConfig(plugin) {
+    if (!isPluginBaseConfig(plugin))
+        return false;
+    return plugin.type === 'replace';
+}
+exports.isReplacePluginConfig = isReplacePluginConfig;
+function isPluginConfig(plugin) {
+    return isPluginBaseConfig(plugin);
+}
+exports.isPluginConfig = isPluginConfig;
+exports.SOURCE_START = '/** ❗️ Original (modified) source starts here **/';
+exports.SOURCE_END = '/** ❗️ Original (modified) source ends here **/';
+const originalSuffix = 'Original';
+const sourceSuffix = 'Source';
+const interceptorSuffix = 'Interceptor';
+const disabledSuffix = 'Disabled';
+const name = (plugin) => `${plugin.sourceExport}${plugin.sourceModule
+    .split('/')[plugin.sourceModule.split('/').length - 1].replace(/[^a-zA-Z0-9]/g, '')}`;
+const fileName = (plugin) => `${plugin.sourceModule}#${plugin.sourceExport}`;
+const originalName = (n) => `${n}${originalSuffix}`;
+const sourceName = (n) => `${n}${sourceSuffix}`;
+const interceptorName = (n) => `${n}${interceptorSuffix}`;
+const interceptorPropsName = (n) => `${interceptorName(n)}Props`;
+function moveRelativeDown(plugins) {
+    return [...plugins].sort((a, b) => {
+        if (a.sourceModule.startsWith('.') && !b.sourceModule.startsWith('.'))
+            return 1;
+        if (!a.sourceModule.startsWith('.') && b.sourceModule.startsWith('.'))
+            return -1;
+        return 0;
+    });
+}
+exports.moveRelativeDown = moveRelativeDown;
+const generateIdentifyer = (s) => Math.abs(s.split('').reduce((a, b) => {
+    // eslint-disable-next-line no-param-reassign, no-bitwise
+    a = (a << 5) - a + b.charCodeAt(0);
+    // eslint-disable-next-line no-bitwise
+    return a & a;
+}, 0)).toString();
+/**
+ * The is on the first line, with the format: \/* hash:${identifer} *\/
+ */
+function extractIdentifier(source) {
+    if (!source)
+        return null;
+    const match = source.match(/\/\* hash:(\d+) \*\//);
+    if (!match)
+        return null;
+    return match[1];
+}
+async function generateInterceptor(interceptor, config, oldInterceptorSource) {
+    const identifer = generateIdentifyer(JSON.stringify(interceptor) + JSON.stringify(config));
+    const { dependency, targetExports, source } = interceptor;
+    if (oldInterceptorSource && identifer === extractIdentifier(oldInterceptorSource))
+        return { ...interceptor, template: oldInterceptorSource };
+    const pluginConfigs = [...Object.entries(targetExports)].map(([, plugins]) => plugins).flat();
+    // console.log('pluginConfigs', pluginConfigs)
+    const duplicateImports = new Set();
+    const pluginImports = moveRelativeDown([...pluginConfigs].sort((a, b) => a.sourceModule.localeCompare(b.sourceModule)))
+        .map((plugin) => `import { ${plugin.sourceExport} as ${sourceName(name(plugin))} } from '${plugin.sourceModule}'`)
+        .filter((str) => {
+        if (duplicateImports.has(str))
+            return false;
+        duplicateImports.add(str);
+        return true;
+    })
+        .join('\n');
+    const ast = (0, swc_1.parseSync)(source);
+    new RenameVisitor_1.RenameVisitor(Object.keys(targetExports), (s) => originalName(s)).visitModule(ast);
+    const pluginExports = Object.entries(targetExports)
+        .map(([base, plugins]) => {
+        const duplicateInterceptors = new Set();
+        let carry = originalName(base);
+        const carryProps = [];
+        const pluginStr = plugins
+            .reverse()
+            .filter((p) => {
+            if (duplicateInterceptors.has(name(p)))
+                return false;
+            duplicateInterceptors.add(name(p));
+            return true;
+        })
+            .map((p) => {
+            let result;
+            const wrapChain = plugins
+                .reverse()
+                .map((pl) => name(pl))
+                .join(' wrapping ');
+            if (isReplacePluginConfig(p)) {
+                new RenameVisitor_1.RenameVisitor([originalName(p.targetExport)], (s) => s.replace(originalSuffix, disabledSuffix)).visitModule(ast);
+                carryProps.push(interceptorPropsName(name(p)));
+                result = `type ${interceptorPropsName(name(p))} = React.ComponentProps<typeof ${sourceName(name(p))}>`;
+            }
+            if (isReactPluginConfig(p)) {
+                carryProps.push(interceptorPropsName(name(p)));
+                result = `
+              type ${interceptorPropsName(name(p))} = DistributedOmit<React.ComponentProps<typeof ${sourceName(name(p))}>, 'Prev'>
+              const ${interceptorName(name(p))} = (props: ${carryProps.join(' & ')}) => {
+                ${config.pluginStatus ? `logOnce(\`🔌 Rendering ${base} with plugin(s): ${wrapChain} wrapping <${base}/>\`)` : ''}
+
+                ${process.env.NODE_ENV === 'development'
+                    ? `if(!props['data-plugin'])
+                  logOnce('${fileName(p)} does not spread props to prev: <Prev {...props}/>. This will cause issues if multiple plugins are applied to this component.')`
+                    : ''}
+                return <${sourceName(name(p))} {...props} Prev={${carry} as React.FC} />
+              }`;
+            }
+            if (isMethodPluginConfig(p)) {
+                result = `const ${interceptorName(name(p))}: typeof ${carry} = (...args) => {
+                ${config.pluginStatus ? `logOnce(\`🔌 Calling ${base} with plugin(s): ${wrapChain} wrapping ${base}()\`)` : ''}
+                return ${sourceName(name(p))}(${carry}, ...args)
+              }`;
+            }
+            carry = p.type === 'replace' ? sourceName(name(p)) : interceptorName(name(p));
+            return result;
+        })
+            .filter((v) => !!v)
+            .join('\n');
+        const isComponent = plugins.every((p) => isReplacePluginConfig(p) || isReactPluginConfig(p));
+        if (isComponent && plugins.some((p) => isMethodPluginConfig(p))) {
+            throw new Error(`Cannot mix React and Method plugins for ${base} in ${dependency}.`);
+        }
+        if (process.env.NODE_ENV === 'development' && isComponent) {
+            return `${pluginStr}
+          export const ${base}: typeof ${carry} = (props) => {
+            return <${carry} {...props} data-plugin />
+          }`;
+        }
+        return `
+        ${pluginStr}
+        export const ${base} = ${carry}
+      `;
+    })
+        .join('\n');
+    const logOnce = config.pluginStatus || process.env.NODE_ENV === 'development'
+        ? `
+        const logged: Set<string> = new Set();
+        const logOnce = (log: string, ...additional: unknown[]) => {
+          if (logged.has(log)) return
+          logged.add(log)
+          console.warn(log, ...additional)
+        }
+        `
+        : '';
+    const template = `/* hash:${identifer} */
+    /* eslint-disable */
+    /* This file is automatically generated for ${dependency} */
+    ${Object.values(targetExports).some((t) => t.some((p) => p.type === 'component'))
+        ? `import type { DistributedOmit } from 'type-fest'`
+        : ''}
+
+    ${pluginImports}
+
+    ${exports.SOURCE_START}
+    ${(0, swc_1.printSync)(ast).code}
+    ${exports.SOURCE_END}
+    ${logOnce}${pluginExports}
+  `;
+    let templateFormatted;
+    try {
+        templateFormatted = await prettier_1.default.format(template, { ...prettier_config_pwa_1.default, parser: 'typescript' });
+    }
+    catch (e) {
+        console.log('Error formatting interceptor: ', e, 'using raw template.');
+        templateFormatted = template;
+    }
+    return { ...interceptor, template: templateFormatted };
+}
+exports.generateInterceptor = generateInterceptor;