@checkdigit/eslint-plugin 7.6.0-PR.75-4751 → 7.6.0-PR.97-af5e

package/src/agent/add-base-path-import.ts

@@ -1,69 +0,0 @@
-// agent/add-url-domain.ts
-
-/*
- * Copyright (c) 2021-2024 Check Digit, LLC
- *
- * This code is licensed under the MIT license (see LICENSE.txt for details).
- */
-
-import { strict as assert } from 'node:assert';
-
-import { AST_NODE_TYPES, ESLintUtils } from '@typescript-eslint/utils';
-
-import getDocumentationUrl from '../get-documentation-url';
-import { getApiIndexPathByFilename } from './file';
-
-export const ruleId = 'add-base-path-import';
-
-const createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
-
-const rule: ESLintUtils.RuleModule<'addBasePathImport'> = createRule({
-  name: ruleId,
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Add import of BASE_PATH if it is used but not imported.',
-    },
-    messages: {
-      addBasePathImport: 'Add import of BASE_PATH.',
-    },
-    fixable: 'code',
-    schema: [],
-  },
-  defaultOptions: [],
-  create(context) {
-    const sourceCode = context.sourceCode;
-
-    return {
-      Program: (program) => {
-        const isBasePathUsed = sourceCode.text.includes(`$\{BASE_PATH}`);
-        if (isBasePathUsed) {
-          const topScope = sourceCode.getScope(program).childScopes[0];
-          assert(topScope);
-          if (topScope.variables.some((variable) => variable.name === 'BASE_PATH')) {
-            return;
-          }
-
-          const apiIndexPath = getApiIndexPathByFilename(context.filename);
-          if (apiIndexPath !== undefined) {
-            const lastImportStatement = program.body.findLast(
-              (statement) => statement.type === AST_NODE_TYPES.ImportDeclaration,
-            );
-            assert(lastImportStatement);
-
-            const basePathImportStatement = `\nimport { BASE_PATH } from '${apiIndexPath}';\n`;
-            context.report({
-              node: program,
-              messageId: 'addBasePathImport',
-              fix(fixer) {
-                return fixer.insertTextAfter(lastImportStatement, basePathImportStatement);
-              },
-            });
-          }
-        }
-      },
-    };
-  },
-});
-
-export default rule;

package/src/agent/add-url-domain.ts

@@ -1,76 +0,0 @@
-// agent/add-url-domain.ts
-
-/*
- * Copyright (c) 2021-2024 Check Digit, LLC
- *
- * This code is licensed under the MIT license (see LICENSE.txt for details).
- */
-
-import { AST_NODE_TYPES, ESLintUtils, TSESTree } from '@typescript-eslint/utils';
-
-import getDocumentationUrl from '../get-documentation-url';
-import { addBasePathUrlDomain } from './url';
-
-export const ruleId = 'add-url-domain';
-
-const createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
-
-const rule: ESLintUtils.RuleModule<'addDomain' | 'unknownError'> = createRule({
-  name: ruleId,
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Add HTTP domain to the BASE_PATH like url constant variable.',
-    },
-    messages: {
-      addDomain: 'Add HTTP domain to the BASE_PATH like url constant variable.',
-      unknownError: 'Unknown error occurred in file "{{fileName}}": {{ error }}.',
-    },
-    fixable: 'code',
-    schema: [],
-  },
-  defaultOptions: [],
-  create(context) {
-    const sourceCode = context.sourceCode;
-
-    return {
-      'VariableDeclarator[id.name=/^([A-Z]+_)*BASE_PATH$/]': (basePathDeclarator: TSESTree.VariableDeclarator) => {
-        try {
-          if (
-            basePathDeclarator.init === null ||
-            (basePathDeclarator.init.type !== AST_NODE_TYPES.Literal &&
-              basePathDeclarator.init.type !== AST_NODE_TYPES.TemplateLiteral)
-          ) {
-            return;
-          }
-
-          const urlText = sourceCode.getText(basePathDeclarator.init);
-          const replacement = addBasePathUrlDomain(urlText);
-
-          if (replacement !== urlText) {
-            context.report({
-              messageId: 'addDomain',
-              node: basePathDeclarator.init,
-              fix(fixer) {
-                return fixer.replaceText(basePathDeclarator.init as TSESTree.Node, replacement);
-              },
-            });
-          }
-        } catch (error) {
-          // eslint-disable-next-line no-console
-          console.error(`Failed to apply ${ruleId} rule for file "${context.filename}":`, error);
-          context.report({
-            node: basePathDeclarator,
-            messageId: 'unknownError',
-            data: {
-              fileName: context.filename,
-              error: error instanceof Error ? error.toString() : JSON.stringify(error),
-            },
-          });
-        }
-      },
-    };
-  },
-});
-
-export default rule;

package/src/agent/agent-test-wiring.ts

@@ -1,273 +0,0 @@
-// agent/agent-test-wiring.ts
-
-/*
- * Copyright (c) 2021-2024 Check Digit, LLC
- *
- * This code is licensed under the MIT license (see LICENSE.txt for details).
- */
-
-import { strict as assert } from 'node:assert';
-
-import { AST_TOKEN_TYPES, ESLintUtils, TSESTree } from '@typescript-eslint/utils';
-import type { RuleFix, RuleFixer } from '@typescript-eslint/utils/ts-eslint';
-import debug from 'debug';
-
-import getDocumentationUrl from '../get-documentation-url';
-
-export const ruleId = 'agent-test-wiring';
-const createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
-const log = debug('eslint-plugin:agent:agent-test-wiring');
-
-const STATEMENT_FIXTURE_RESET = 'fixture.reset()';
-const STATEMENT_FIXTURE_RESET_AWAITED = `await ${STATEMENT_FIXTURE_RESET};`;
-const STATEMENT_AGENT_DECLARATION = 'let agent: Agent;';
-const STATEMENT_AGENT_CREATION = 'agent = await createAgent();';
-const STATEMENT_AGENT_REGISTER = 'agent.register(await fixturePlugin(fixture));';
-const STATEMENT_AGENT_ENABLE = 'agent.enable();';
-const STATEMENT_AGENT_DISPOSE = 'await agent[Symbol.asyncDispose]();';
-
-const rule: ESLintUtils.RuleModule<'updateTestWiring' | 'unknownError'> = createRule({
-  name: ruleId,
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Update test wiring.',
-    },
-    messages: {
-      updateTestWiring: 'Updating test wiring.',
-      unknownError: 'Unknown error occurred in file "{{fileName}}": {{ error }}.',
-    },
-    fixable: 'code',
-    schema: [],
-  },
-  defaultOptions: [],
-  // eslint-disable-next-line max-lines-per-function
-  create(context) {
-    log('Processing file:', context.filename);
-    const sourceCode = context.sourceCode;
-    const importDeclarations = new Map<string, TSESTree.ImportDeclaration>();
-    let isFixtureUsed = false;
-    let beforeAll: TSESTree.CallExpression | undefined;
-    let beforeEach: TSESTree.CallExpression | undefined;
-    let afterAll: TSESTree.CallExpression | undefined;
-
-    return {
-      ImportDeclaration(importDeclaration) {
-        const moduleName = importDeclaration.source.value;
-        importDeclarations.set(moduleName, importDeclaration);
-        if (
-          moduleName === '@checkdigit/fixture' &&
-          importDeclaration.specifiers.some(
-            (specifier) =>
-              specifier.type === TSESTree.AST_NODE_TYPES.ImportSpecifier &&
-              specifier.imported.type === TSESTree.AST_NODE_TYPES.Identifier &&
-              specifier.imported.name === 'createFixture',
-          )
-        ) {
-          isFixtureUsed = true;
-        }
-      },
-      'CallExpression[callee.name="beforeAll"]': (callExpression: TSESTree.CallExpression) => {
-        beforeAll = callExpression;
-      },
-      'CallExpression[callee.name="beforeEach"]': (callExpression: TSESTree.CallExpression) => {
-        beforeEach = callExpression;
-      },
-      'CallExpression[callee.name="afterAll"]': (callExpression: TSESTree.CallExpression) => {
-        afterAll = callExpression;
-      },
-      // eslint-disable-next-line sonarjs/cognitive-complexity
-      'Program:exit'(program) {
-        if (!isFixtureUsed || (beforeAll === undefined && beforeEach === undefined)) {
-          // only update test wiring if fixture is used
-          return;
-        }
-
-        try {
-          let jestImportFixer: ((fixer: RuleFixer) => RuleFix) | undefined;
-          let agentImportFixer: ((fixer: RuleFixer) => RuleFix) | undefined;
-          let fixturePluginImportFixer: ((fixer: RuleFixer) => RuleFix) | undefined;
-          let agentDeclarationFixer: ((fixer: RuleFixer) => RuleFix) | undefined;
-          let beforeAllOrEachFixer: ((fixer: RuleFixer) => RuleFix) | undefined;
-          let afterAllFixer: ((fixer: RuleFixer) => RuleFix) | undefined;
-
-          const lastImportDeclaration = [...importDeclarations.values()].at(-1);
-          assert.ok(lastImportDeclaration);
-
-          // make sure that afterAll is imported from jest
-          const jestImportDeclaration = importDeclarations.get('@jest/globals');
-          assert.ok(jestImportDeclaration);
-          const importsToAdd = ['afterAll', 'beforeAll'].filter(
-            (jestHook) =>
-              !jestImportDeclaration.specifiers.some(
-                (specifier) =>
-                  specifier.type === TSESTree.AST_NODE_TYPES.ImportSpecifier &&
-                  specifier.imported.type === TSESTree.AST_NODE_TYPES.Identifier &&
-                  specifier.imported.name === jestHook,
-              ),
-          );
-          if (importsToAdd.length > 0) {
-            const firstImportSpecifier = jestImportDeclaration.specifiers[0];
-            assert.ok(firstImportSpecifier);
-            jestImportFixer = (fixer: RuleFixer) =>
-              fixer.insertTextBefore(firstImportSpecifier, `${importsToAdd.join(', ')}, `);
-          }
-
-          // make sure that agent is imported
-          const agentImportDeclaration = importDeclarations.get('@checkdigit/agent');
-          if (!agentImportDeclaration) {
-            agentImportFixer = (fixer: RuleFixer) =>
-              fixer.insertTextAfter(
-                lastImportDeclaration,
-                `\nimport createAgent, { type Agent } from '@checkdigit/agent';`,
-              );
-          }
-
-          // make sure that fixture plugin is imported
-          const pathLets = context.filename.split('/');
-          const currentFileIndex = pathLets.length - 1;
-          const pluginFolderIndex = pathLets.lastIndexOf('src') + 1;
-          // it should be safe to assume that the test code is always at least one level deeper than the plugin folder
-          const fixturePluginImportPath = `${'../'.repeat(currentFileIndex - pluginFolderIndex)}plugin/fixture.test`;
-          if (!importDeclarations.get(fixturePluginImportPath)) {
-            fixturePluginImportFixer = (fixer: RuleFixer) =>
-              fixer.insertTextAfter(lastImportDeclaration, `\nimport fixturePlugin from '${fixturePluginImportPath}';`);
-          }
-
-          // inject agent declaration and initialization
-          if (beforeAll === undefined) {
-            // create `beforeAll` block if it doesn't exist
-            beforeAllOrEachFixer = (fixer: RuleFixer) =>
-              fixer.insertTextBefore(
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                beforeEach!,
-                [
-                  STATEMENT_AGENT_DECLARATION,
-                  `beforeAll(async () => {`,
-                  [STATEMENT_AGENT_CREATION, STATEMENT_AGENT_REGISTER, STATEMENT_AGENT_ENABLE].join('\n'),
-                  `});\n`,
-                ].join('\n'),
-              );
-          } else {
-            const beforeAllArgument = beforeAll.arguments[0];
-            assert.ok(beforeAllArgument !== undefined);
-            if (!sourceCode.getText(beforeAllArgument).includes(STATEMENT_AGENT_CREATION)) {
-              if (
-                beforeAllArgument.type === TSESTree.AST_NODE_TYPES.ArrowFunctionExpression &&
-                beforeAllArgument.body.type === TSESTree.AST_NODE_TYPES.BlockStatement
-              ) {
-                const fixtureResetStatement = beforeAllArgument.body.body.find(
-                  (statement) => sourceCode.getText(statement) === STATEMENT_FIXTURE_RESET_AWAITED,
-                );
-                assert.ok(fixtureResetStatement !== undefined);
-                beforeAllOrEachFixer = (fixer: RuleFixer) =>
-                  fixer.replaceText(
-                    fixtureResetStatement,
-                    [
-                      STATEMENT_AGENT_CREATION,
-                      STATEMENT_AGENT_REGISTER,
-                      STATEMENT_AGENT_ENABLE,
-                      STATEMENT_FIXTURE_RESET_AWAITED,
-                    ].join('\n'),
-                  );
-              } else {
-                beforeAllOrEachFixer = (fixer: RuleFixer) =>
-                  fixer.replaceText(
-                    beforeAllArgument,
-                    [
-                      `async () => {`,
-                      STATEMENT_AGENT_CREATION,
-                      STATEMENT_AGENT_REGISTER,
-                      STATEMENT_AGENT_ENABLE,
-                      STATEMENT_FIXTURE_RESET_AWAITED,
-                      `}`,
-                    ].join('\n'),
-                  );
-              }
-              agentDeclarationFixer = (fixer: RuleFixer) =>
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                fixer.insertTextBefore(beforeAll!, `${STATEMENT_AGENT_DECLARATION}\n`);
-            }
-          }
-
-          // inject agent disposal to `afterAll` block
-          if (afterAll !== undefined) {
-            const afterAllArrowFunctionExpression = afterAll.arguments[0];
-            assert.ok(
-              afterAllArrowFunctionExpression !== undefined &&
-                afterAllArrowFunctionExpression.type === TSESTree.AST_NODE_TYPES.ArrowFunctionExpression,
-            );
-            const arrowFunctionBody = afterAllArrowFunctionExpression.body;
-            assert.ok(arrowFunctionBody.type === TSESTree.AST_NODE_TYPES.BlockStatement);
-
-            const afterAllBodyText = sourceCode.getText(arrowFunctionBody);
-            if (!afterAllBodyText.includes(STATEMENT_AGENT_DISPOSE)) {
-              const lastStatement = arrowFunctionBody.body.at(-1);
-              assert.ok(lastStatement);
-              afterAllFixer = (fixer: RuleFixer) => fixer.insertTextAfter(lastStatement, STATEMENT_AGENT_DISPOSE);
-            }
-          } else {
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            const nextToken = sourceCode.getTokenAfter(beforeAll ?? beforeEach!);
-            afterAllFixer = (fixer: RuleFixer) =>
-              fixer.insertTextAfter(
-                nextToken !== null && nextToken.type === AST_TOKEN_TYPES.Punctuator
-                  ? nextToken
-                  : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                    beforeAll!,
-                ['', `afterAll(async () => {`, STATEMENT_AGENT_DISPOSE, `});`].join('\n'),
-              );
-          }
-
-          if (
-            jestImportFixer !== undefined ||
-            agentImportFixer !== undefined ||
-            fixturePluginImportFixer !== undefined ||
-            agentDeclarationFixer !== undefined ||
-            beforeAllOrEachFixer !== undefined ||
-            afterAllFixer !== undefined
-          ) {
-            context.report({
-              messageId: 'updateTestWiring',
-              // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-              node: beforeAll ?? beforeEach!,
-              *fix(fixer) {
-                if (jestImportFixer !== undefined) {
-                  yield jestImportFixer(fixer);
-                }
-                if (agentImportFixer !== undefined) {
-                  yield agentImportFixer(fixer);
-                }
-                if (fixturePluginImportFixer !== undefined) {
-                  yield fixturePluginImportFixer(fixer);
-                }
-                if (agentDeclarationFixer !== undefined) {
-                  yield agentDeclarationFixer(fixer);
-                }
-                if (beforeAllOrEachFixer !== undefined) {
-                  yield beforeAllOrEachFixer(fixer);
-                }
-                if (afterAllFixer !== undefined) {
-                  yield afterAllFixer(fixer);
-                }
-              },
-            });
-          }
-        } catch (error) {
-          // eslint-disable-next-line no-console
-          console.error(`Failed to apply ${ruleId} rule for file "${context.filename}":`, error);
-          context.report({
-            node: program,
-            messageId: 'unknownError',
-            data: {
-              fileName: context.filename,
-              error: error instanceof Error ? error.toString() : JSON.stringify(error),
-            },
-          });
-        }
-      },
-    };
-  },
-});
-
-export default rule;

package/src/agent/fetch-response-body-json.ts

@@ -1,194 +0,0 @@
-// agent/fetch-response-body-json.ts
-
-/*
- * Copyright (c) 2021-2024 Check Digit, LLC
- *
- * This code is licensed under the MIT license (see LICENSE.txt for details).
- */
-
-import { strict as assert } from 'node:assert';
-
-import { AST_NODE_TYPES, ESLintUtils, TSESTree } from '@typescript-eslint/utils';
-
-import getDocumentationUrl from '../get-documentation-url';
-import { getAncestor } from '../library/ts-tree';
-import { isFetchResponse } from './fetch';
-
-export const ruleId = 'fetch-response-body-json';
-
-const createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
-
-interface Change {
-  enclosingFunction: TSESTree.FunctionExpression | TSESTree.ArrowFunctionExpression | TSESTree.FunctionDeclaration;
-  enclosingStatement: TSESTree.VariableDeclaration | TSESTree.ExpressionStatement | TSESTree.ReturnStatement;
-  enclosingStatementIndex: number;
-  responseBodyNode: TSESTree.MemberExpression;
-  responseVariableName: string;
-  responseBodyVariableName: string;
-  isResponseBodyVariableDeclared: boolean;
-  // replacementText: string;
-}
-
-const rule: ESLintUtils.RuleModule<'unknownError' | 'replaceBodyWithJson' | 'refactorNeeded'> = createRule({
-  name: ruleId,
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Replace "response.body" with "await response.json()".',
-    },
-    messages: {
-      refactorNeeded:
-        'Please extract the fetch call and check its reponse status code before accessing its response body.',
-      replaceBodyWithJson: 'Replace "response.body" with "await response.json()".',
-      unknownError: 'Unknown error occurred in file "{{fileName}}": {{ error }}.',
-    },
-    fixable: 'code',
-    schema: [],
-  },
-  defaultOptions: [],
-  create(context) {
-    const parserServices = ESLintUtils.getParserServices(context);
-    const typeChecker = parserServices.program.getTypeChecker();
-    const allChanges = new Map<TSESTree.Node, Map<string, Change[]>>();
-
-    return {
-      'MemberExpression[property.name="body"]': (responseBodyNode: TSESTree.MemberExpression) => {
-        try {
-          const responseNode = parserServices.esTreeNodeToTSNodeMap.get(responseBodyNode.object);
-          const responseType = typeChecker.getTypeAtLocation(responseNode);
-
-          if (isFetchResponse(responseType)) {
-            if (responseBodyNode.object.type !== AST_NODE_TYPES.Identifier) {
-              context.report({
-                node: responseBodyNode,
-                messageId: 'refactorNeeded',
-              });
-              return;
-            }
-
-            const enclosingFunction = getAncestor(
-              responseBodyNode,
-              (node: TSESTree.Node) =>
-                node.type === AST_NODE_TYPES.ArrowFunctionExpression ||
-                node.type === AST_NODE_TYPES.FunctionExpression ||
-                node.type === AST_NODE_TYPES.FunctionDeclaration,
-            ) as TSESTree.FunctionExpression | TSESTree.ArrowFunctionExpression | TSESTree.FunctionDeclaration;
-            const enclosingStatement = getAncestor(
-              responseBodyNode,
-              (node: TSESTree.Node) =>
-                (node.type === AST_NODE_TYPES.VariableDeclaration ||
-                  node.type === AST_NODE_TYPES.ExpressionStatement ||
-                  node.type === AST_NODE_TYPES.ReturnStatement) &&
-                node.parent.type === AST_NODE_TYPES.BlockStatement,
-            ) as TSESTree.VariableDeclaration | TSESTree.ExpressionStatement | TSESTree.ReturnStatement;
-            const enclosingStatementIndex = (enclosingFunction.body as TSESTree.BlockStatement).body.indexOf(
-              enclosingStatement,
-            );
-            const responseVariableName = responseBodyNode.object.name;
-            const isResponseBodyVariableDeclared =
-              enclosingStatement.type === AST_NODE_TYPES.VariableDeclaration &&
-              enclosingStatement.declarations.some(
-                (declaration) =>
-                  declaration.init === responseBodyNode ||
-                  (declaration.init?.type === AST_NODE_TYPES.TSAsExpression &&
-                    declaration.init.expression === responseBodyNode),
-              );
-            const responseBodyVariableName = isResponseBodyVariableDeclared
-              ? (enclosingStatement.declarations.find(
-                  (declaration) =>
-                    declaration.init === responseBodyNode ||
-                    (declaration.init?.type === AST_NODE_TYPES.TSAsExpression &&
-                      declaration.init.expression === responseBodyNode),
-                )?.id as unknown as string)
-              : `${responseBodyNode.object.name}Body`;
-
-            const change: Change = {
-              enclosingFunction,
-              enclosingStatement,
-              enclosingStatementIndex,
-              responseVariableName,
-              responseBodyNode,
-              responseBodyVariableName,
-              isResponseBodyVariableDeclared,
-            };
-
-            const changesByFunction = allChanges.get(enclosingFunction) ?? new Map<string, Change[]>();
-            const changesByResponse = changesByFunction.get(responseVariableName) ?? [];
-            changesByResponse.push(change);
-            changesByFunction.set(responseVariableName, changesByResponse);
-            allChanges.set(enclosingFunction, changesByFunction);
-          }
-        } catch (error) {
-          // eslint-disable-next-line no-console
-          console.error(`Failed to apply ${ruleId} rule for file "${context.filename}":`, error);
-          context.report({
-            node: responseBodyNode,
-            messageId: 'unknownError',
-            data: {
-              fileName: context.filename,
-              error: error instanceof Error ? error.toString() : JSON.stringify(error),
-            },
-          });
-        }
-      },
-
-      'Program:exit': () => {
-        if (allChanges.size === 0) {
-          return;
-        }
-
-        const fixes: { node: TSESTree.Node | TSESTree.Token; text: string; insert: boolean }[] = [];
-        for (const changesByFunction of allChanges.values()) {
-          for (const changesByResponse of changesByFunction.values()) {
-            const orderedChanges = changesByResponse.sort(
-              (changeA, changeB) => changeA.enclosingStatementIndex - changeB.enclosingStatementIndex,
-            );
-            const firstChange = orderedChanges[0];
-            assert(firstChange);
-
-            const {
-              responseBodyNode,
-              responseVariableName,
-              responseBodyVariableName,
-              isResponseBodyVariableDeclared,
-              enclosingStatement,
-            } = firstChange;
-
-            let remainingChanges;
-            if (!isResponseBodyVariableDeclared) {
-              fixes.push({
-                node: context.sourceCode.getTokenBefore(enclosingStatement) as TSESTree.Token,
-                text: `\nconst ${responseBodyVariableName} = await ${responseVariableName}.json();`,
-                insert: true,
-              });
-              remainingChanges = orderedChanges;
-            } else {
-              fixes.push({
-                node: responseBodyNode,
-                text: `await ${responseVariableName}.json()`,
-                insert: false,
-              });
-              remainingChanges = orderedChanges.slice(1);
-            }
-
-            for (const change of remainingChanges) {
-              fixes.push({ node: change.responseBodyNode, text: responseBodyVariableName, insert: false });
-            }
-          }
-        }
-
-        for (const fix of fixes.reverse()) {
-          context.report({
-            node: fix.node,
-            messageId: 'replaceBodyWithJson',
-            fix(fixer) {
-              return fix.insert ? fixer.insertTextAfter(fix.node, fix.text) : fixer.replaceText(fix.node, fix.text);
-            },
-          });
-        }
-      },
-    };
-  },
-});
-
-export default rule;