@ms-cloudpack/eslint-plugin 0.1.1

package/README.md

@@ -0,0 +1,113 @@
+# @ms-cloudpack/eslint-plugin
+
+`@ms-cloudpack/eslint-plugin` provides a shared config and custom rules to help encourage Cloudpack-friendly coding practices, specifically regarding imports and exports.
+
+## Recommended config
+
+To enable the `@ms-cloudpack/recommended` configuration, add it to your ESLint config file:
+
+```json
+{
+  "plugins": ["@ms-cloudpack"],
+  "extends": ["plugin:@ms-cloudpack/recommended"]
+}
+```
+
+`@ms-cloudpack/recommended` currently includes the following rules:
+
+- `@ms-cloudpack/no-unsupported-imports`
+
+## Included rules
+
+- ✓: Enabled with `@ms-cloudpack/recommended`
+- 🔧: Fixable with `--fix`
+
+|  ✓  | 🔧  | Rule                                   | Description                                               |
+| :-: | :-: | :------------------------------------- | :-------------------------------------------------------- |
+|  ✓  |     | `@ms-cloudpack/no-unsupported-imports` | Ban deep imports that are not defined in an `exports` map |
+
+### `no-unsupported-imports`
+
+This rule bans deep imports from paths which aren't defined in a package's [exports map](https://nodejs.org/api/packages.html#package-entry-points). It also bans **all** deep imports from packages which don't define exports maps.
+
+Features:
+
+- Supports all common "import-like" syntax variants (`import`, `export` from paths, `require`)
+- Basic support for wildcards and directories in exports maps
+- Caches resolved package info to reduce disk access
+- Provides suggestions (not auto-fixes) for importing from package root in some cases
+
+Current limitations (handling for some of these could be added if needed):
+
+- Not sensitive to conditions: it passes if a path is exported for any condition
+- Can't auto-fix. This would require either type information (to figure out where symbols are defined and whether they're exported from the root) or complete manual traversal of a package's exported paths and symbols.
+- Limited support for later exclusions underneath wildcards or directories
+- Doesn't verify that the resolved path exists on disk (reduces cost and complexity)
+- Does no verification of top-level package imports. This is intentional for performance and usually correct, but it would fail to detect a package that _only_ defines deep imports in its exports map. (Importing specific packages with this issue could be banned with ESLint's `no-restricted-imports`.)
+
+#### Options
+
+- `ignorePatterns` (`string[]`): Don't check imports matching these regular expression patterns. Examples:
+  - `"^foo/"`: Ignore all imports under `foo`
+  - `"^foo/bar/`: Ignore imports under `foo/bar`
+  - `"^foo/bar/baz$"`: Ignore the specific path `foo/bar/baz`
+
+#### Examples
+
+For this package without an exports map:
+
+```json
+{
+  "name": "no-exports",
+  "main": "lib/index.js"
+}
+```
+
+The rule bans all deep imports, regardless of whether the files being imported exist on disk:
+
+```js
+// ✅ OK
+import { foo } from 'no-exports';
+// and other variants of import/export syntax
+
+// ❌ Error
+import { foo } from 'no-exports/lib/foo';
+import { foo } from 'no-exports/lib/index';
+const packageJson = require('no-exports/package.json');
+
+// ✅ OK with ignorePatterns such as ["^no-exports/"] or ["^no-exports/lib/foo$"]
+import { foo } from 'no-exports/lib/foo';
+```
+
+For this package with an exports map:
+
+```json
+{
+  "name": "with-exports",
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./lib/foo": "./lib/foo.js",
+    "./lib/utils/*": "./lib/utils/*.js"
+  }
+}
+```
+
+The rule allows root imports or those matching keys in the exports map:
+
+```js
+// ✅ OK
+import { foo } from 'with-exports';
+import { foo } from 'with-exports/lib/foo';
+import { foo } from 'with-exports/lib/utils/bar';
+
+// ❌ Error
+// Not included in exports
+import { foo } from 'with-exports/lib/nope';
+const packageJson = require('with-exports/package.json');
+// Path in exports doesn't have extension
+import { foo } from 'with-exports/lib/foo.js';
+
+// ✅ OK with ignorePatterns such as ["^with-exports/"] or ["^with-exports/lib/nope$"]
+import { foo } from 'with-exports/lib/nope';
+```

package/lib/configs/recommended.d.ts

@@ -0,0 +1,3 @@
+import type { ESLint } from 'eslint';
+export declare const recommended: ESLint.ConfigData;
+//# sourceMappingURL=recommended.d.ts.map

package/lib/configs/recommended.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recommended.d.ts","sourceRoot":"","sources":["../../src/configs/recommended.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAErC,eAAO,MAAM,WAAW,EAAE,MAAM,CAAC,UAKhC,CAAC"}

package/lib/configs/recommended.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recommended = void 0;
+exports.recommended = {
+    plugins: ['@ms-cloudpack', '@typescript-eslint'],
+    rules: {
+        '@ms-cloudpack/no-unsupported-imports': 'error',
+    },
+};
+//# sourceMappingURL=recommended.js.map

package/lib/configs/recommended.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"recommended.js","sourceRoot":"","sources":["../../src/configs/recommended.ts"],"names":[],"mappings":";;;AAEa,QAAA,WAAW,GAAsB;IAC5C,OAAO,EAAE,CAAC,eAAe,EAAE,oBAAoB,CAAC;IAChD,KAAK,EAAE;QACL,sCAAsC,EAAE,OAAO;KAChD;CACF,CAAC","sourcesContent":["import type { ESLint } from 'eslint';\n\nexport const recommended: ESLint.ConfigData = {\n  plugins: ['@ms-cloudpack', '@typescript-eslint'],\n  rules: {\n    '@ms-cloudpack/no-unsupported-imports': 'error',\n  },\n};\n"]}

package/lib/index.d.ts

@@ -0,0 +1,10 @@
+declare const _default: {
+    configs: {
+        recommended: import("eslint").ESLint.ConfigData<import("eslint").Linter.RulesRecord>;
+    };
+    rules: {
+        'no-unsupported-imports': import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleModule<import("./rules/no-unsupported-imports.js").MessageIds, import("./rules/no-unsupported-imports.js").RawRuleOptions[], import("@typescript-eslint/utils/dist/ts-eslint/Rule.js").RuleListener>;
+    };
+};
+export = _default;
+//# sourceMappingURL=index.d.ts.map

package/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;AAGA,kBAOE"}

package/lib/index.js

@@ -0,0 +1,12 @@
+"use strict";
+const recommended_js_1 = require("./configs/recommended.js");
+const no_unsupported_imports_js_1 = require("./rules/no-unsupported-imports.js");
+module.exports = {
+    configs: {
+        recommended: recommended_js_1.recommended,
+    },
+    rules: {
+        'no-unsupported-imports': no_unsupported_imports_js_1.rule,
+    },
+};
+//# sourceMappingURL=index.js.map

package/lib/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";AAAA,6DAAuD;AACvD,iFAAiF;AAEjF,iBAAS;IACP,OAAO,EAAE;QACP,WAAW,EAAX,4BAAW;KACZ;IACD,KAAK,EAAE;QACL,wBAAwB,EAAE,gCAAoB;KAC/C;CACF,CAAC","sourcesContent":["import { recommended } from './configs/recommended.js';\nimport { rule as noUnsupportedImports } from './rules/no-unsupported-imports.js';\n\nexport = {\n  configs: {\n    recommended,\n  },\n  rules: {\n    'no-unsupported-imports': noUnsupportedImports,\n  },\n};\n"]}

package/lib/rules/no-unsupported-imports.d.ts

@@ -0,0 +1,20 @@
+import type { TSESLint } from '@typescript-eslint/utils';
+/** Processed rule options */
+type RuleOptions = {
+    ignorePatterns: RegExp[];
+    debug: boolean;
+};
+/** Rule options as specified in the config */
+export type RawRuleOptions = Omit<Partial<RuleOptions>, 'ignorePatterns'> & {
+    ignorePatterns?: string[];
+};
+export type ErrorMessageIds = 'noExports' | 'noExportsLocal' | 'notExported' | 'notExportedLocal';
+export type SuggestMessageIds = 'useTopLevel';
+export type MessageIds = ErrorMessageIds | SuggestMessageIds;
+export type ErrorData = {
+    packageName: string;
+    subPath: string;
+};
+export declare const rule: TSESLint.RuleModule<MessageIds, RawRuleOptions[]>;
+export {};
+//# sourceMappingURL=no-unsupported-imports.d.ts.map

package/lib/rules/no-unsupported-imports.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-unsupported-imports.d.ts","sourceRoot":"","sources":["../../src/rules/no-unsupported-imports.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAOzD,6BAA6B;AAC7B,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAEF,8CAA8C;AAC9C,MAAM,MAAM,cAAc,GAAG,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,gBAAgB,CAAC,GAAG;IAC1E,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;CAC3B,CAAC;AAOF,MAAM,MAAM,eAAe,GAAG,WAAW,GAAG,gBAAgB,GAAG,aAAa,GAAG,kBAAkB,CAAC;AAClG,MAAM,MAAM,iBAAiB,GAAG,aAAa,CAAC;AAC9C,MAAM,MAAM,UAAU,GAAG,eAAe,GAAG,iBAAiB,CAAC;AAE7D,MAAM,MAAM,SAAS,GAAG;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AA+BF,eAAO,MAAM,IAAI,EAAE,QAAQ,CAAC,UAAU,CAAC,UAAU,EAAE,cAAc,EAAE,CA2DlE,CAAC"}

package/lib/rules/no-unsupported-imports.js

@@ -0,0 +1,179 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rule = void 0;
+const getImportPathLiteralNode_1 = require("../utils/getImportPathLiteralNode");
+const getPackageInfo_1 = require("../utils/getPackageInfo");
+const parseImportIfRelevant_1 = require("../utils/parseImportIfRelevant");
+const pathSatisfiesAnyExport_1 = require("../utils/pathSatisfiesAnyExport");
+const resolvePackageRoot_1 = require("../utils/resolvePackageRoot");
+const defaultOptions = {
+    ignorePatterns: [],
+    debug: false,
+};
+const preferTopLevel = 'prefer importing directly from "{{packageName}}" if possible';
+const noExports = '"{{packageName}}" doesn\'t have an exports map, so deep imports aren\'t allowed; ' + preferTopLevel;
+const notExported = 'Path "{{subPath}}" is not exported by "{{packageName}}", according to its exports map; ' + preferTopLevel;
+const localMessage = '(Consider updating "{{packageName}}" to export additional identifiers if needed, ' +
+    'or if deep imports are strictly necessary, add an exports map.)';
+const messages = {
+    noExports,
+    noExportsLocal: `${noExports}. ${localMessage}`,
+    notExported,
+    notExportedLocal: `${notExported}. ${localMessage}`,
+    useTopLevel: 'Import directly from "{{packageName}}", if possible',
+};
+const suggestMessageId = 'useTopLevel';
+exports.rule = {
+    defaultOptions: [defaultOptions],
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'ban importing from non-exported paths',
+            recommended: 'error',
+        },
+        hasSuggestions: true,
+        messages,
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    ignorePatterns: {
+                        type: 'array',
+                        description: 'Ignore imports matching these regular expression patterns.',
+                        items: { type: 'string' },
+                    },
+                    debug: { type: 'boolean' },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    create: (context) => {
+        const options = context.options?.[0] || {};
+        const ruleContext = {
+            ...context,
+            options: {
+                debug: false,
+                ...options,
+                ignorePatterns: (options.ignorePatterns || []).map((str) => new RegExp(str)),
+            },
+            filename: context.getFilename(),
+        };
+        return {
+            // import foo from 'foo'
+            // import * as foo from 'foo'
+            // import { foo } from 'foo'
+            // import { foo as bar } from 'foo'
+            // import 'foo'
+            ImportDeclaration: (node) => checkImportOrExport(ruleContext, node),
+            // await import('foo')
+            ImportExpression: (node) => checkImportOrExport(ruleContext, node),
+            // import foo = require('foo')
+            TSImportEqualsDeclaration: (node) => checkImportOrExport(ruleContext, node),
+            // export { foo } from 'foo'
+            // export { foo as bar } from 'foo'
+            ExportNamedDeclaration: (node) => checkImportOrExport(ruleContext, node),
+            // export * from 'foo'
+            // export * as foo from 'foo'
+            ExportAllDeclaration: (node) => checkImportOrExport(ruleContext, node),
+            // require('foo')
+            // require.resolve('foo')
+            CallExpression: (node) => checkImportOrExport(ruleContext, node),
+        };
+    },
+};
+function checkImportOrExport(context, node) {
+    const pathNode = (0, getImportPathLiteralNode_1.getImportPathLiteralNode)(node);
+    if (!pathNode) {
+        return;
+    }
+    const errorData = checkImportPath(context, pathNode.value);
+    if (!errorData) {
+        return; // Import is fine
+    }
+    // At this point, the import is probably invalid, so report it.
+    // (Might still be a false positive if it's a local package that hasn't been built yet.)
+    const { messageId, ...data } = errorData;
+    // For named imports/exports or import *, suggest importing from the package root.
+    // This is just a suggestion, so it doesn't have to be correct, but we also want to avoid
+    // suggesting when it's likely to be misleading or might cause issues; for example:
+    // - Default imports may refer to an actual default export or the entire module
+    // - Side effect imports are likely specific to a particular file
+    // - Async import()
+    // - export * from an entire package might export a lot more things
+    // - require() could be used in many ways (would have to look at more context)
+    // - require.resolve() is typically used to find the path to a specific file
+    let suggestion;
+    if (
+    // import { foo } from 'foo/bar'
+    (node.type === 'ImportDeclaration' && node.specifiers[0]?.type === 'ImportSpecifier') ||
+        // import * as foo from 'foo/bar'
+        (node.type === 'ImportDeclaration' && node.specifiers[0]?.type === 'ImportNamespaceSpecifier') ||
+        // import foo = require('foo/bar')
+        node.type === 'TSImportEqualsDeclaration' ||
+        // export { foo } from 'foo/bar'
+        node.type === 'ExportNamedDeclaration') {
+        suggestion = {
+            messageId: suggestMessageId,
+            data,
+            fix: (fixer) => fixer.replaceTextRange(
+            // Keep the quotes
+            [pathNode.range[0] + 1, pathNode.range[1] - 1], data.packageName),
+        };
+    }
+    context.report({
+        node: pathNode,
+        messageId,
+        data,
+        suggest: suggestion ? [suggestion] : undefined,
+    });
+}
+function checkImportPath(context, importPath) {
+    const { ignorePatterns } = context.options;
+    const importParts = (0, parseImportIfRelevant_1.parseImportIfRelevant)(importPath, ignorePatterns);
+    if (!importParts) {
+        // Import is relative, top-level, built-in, or ignored
+        return null;
+    }
+    const { packageName, subPath } = importParts;
+    // Find the root of the current file's package and read its package.json
+    const currentPkg = (0, getPackageInfo_1.getPackageInfo)(context.filename, context.options.debug);
+    if (!currentPkg || currentPkg.json.name === packageName) {
+        // - If package.json for the current file's package wasn't found, ignore the import
+        //   (getPackageInfo already logged a debug message about it)
+        // - If the import is a self-reference, ignore it
+        return null;
+    }
+    // Resolve packageName's top-level import so we can find the package.json.
+    // (This resolution must be done in the context of the current package in case eslint is running
+    // in a different directory, e.g. monorepo root, where the package may not be installed or a
+    // different version may be installed.)
+    const resolvedPkgRoot = (0, resolvePackageRoot_1.resolvePackageRoot)(currentPkg.path, packageName, context.options.debug);
+    if (!resolvedPkgRoot) {
+        // Maybe an optional dep?
+        return null;
+    }
+    // Read packageName's package.json
+    const importPkg = (0, getPackageInfo_1.getPackageInfo)(resolvedPkgRoot, context.options.debug);
+    if (!importPkg) {
+        return null;
+    }
+    if (!importPkg.json.exports) {
+        // Deep imports are always an error if there's no exports map
+        return {
+            messageId: importPkg.isLocal ? 'noExportsLocal' : 'noExports',
+            subPath: subPath,
+            packageName,
+        };
+    }
+    // Check if subPath matches any paths from exports (disregarding conditions)
+    if (!(0, pathSatisfiesAnyExport_1.pathSatisfiesAnyExport)(importPkg.json.exports, subPath)) {
+        return {
+            messageId: importPkg.isLocal ? 'notExportedLocal' : 'notExported',
+            subPath: subPath,
+            packageName,
+        };
+    }
+    return null;
+}
+//# sourceMappingURL=no-unsupported-imports.js.map

package/lib/rules/no-unsupported-imports.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-unsupported-imports.js","sourceRoot":"","sources":["../../src/rules/no-unsupported-imports.ts"],"names":[],"mappings":"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","sourcesContent":["import type { TSESLint } from '@typescript-eslint/utils';\nimport { getImportPathLiteralNode, type ImportLikeNode } from '../utils/getImportPathLiteralNode';\nimport { getPackageInfo } from '../utils/getPackageInfo';\nimport { parseImportIfRelevant } from '../utils/parseImportIfRelevant';\nimport { pathSatisfiesAnyExport } from '../utils/pathSatisfiesAnyExport';\nimport { resolvePackageRoot } from '../utils/resolvePackageRoot';\n\n/** Processed rule options */\ntype RuleOptions = {\n  ignorePatterns: RegExp[];\n  debug: boolean;\n};\n\n/** Rule options as specified in the config */\nexport type RawRuleOptions = Omit<Partial<RuleOptions>, 'ignorePatterns'> & {\n  ignorePatterns?: string[];\n};\n\ntype RuleContext = Omit<RawRuleContext, 'options'> & {\n  options: RuleOptions;\n  filename: string;\n};\n\nexport type ErrorMessageIds = 'noExports' | 'noExportsLocal' | 'notExported' | 'notExportedLocal';\nexport type SuggestMessageIds = 'useTopLevel';\nexport type MessageIds = ErrorMessageIds | SuggestMessageIds;\n\nexport type ErrorData = {\n  packageName: string;\n  subPath: string;\n};\n\ntype ErrorResult = ErrorData & {\n  messageId: ErrorMessageIds;\n};\n\ntype RawRuleContext = TSESLint.RuleContext<MessageIds, RawRuleOptions[]>;\n\nconst defaultOptions: RawRuleOptions = {\n  ignorePatterns: [],\n  debug: false,\n};\n\nconst preferTopLevel = 'prefer importing directly from \"{{packageName}}\" if possible';\nconst noExports = '\"{{packageName}}\" doesn\\'t have an exports map, so deep imports aren\\'t allowed; ' + preferTopLevel;\nconst notExported =\n  'Path \"{{subPath}}\" is not exported by \"{{packageName}}\", according to its exports map; ' + preferTopLevel;\nconst localMessage =\n  '(Consider updating \"{{packageName}}\" to export additional identifiers if needed, ' +\n  'or if deep imports are strictly necessary, add an exports map.)';\n\nconst messages: Record<MessageIds, string> = {\n  noExports,\n  noExportsLocal: `${noExports}. ${localMessage}`,\n  notExported,\n  notExportedLocal: `${notExported}. ${localMessage}`,\n  useTopLevel: 'Import directly from \"{{packageName}}\", if possible',\n};\n\nconst suggestMessageId: SuggestMessageIds = 'useTopLevel';\n\nexport const rule: TSESLint.RuleModule<MessageIds, RawRuleOptions[]> = {\n  defaultOptions: [defaultOptions],\n  meta: {\n    type: 'problem',\n    docs: {\n      description: 'ban importing from non-exported paths',\n      recommended: 'error',\n    },\n    hasSuggestions: true,\n    messages,\n    schema: [\n      {\n        type: 'object',\n        properties: {\n          ignorePatterns: {\n            type: 'array',\n            description: 'Ignore imports matching these regular expression patterns.',\n            items: { type: 'string' },\n          },\n          debug: { type: 'boolean' },\n        },\n        additionalProperties: false,\n      },\n    ],\n  },\n  create: (context) => {\n    const options = context.options?.[0] || {};\n    const ruleContext: RuleContext = {\n      ...context,\n      options: {\n        debug: false,\n        ...options,\n        ignorePatterns: (options.ignorePatterns || []).map((str) => new RegExp(str)),\n      },\n      filename: context.getFilename(),\n    };\n\n    return {\n      // import foo from 'foo'\n      // import * as foo from 'foo'\n      // import { foo } from 'foo'\n      // import { foo as bar } from 'foo'\n      // import 'foo'\n      ImportDeclaration: (node) => checkImportOrExport(ruleContext, node),\n      // await import('foo')\n      ImportExpression: (node) => checkImportOrExport(ruleContext, node),\n      // import foo = require('foo')\n      TSImportEqualsDeclaration: (node) => checkImportOrExport(ruleContext, node),\n      // export { foo } from 'foo'\n      // export { foo as bar } from 'foo'\n      ExportNamedDeclaration: (node) => checkImportOrExport(ruleContext, node),\n      // export * from 'foo'\n      // export * as foo from 'foo'\n      ExportAllDeclaration: (node) => checkImportOrExport(ruleContext, node),\n      // require('foo')\n      // require.resolve('foo')\n      CallExpression: (node) => checkImportOrExport(ruleContext, node),\n    };\n  },\n};\n\nfunction checkImportOrExport(context: RuleContext, node: ImportLikeNode) {\n  const pathNode = getImportPathLiteralNode(node);\n  if (!pathNode) {\n    return;\n  }\n\n  const errorData = checkImportPath(context, pathNode.value);\n  if (!errorData) {\n    return; // Import is fine\n  }\n\n  // At this point, the import is probably invalid, so report it.\n  // (Might still be a false positive if it's a local package that hasn't been built yet.)\n  const { messageId, ...data } = errorData;\n\n  // For named imports/exports or import *, suggest importing from the package root.\n  // This is just a suggestion, so it doesn't have to be correct, but we also want to avoid\n  // suggesting when it's likely to be misleading or might cause issues; for example:\n  // - Default imports may refer to an actual default export or the entire module\n  // - Side effect imports are likely specific to a particular file\n  // - Async import()\n  // - export * from an entire package might export a lot more things\n  // - require() could be used in many ways (would have to look at more context)\n  // - require.resolve() is typically used to find the path to a specific file\n  let suggestion: TSESLint.ReportSuggestionArray<SuggestMessageIds>[number] | undefined;\n  if (\n    // import { foo } from 'foo/bar'\n    (node.type === 'ImportDeclaration' && node.specifiers[0]?.type === 'ImportSpecifier') ||\n    // import * as foo from 'foo/bar'\n    (node.type === 'ImportDeclaration' && node.specifiers[0]?.type === 'ImportNamespaceSpecifier') ||\n    // import foo = require('foo/bar')\n    node.type === 'TSImportEqualsDeclaration' ||\n    // export { foo } from 'foo/bar'\n    node.type === 'ExportNamedDeclaration'\n  ) {\n    suggestion = {\n      messageId: suggestMessageId,\n      data,\n      fix: (fixer) =>\n        fixer.replaceTextRange(\n          // Keep the quotes\n          [pathNode.range[0] + 1, pathNode.range[1] - 1],\n          data.packageName,\n        ),\n    };\n  }\n\n  context.report({\n    node: pathNode,\n    messageId,\n    data,\n    suggest: suggestion ? [suggestion] : undefined,\n  });\n}\n\nfunction checkImportPath(context: RuleContext, importPath: string): ErrorResult | null {\n  const { ignorePatterns } = context.options;\n\n  const importParts = parseImportIfRelevant(importPath, ignorePatterns);\n  if (!importParts) {\n    // Import is relative, top-level, built-in, or ignored\n    return null;\n  }\n  const { packageName, subPath } = importParts;\n\n  // Find the root of the current file's package and read its package.json\n  const currentPkg = getPackageInfo(context.filename, context.options.debug);\n  if (!currentPkg || currentPkg.json.name === packageName) {\n    // - If package.json for the current file's package wasn't found, ignore the import\n    //   (getPackageInfo already logged a debug message about it)\n    // - If the import is a self-reference, ignore it\n    return null;\n  }\n\n  // Resolve packageName's top-level import so we can find the package.json.\n  // (This resolution must be done in the context of the current package in case eslint is running\n  // in a different directory, e.g. monorepo root, where the package may not be installed or a\n  // different version may be installed.)\n  const resolvedPkgRoot = resolvePackageRoot(currentPkg.path, packageName, context.options.debug);\n  if (!resolvedPkgRoot) {\n    // Maybe an optional dep?\n    return null;\n  }\n\n  // Read packageName's package.json\n  const importPkg = getPackageInfo(resolvedPkgRoot, context.options.debug);\n  if (!importPkg) {\n    return null;\n  }\n\n  if (!importPkg.json.exports) {\n    // Deep imports are always an error if there's no exports map\n    return {\n      messageId: importPkg.isLocal ? 'noExportsLocal' : 'noExports',\n      subPath: subPath,\n      packageName,\n    };\n  }\n\n  // Check if subPath matches any paths from exports (disregarding conditions)\n  if (!pathSatisfiesAnyExport(importPkg.json.exports, subPath)) {\n    return {\n      messageId: importPkg.isLocal ? 'notExportedLocal' : 'notExported',\n      subPath: subPath,\n      packageName,\n    };\n  }\n  return null;\n}\n"]}

package/lib/utils/PackageJson.d.ts

@@ -0,0 +1,43 @@
+type PathLiteral = '.' | `./${string}`;
+/**
+ * The module path that is resolved when this specifier is imported.
+ * Set to `null` to disallow importing this module.
+ */
+type PackageExportsEntryPath = PathLiteral | null;
+type PackageExportsEntry = PackageExportsEntryPath | PackageExportsConditionsObject;
+/**
+ * Used to allow fallbacks in case this environment doesn't support the preceding entries.
+ * Fallbacks are not supported by all implementations.
+ */
+type PackageExportsFallback = PackageExportsEntry[];
+type PackageExportsEntryOrFallback = PackageExportsEntry | PackageExportsFallback;
+/** Used to specify conditional exports */
+type PackageExportsConditionsObject = {
+    [condition: string]: PackageExportsEntryOrFallback;
+};
+/**
+ * Each key is the module path that is resolved when the module specifier starts with "name/".
+ * Special case: `"."` defines the primary entry point (shadows the `main` field).
+ * The key `"./*"` allows external modules to import any subpath (not recommended).
+ */
+type PackageExportsPathsObject = {
+    [path in PathLiteral]?: PackageExportsEntryOrFallback;
+};
+/**
+ * The `exports` field allows defining the entry points of a package.
+ * - If a single string: load this module when the package name is imported
+ *   (shadows the `main` field)
+ * - If an array: load the first one that exists (fallbacks are not supported by all implementations)
+ * - If an object where *all* keys start with `.`: see `PackageExportsPathsObject`
+ * - If an object where *no* keys start with `.`: see `PackageExportsConditionsObject`
+ * - Objects mixing paths and conditions are not valid
+ */
+export type PackageExports = PackageExportsEntryPath | PackageExportsPathsObject | PackageExportsConditionsObject | PackageExportsFallback;
+/** Relevant package.json contents for checking the exports map */
+export type PackageJson = {
+    name: string;
+    exports?: PackageExports;
+    [key: string]: unknown;
+};
+export {};
+//# sourceMappingURL=PackageJson.d.ts.map

package/lib/utils/PackageJson.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PackageJson.d.ts","sourceRoot":"","sources":["../../src/utils/PackageJson.ts"],"names":[],"mappings":"AAEA,KAAK,WAAW,GAAG,GAAG,GAAG,KAAK,MAAM,EAAE,CAAC;AAEvC;;;GAGG;AACH,KAAK,uBAAuB,GAAG,WAAW,GAAG,IAAI,CAAC;AAElD,KAAK,mBAAmB,GAAG,uBAAuB,GAAG,8BAA8B,CAAC;AAEpF;;;GAGG;AACH,KAAK,sBAAsB,GAAG,mBAAmB,EAAE,CAAC;AAEpD,KAAK,6BAA6B,GAAG,mBAAmB,GAAG,sBAAsB,CAAC;AAElF,0CAA0C;AAC1C,KAAK,8BAA8B,GAAG;IACpC,CAAC,SAAS,EAAE,MAAM,GAAG,6BAA6B,CAAC;CACpD,CAAC;AAEF;;;;GAIG;AACH,KAAK,yBAAyB,GAAG;KAC9B,IAAI,IAAI,WAAW,CAAC,CAAC,EAAE,6BAA6B;CACtD,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,MAAM,cAAc,GACtB,uBAAuB,GACvB,yBAAyB,GACzB,8BAA8B,GAC9B,sBAAsB,CAAC;AAG3B,kEAAkE;AAClE,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,cAAc,CAAC;IACzB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB,CAAC"}

package/lib/utils/PackageJson.js

@@ -0,0 +1,4 @@
+"use strict";
+// These types are more precisely based on the schema and should replace the ones in bundler-types in another PR
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=PackageJson.js.map

package/lib/utils/PackageJson.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PackageJson.js","sourceRoot":"","sources":["../../src/utils/PackageJson.ts"],"names":[],"mappings":";AAAA,gHAAgH","sourcesContent":["// These types are more precisely based on the schema and should replace the ones in bundler-types in another PR\n\ntype PathLiteral = '.' | `./${string}`;\n\n/**\n * The module path that is resolved when this specifier is imported.\n * Set to `null` to disallow importing this module.\n */\ntype PackageExportsEntryPath = PathLiteral | null;\n\ntype PackageExportsEntry = PackageExportsEntryPath | PackageExportsConditionsObject;\n\n/**\n * Used to allow fallbacks in case this environment doesn't support the preceding entries.\n * Fallbacks are not supported by all implementations.\n */\ntype PackageExportsFallback = PackageExportsEntry[];\n\ntype PackageExportsEntryOrFallback = PackageExportsEntry | PackageExportsFallback;\n\n/** Used to specify conditional exports */\ntype PackageExportsConditionsObject = {\n  [condition: string]: PackageExportsEntryOrFallback;\n};\n\n/**\n * Each key is the module path that is resolved when the module specifier starts with \"name/\".\n * Special case: `\".\"` defines the primary entry point (shadows the `main` field).\n * The key `\"./*\"` allows external modules to import any subpath (not recommended).\n */\ntype PackageExportsPathsObject = {\n  [path in PathLiteral]?: PackageExportsEntryOrFallback;\n};\n\n/**\n * The `exports` field allows defining the entry points of a package.\n * - If a single string: load this module when the package name is imported\n *   (shadows the `main` field)\n * - If an array: load the first one that exists (fallbacks are not supported by all implementations)\n * - If an object where *all* keys start with `.`: see `PackageExportsPathsObject`\n * - If an object where *no* keys start with `.`: see `PackageExportsConditionsObject`\n * - Objects mixing paths and conditions are not valid\n */\nexport type PackageExports =\n  | PackageExportsEntryPath\n  | PackageExportsPathsObject\n  | PackageExportsConditionsObject\n  | PackageExportsFallback;\n\n// this is a basic type which should not be copied elsewhere\n/** Relevant package.json contents for checking the exports map */\nexport type PackageJson = {\n  name: string;\n  exports?: PackageExports;\n  [key: string]: unknown;\n};\n"]}

package/lib/utils/getImportPathLiteralNode.d.ts

@@ -0,0 +1,8 @@
+import type { TSESTree } from '@typescript-eslint/utils';
+export type ImportLikeNode = TSESTree.CallExpression | TSESTree.ExportAllDeclaration | TSESTree.ExportNamedDeclaration | TSESTree.ImportDeclaration | TSESTree.ImportExpression | TSESTree.TSImportEqualsDeclaration;
+/**
+ * Verifies that the given node contains a string literal import path, and if so, returns the path node.
+ * (For `CallExpression` nodes, also verifies that the callee is `require` or `require.resolve`.)
+ */
+export declare function getImportPathLiteralNode(node: ImportLikeNode): TSESTree.StringLiteral | null;
+//# sourceMappingURL=getImportPathLiteralNode.d.ts.map

package/lib/utils/getImportPathLiteralNode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getImportPathLiteralNode.d.ts","sourceRoot":"","sources":["../../src/utils/getImportPathLiteralNode.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEzD,MAAM,MAAM,cAAc,GACtB,QAAQ,CAAC,cAAc,GACvB,QAAQ,CAAC,oBAAoB,GAC7B,QAAQ,CAAC,sBAAsB,GAC/B,QAAQ,CAAC,iBAAiB,GAC1B,QAAQ,CAAC,gBAAgB,GACzB,QAAQ,CAAC,yBAAyB,CAAC;AAEvC;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,cAAc,GAAG,QAAQ,CAAC,aAAa,GAAG,IAAI,CAwB5F"}

package/lib/utils/getImportPathLiteralNode.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getImportPathLiteralNode = void 0;
+/**
+ * Verifies that the given node contains a string literal import path, and if so, returns the path node.
+ * (For `CallExpression` nodes, also verifies that the callee is `require` or `require.resolve`.)
+ */
+function getImportPathLiteralNode(node) {
+    let pathNode = null;
+    if (node.type === 'CallExpression') {
+        const isRequire = node.callee.type === 'Identifier' && node.callee.name === 'require';
+        const isRequireResolve = node.callee.type === 'MemberExpression' &&
+            node.callee.object.type === 'Identifier' &&
+            node.callee.object.name === 'require' &&
+            node.callee.property.type === 'Identifier' &&
+            node.callee.property.name === 'resolve';
+        if ((isRequire || isRequireResolve) && node.arguments.length === 1) {
+            pathNode = node.arguments[0];
+        }
+    }
+    else if (node.type === 'TSImportEqualsDeclaration') {
+        if (node.moduleReference.type === 'TSExternalModuleReference') {
+            pathNode = node.moduleReference.expression;
+        }
+    }
+    else {
+        pathNode = node.source;
+    }
+    return pathNode && pathNode.type === 'Literal' && typeof pathNode.value === 'string' ? pathNode : null;
+}
+exports.getImportPathLiteralNode = getImportPathLiteralNode;
+//# sourceMappingURL=getImportPathLiteralNode.js.map

package/lib/utils/getImportPathLiteralNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getImportPathLiteralNode.js","sourceRoot":"","sources":["../../src/utils/getImportPathLiteralNode.ts"],"names":[],"mappings":";;;AAUA;;;GAGG;AACH,SAAgB,wBAAwB,CAAC,IAAoB;IAC3D,IAAI,QAAQ,GAAyB,IAAI,CAAC;IAE1C,IAAI,IAAI,CAAC,IAAI,KAAK,gBAAgB,EAAE;QAClC,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,YAAY,IAAI,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,SAAS,CAAC;QACtF,MAAM,gBAAgB,GACpB,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,kBAAkB;YACvC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,KAAK,YAAY;YACxC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,IAAI,KAAK,SAAS;YACrC,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,KAAK,YAAY;YAC1C,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,KAAK,SAAS,CAAC;QAE1C,IAAI,CAAC,SAAS,IAAI,gBAAgB,CAAC,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE;YAClE,QAAQ,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;SAC9B;KACF;SAAM,IAAI,IAAI,CAAC,IAAI,KAAK,2BAA2B,EAAE;QACpD,IAAI,IAAI,CAAC,eAAe,CAAC,IAAI,KAAK,2BAA2B,EAAE;YAC7D,QAAQ,GAAG,IAAI,CAAC,eAAe,CAAC,UAAU,CAAC;SAC5C;KACF;SAAM;QACL,QAAQ,GAAG,IAAI,CAAC,MAAM,CAAC;KACxB;IAED,OAAO,QAAQ,IAAI,QAAQ,CAAC,IAAI,KAAK,SAAS,IAAI,OAAO,QAAQ,CAAC,KAAK,KAAK,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC;AACzG,CAAC;AAxBD,4DAwBC","sourcesContent":["import type { TSESTree } from '@typescript-eslint/utils';\n\nexport type ImportLikeNode =\n  | TSESTree.CallExpression\n  | TSESTree.ExportAllDeclaration\n  | TSESTree.ExportNamedDeclaration\n  | TSESTree.ImportDeclaration\n  | TSESTree.ImportExpression\n  | TSESTree.TSImportEqualsDeclaration;\n\n/**\n * Verifies that the given node contains a string literal import path, and if so, returns the path node.\n * (For `CallExpression` nodes, also verifies that the callee is `require` or `require.resolve`.)\n */\nexport function getImportPathLiteralNode(node: ImportLikeNode): TSESTree.StringLiteral | null {\n  let pathNode: TSESTree.Node | null = null;\n\n  if (node.type === 'CallExpression') {\n    const isRequire = node.callee.type === 'Identifier' && node.callee.name === 'require';\n    const isRequireResolve =\n      node.callee.type === 'MemberExpression' &&\n      node.callee.object.type === 'Identifier' &&\n      node.callee.object.name === 'require' &&\n      node.callee.property.type === 'Identifier' &&\n      node.callee.property.name === 'resolve';\n\n    if ((isRequire || isRequireResolve) && node.arguments.length === 1) {\n      pathNode = node.arguments[0];\n    }\n  } else if (node.type === 'TSImportEqualsDeclaration') {\n    if (node.moduleReference.type === 'TSExternalModuleReference') {\n      pathNode = node.moduleReference.expression;\n    }\n  } else {\n    pathNode = node.source;\n  }\n\n  return pathNode && pathNode.type === 'Literal' && typeof pathNode.value === 'string' ? pathNode : null;\n}\n"]}

package/lib/utils/getPackageInfo.d.ts

@@ -0,0 +1,16 @@
+import type { PackageJson } from './PackageJson';
+export type PackageInfo = {
+    /** Path to the package root directory */
+    path: string;
+    /** Whether this is a package locally developed in the same monorepo */
+    isLocal: boolean;
+    /** package.json contents */
+    json: PackageJson;
+};
+/**
+ * Find the package root directory relative to the given file (based on the presence of a
+ * package.json file) and read the package.json.
+ * @param startPath Search up starting from this file or directory
+ */
+export declare function getPackageInfo(startPath: string, debug: boolean): PackageInfo | null;
+//# sourceMappingURL=getPackageInfo.d.ts.map

package/lib/utils/getPackageInfo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getPackageInfo.d.ts","sourceRoot":"","sources":["../../src/utils/getPackageInfo.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD,MAAM,MAAM,WAAW,GAAG;IACxB,yCAAyC;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,uEAAuE;IACvE,OAAO,EAAE,OAAO,CAAC;IACjB,4BAA4B;IAC5B,IAAI,EAAE,WAAW,CAAC;CACnB,CAAC;AAGF;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,WAAW,GAAG,IAAI,CA8CpF"}

package/lib/utils/getPackageInfo.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPackageInfo = void 0;
+const fs = require("fs");
+const path = require("path");
+const packageInfoCache = new Map();
+/**
+ * Find the package root directory relative to the given file (based on the presence of a
+ * package.json file) and read the package.json.
+ * @param startPath Search up starting from this file or directory
+ */
+function getPackageInfo(startPath, debug) {
+    // Use the realpath in case this is a linked package in a monorepo
+    startPath = fs.realpathSync(startPath);
+    const root = path.parse(startPath).root;
+    const startDir = fs.statSync(startPath).isDirectory() ? startPath : path.dirname(startPath);
+    let dir = startDir;
+    let packageJsonPath = '';
+    let found = false;
+    while (dir !== root && !found) {
+        const cachedInfo = packageInfoCache.get(dir);
+        if (cachedInfo !== undefined) {
+            packageInfoCache.set(startDir, cachedInfo);
+            return cachedInfo;
+        }
+        packageJsonPath = path.join(dir, 'package.json');
+        if (fs.existsSync(packageJsonPath)) {
+            found = true;
+        }
+        else {
+            dir = path.dirname(dir);
+        }
+    }
+    if (!found) {
+        debug && console.error(`no package.json found searching up from ${startPath}`);
+        packageInfoCache.set(startDir, null);
+        return null;
+    }
+    let packageInfo = null;
+    try {
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        packageInfo = {
+            path: dir,
+            // TODO may not work with yarn 3?
+            isLocal: !/[\\/]node_modules[\\/]/.test(dir),
+            json: packageJson,
+        };
+    }
+    catch (err) {
+        debug && console.error(`error reading or parsing ${packageJsonPath}:`, err);
+    }
+    packageInfoCache.set(dir, packageInfo);
+    packageInfoCache.set(startDir, packageInfo);
+    return packageInfo;
+}
+exports.getPackageInfo = getPackageInfo;
+//# sourceMappingURL=getPackageInfo.js.map

package/lib/utils/getPackageInfo.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getPackageInfo.js","sourceRoot":"","sources":["../../src/utils/getPackageInfo.ts"],"names":[],"mappings":";;;AAAA,yBAAyB;AACzB,6BAA6B;AAY7B,MAAM,gBAAgB,GAAG,IAAI,GAAG,EAA8B,CAAC;AAC/D;;;;GAIG;AACH,SAAgB,cAAc,CAAC,SAAiB,EAAE,KAAc;IAC9D,kEAAkE;IAClE,SAAS,GAAG,EAAE,CAAC,YAAY,CAAC,SAAS,CAAC,CAAC;IACvC,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC;IAExC,MAAM,QAAQ,GAAG,EAAE,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;IAE5F,IAAI,GAAG,GAAG,QAAQ,CAAC;IACnB,IAAI,eAAe,GAAG,EAAE,CAAC;IACzB,IAAI,KAAK,GAAG,KAAK,CAAC;IAClB,OAAO,GAAG,KAAK,IAAI,IAAI,CAAC,KAAK,EAAE;QAC7B,MAAM,UAAU,GAAG,gBAAgB,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAC7C,IAAI,UAAU,KAAK,SAAS,EAAE;YAC5B,gBAAgB,CAAC,GAAG,CAAC,QAAQ,EAAE,UAAU,CAAC,CAAC;YAC3C,OAAO,UAAU,CAAC;SACnB;QAED,eAAe,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,cAAc,CAAC,CAAC;QACjD,IAAI,EAAE,CAAC,UAAU,CAAC,eAAe,CAAC,EAAE;YAClC,KAAK,GAAG,IAAI,CAAC;SACd;aAAM;YACL,GAAG,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;SACzB;KACF;IAED,IAAI,CAAC,KAAK,EAAE;QACV,KAAK,IAAI,OAAO,CAAC,KAAK,CAAC,2CAA2C,SAAS,EAAE,CAAC,CAAC;QAC/E,gBAAgB,CAAC,GAAG,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;QACrC,OAAO,IAAI,CAAC;KACb;IAED,IAAI,WAAW,GAAuB,IAAI,CAAC;IAC3C,IAAI;QACF,MAAM,WAAW,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,YAAY,CAAC,eAAe,EAAE,MAAM,CAAC,CAAgB,CAAC;QACxF,WAAW,GAAG;YACZ,IAAI,EAAE,GAAG;YACT,iCAAiC;YACjC,OAAO,EAAE,CAAC,wBAAwB,CAAC,IAAI,CAAC,GAAG,CAAC;YAC5C,IAAI,EAAE,WAAW;SAClB,CAAC;KACH;IAAC,OAAO,GAAG,EAAE;QACZ,KAAK,IAAI,OAAO,CAAC,KAAK,CAAC,4BAA4B,eAAe,GAAG,EAAE,GAAG,CAAC,CAAC;KAC7E;IACD,gBAAgB,CAAC,GAAG,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC;IACvC,gBAAgB,CAAC,GAAG,CAAC,QAAQ,EAAE,WAAW,CAAC,CAAC;IAC5C,OAAO,WAAW,CAAC;AACrB,CAAC;AA9CD,wCA8CC","sourcesContent":["import * as fs from 'fs';\nimport * as path from 'path';\nimport type { PackageJson } from './PackageJson';\n\nexport type PackageInfo = {\n  /** Path to the package root directory */\n  path: string;\n  /** Whether this is a package locally developed in the same monorepo */\n  isLocal: boolean;\n  /** package.json contents */\n  json: PackageJson;\n};\n\nconst packageInfoCache = new Map<string, PackageInfo | null>();\n/**\n * Find the package root directory relative to the given file (based on the presence of a\n * package.json file) and read the package.json.\n * @param startPath Search up starting from this file or directory\n */\nexport function getPackageInfo(startPath: string, debug: boolean): PackageInfo | null {\n  // Use the realpath in case this is a linked package in a monorepo\n  startPath = fs.realpathSync(startPath);\n  const root = path.parse(startPath).root;\n\n  const startDir = fs.statSync(startPath).isDirectory() ? startPath : path.dirname(startPath);\n\n  let dir = startDir;\n  let packageJsonPath = '';\n  let found = false;\n  while (dir !== root && !found) {\n    const cachedInfo = packageInfoCache.get(dir);\n    if (cachedInfo !== undefined) {\n      packageInfoCache.set(startDir, cachedInfo);\n      return cachedInfo;\n    }\n\n    packageJsonPath = path.join(dir, 'package.json');\n    if (fs.existsSync(packageJsonPath)) {\n      found = true;\n    } else {\n      dir = path.dirname(dir);\n    }\n  }\n\n  if (!found) {\n    debug && console.error(`no package.json found searching up from ${startPath}`);\n    packageInfoCache.set(startDir, null);\n    return null;\n  }\n\n  let packageInfo: PackageInfo | null = null;\n  try {\n    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8')) as PackageJson;\n    packageInfo = {\n      path: dir,\n      // TODO may not work with yarn 3?\n      isLocal: !/[\\\\/]node_modules[\\\\/]/.test(dir),\n      json: packageJson,\n    };\n  } catch (err) {\n    debug && console.error(`error reading or parsing ${packageJsonPath}:`, err);\n  }\n  packageInfoCache.set(dir, packageInfo);\n  packageInfoCache.set(startDir, packageInfo);\n  return packageInfo;\n}\n"]}

package/lib/utils/parseImportIfRelevant.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Verify that the import is relevant for the very specific purposes of the `no-unsupported-imports` rule,
+ * and if so, find the package name and sub-path.
+ */
+export declare function parseImportIfRelevant(importPath: string, ignorePatterns: RegExp[]): {
+    packageName: string;
+    subPath: string;
+} | null;
+/**
+ * Parse a module ID which is assumed to point to an actual file in a package (no loader prefixes,
+ * relative paths, node builtins, or data URIs).
+ * @returns Package name and sub-path (if any). Sub-path does *not* include a leading `./`,
+ * e.g. `@foo/bar/baz` returns `{ packageName: '@foo/bar', subPath: 'baz' }`.
+ */
+export declare function parseModuleId(moduleId: string): {
+    packageName: string;
+    subPath: string;
+};
+//# sourceMappingURL=parseImportIfRelevant.d.ts.map

package/lib/utils/parseImportIfRelevant.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseImportIfRelevant.d.ts","sourceRoot":"","sources":["../../src/utils/parseImportIfRelevant.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,wBAAgB,qBAAqB,CACnC,UAAU,EAAE,MAAM,EAClB,cAAc,EAAE,MAAM,EAAE,GACvB;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAiBjD;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM;;;EAO7C"}

package/lib/utils/parseImportIfRelevant.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseModuleId = exports.parseImportIfRelevant = void 0;
+const module_1 = require("module");
+/**
+ * Verify that the import is relevant for the very specific purposes of the `no-unsupported-imports` rule,
+ * and if so, find the package name and sub-path.
+ */
+function parseImportIfRelevant(importPath, ignorePatterns) {
+    // Remove any webpack loader prefix
+    // (* is greedy, so it will work even if multiple loaders are specified)
+    const normalizedImport = importPath.replace(/.*!/, '');
+    // Ignore relative imports, internal imports, builtins, and data URLs
+    // (builtinModules includes valid sub-paths like "fs/promises")
+    if (!/^([.#]|node:|data:)/.test(normalizedImport) && !module_1.builtinModules.includes(normalizedImport)) {
+        // Find the package name and sub-path (if any)
+        const { packageName, subPath } = parseModuleId(normalizedImport);
+        // Ignore top-level imports, or anything from an ignored package
+        if (subPath && !ignorePatterns.some((r) => r.test(normalizedImport))) {
+            return { packageName, subPath };
+        }
+    }
+    return null;
+}
+exports.parseImportIfRelevant = parseImportIfRelevant;
+/**
+ * Parse a module ID which is assumed to point to an actual file in a package (no loader prefixes,
+ * relative paths, node builtins, or data URIs).
+ * @returns Package name and sub-path (if any). Sub-path does *not* include a leading `./`,
+ * e.g. `@foo/bar/baz` returns `{ packageName: '@foo/bar', subPath: 'baz' }`.
+ */
+function parseModuleId(moduleId) {
+    const nameParts = moduleId.split('/');
+    const hasScope = nameParts.length >= 2 && nameParts[0][0] === '@';
+    const packageName = hasScope ? `${nameParts[0]}/${nameParts[1]}` : nameParts[0];
+    const subPath = nameParts.slice(hasScope ? 2 : 1).join('/');
+    return { packageName, subPath };
+}
+exports.parseModuleId = parseModuleId;
+//# sourceMappingURL=parseImportIfRelevant.js.map

package/lib/utils/parseImportIfRelevant.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parseImportIfRelevant.js","sourceRoot":"","sources":["../../src/utils/parseImportIfRelevant.ts"],"names":[],"mappings":";;;AAAA,mCAAwC;AAExC;;;GAGG;AACH,SAAgB,qBAAqB,CACnC,UAAkB,EAClB,cAAwB;IAExB,mCAAmC;IACnC,wEAAwE;IACxE,MAAM,gBAAgB,GAAG,UAAU,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IAEvD,qEAAqE;IACrE,+DAA+D;IAC/D,IAAI,CAAC,qBAAqB,CAAC,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,uBAAc,CAAC,QAAQ,CAAC,gBAAgB,CAAC,EAAE;QAC/F,8CAA8C;QAC9C,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,GAAG,aAAa,CAAC,gBAAgB,CAAC,CAAC;QAEjE,gEAAgE;QAChE,IAAI,OAAO,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,EAAE;YACpE,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,CAAC;SACjC;KACF;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AApBD,sDAoBC;AAED;;;;;GAKG;AACH,SAAgB,aAAa,CAAC,QAAgB;IAC5C,MAAM,SAAS,GAAG,QAAQ,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACtC,MAAM,QAAQ,GAAG,SAAS,CAAC,MAAM,IAAI,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC;IAElE,MAAM,WAAW,GAAG,QAAQ,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;IAChF,MAAM,OAAO,GAAG,SAAS,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC5D,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,CAAC;AAClC,CAAC;AAPD,sCAOC","sourcesContent":["import { builtinModules } from 'module';\n\n/**\n * Verify that the import is relevant for the very specific purposes of the `no-unsupported-imports` rule,\n * and if so, find the package name and sub-path.\n */\nexport function parseImportIfRelevant(\n  importPath: string,\n  ignorePatterns: RegExp[],\n): { packageName: string; subPath: string } | null {\n  // Remove any webpack loader prefix\n  // (* is greedy, so it will work even if multiple loaders are specified)\n  const normalizedImport = importPath.replace(/.*!/, '');\n\n  // Ignore relative imports, internal imports, builtins, and data URLs\n  // (builtinModules includes valid sub-paths like \"fs/promises\")\n  if (!/^([.#]|node:|data:)/.test(normalizedImport) && !builtinModules.includes(normalizedImport)) {\n    // Find the package name and sub-path (if any)\n    const { packageName, subPath } = parseModuleId(normalizedImport);\n\n    // Ignore top-level imports, or anything from an ignored package\n    if (subPath && !ignorePatterns.some((r) => r.test(normalizedImport))) {\n      return { packageName, subPath };\n    }\n  }\n  return null;\n}\n\n/**\n * Parse a module ID which is assumed to point to an actual file in a package (no loader prefixes,\n * relative paths, node builtins, or data URIs).\n * @returns Package name and sub-path (if any). Sub-path does *not* include a leading `./`,\n * e.g. `@foo/bar/baz` returns `{ packageName: '@foo/bar', subPath: 'baz' }`.\n */\nexport function parseModuleId(moduleId: string) {\n  const nameParts = moduleId.split('/');\n  const hasScope = nameParts.length >= 2 && nameParts[0][0] === '@';\n\n  const packageName = hasScope ? `${nameParts[0]}/${nameParts[1]}` : nameParts[0];\n  const subPath = nameParts.slice(hasScope ? 2 : 1).join('/');\n  return { packageName, subPath };\n}\n"]}

package/lib/utils/pathSatisfiesAnyExport.d.ts

@@ -0,0 +1,8 @@
+import type { PackageExports } from './PackageJson.js';
+/**
+ * Determine whether `importSubPath` might satisfy any sub-path from the exports map,
+ * disregarding conditions and file existence.
+ * @param importSubPath Sub-path such as `lib/foo`
+ */
+export declare function pathSatisfiesAnyExport(exportsMap: PackageExports | undefined, importSubPath: string): boolean;
+//# sourceMappingURL=pathSatisfiesAnyExport.d.ts.map

package/lib/utils/pathSatisfiesAnyExport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pathSatisfiesAnyExport.d.ts","sourceRoot":"","sources":["../../src/utils/pathSatisfiesAnyExport.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEvD;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,cAAc,GAAG,SAAS,EAAE,aAAa,EAAE,MAAM,WA8BnG"}

package/lib/utils/pathSatisfiesAnyExport.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pathSatisfiesAnyExport = void 0;
+/**
+ * Determine whether `importSubPath` might satisfy any sub-path from the exports map,
+ * disregarding conditions and file existence.
+ * @param importSubPath Sub-path such as `lib/foo`
+ */
+function pathSatisfiesAnyExport(exportsMap, importSubPath) {
+    // If the exports map is a string, it's a shorthand for a single export.
+    // If it's an array, the contents are fallbacks for a single export.
+    if (!exportsMap || typeof exportsMap === 'string' || Array.isArray(exportsMap)) {
+        return false;
+    }
+    importSubPath = `./${importSubPath}`;
+    return (
+    // Check for very basic exclusions. (Technically a path could also be excluded by setting
+    // a condition to null, or by setting a later wildcard to override an earlier one.
+    // Handling for this can be added later if needed.)
+    exportsMap[importSubPath] !== null &&
+        Object.keys(exportsMap).some((key) => {
+            // . is the root import, not a sub-path.
+            // Starting character other than . means this is a condition, not a path.
+            if (key === '.' || key[0] !== '.') {
+                return false;
+            }
+            if (key.includes('*')) {
+                return new RegExp(`^${key.replace(/\./g, '\\.').replace(/\*/g, '.*')}$`).test(importSubPath);
+            }
+            if (key.endsWith('/')) {
+                return importSubPath.startsWith(key);
+            }
+            // Check if the path is a literal match for this key
+            return key === importSubPath;
+        }));
+}
+exports.pathSatisfiesAnyExport = pathSatisfiesAnyExport;
+//# sourceMappingURL=pathSatisfiesAnyExport.js.map

package/lib/utils/pathSatisfiesAnyExport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pathSatisfiesAnyExport.js","sourceRoot":"","sources":["../../src/utils/pathSatisfiesAnyExport.ts"],"names":[],"mappings":";;;AAEA;;;;GAIG;AACH,SAAgB,sBAAsB,CAAC,UAAsC,EAAE,aAAqB;IAClG,wEAAwE;IACxE,oEAAoE;IACpE,IAAI,CAAC,UAAU,IAAI,OAAO,UAAU,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE;QAC9E,OAAO,KAAK,CAAC;KACd;IAED,aAAa,GAAG,KAAK,aAAa,EAAE,CAAC;IAErC,OAAO;IACL,yFAAyF;IACzF,kFAAkF;IAClF,mDAAmD;IAClD,UAAsC,CAAC,aAAa,CAAC,KAAK,IAAI;QAC/D,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE;YACnC,wCAAwC;YACxC,yEAAyE;YACzE,IAAI,GAAG,KAAK,GAAG,IAAI,GAAG,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE;gBACjC,OAAO,KAAK,CAAC;aACd;YACD,IAAI,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE;gBACrB,OAAO,IAAI,MAAM,CAAC,IAAI,GAAG,CAAC,OAAO,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;aAC9F;YACD,IAAI,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE;gBACrB,OAAO,aAAa,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;aACtC;YACD,oDAAoD;YACpD,OAAO,GAAG,KAAK,aAAa,CAAC;QAC/B,CAAC,CAAC,CACH,CAAC;AACJ,CAAC;AA9BD,wDA8BC","sourcesContent":["import type { PackageExports } from './PackageJson.js';\n\n/**\n * Determine whether `importSubPath` might satisfy any sub-path from the exports map,\n * disregarding conditions and file existence.\n * @param importSubPath Sub-path such as `lib/foo`\n */\nexport function pathSatisfiesAnyExport(exportsMap: PackageExports | undefined, importSubPath: string) {\n  // If the exports map is a string, it's a shorthand for a single export.\n  // If it's an array, the contents are fallbacks for a single export.\n  if (!exportsMap || typeof exportsMap === 'string' || Array.isArray(exportsMap)) {\n    return false;\n  }\n\n  importSubPath = `./${importSubPath}`;\n\n  return (\n    // Check for very basic exclusions. (Technically a path could also be excluded by setting\n    // a condition to null, or by setting a later wildcard to override an earlier one.\n    // Handling for this can be added later if needed.)\n    (exportsMap as Record<string, unknown>)[importSubPath] !== null &&\n    Object.keys(exportsMap).some((key) => {\n      // . is the root import, not a sub-path.\n      // Starting character other than . means this is a condition, not a path.\n      if (key === '.' || key[0] !== '.') {\n        return false;\n      }\n      if (key.includes('*')) {\n        return new RegExp(`^${key.replace(/\\./g, '\\\\.').replace(/\\*/g, '.*')}$`).test(importSubPath);\n      }\n      if (key.endsWith('/')) {\n        return importSubPath.startsWith(key);\n      }\n      // Check if the path is a literal match for this key\n      return key === importSubPath;\n    })\n  );\n}\n"]}

package/lib/utils/resolvePackageRoot.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Resolve the root directory of `packageName` starting from `fromDir`, with caching.
+ * This uses the basic `resolve` package (which doesn't respect exports maps) to resolve
+ * `${packageName}/package.json`, which should always exist.
+ */
+export declare function resolvePackageRoot(fromDir: string, packageName: string, debug: boolean): string | null;
+//# sourceMappingURL=resolvePackageRoot.d.ts.map

package/lib/utils/resolvePackageRoot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolvePackageRoot.d.ts","sourceRoot":"","sources":["../../src/utils/resolvePackageRoot.ts"],"names":[],"mappings":"AAgBA;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,IAAI,CAyBtG"}

package/lib/utils/resolvePackageRoot.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolvePackageRoot = void 0;
+const path = require("path");
+const _resolve = require("resolve");
+// 'resolve' index.js looks like this:
+//     var async = require('./lib/async');
+//     async.sync = require('./lib/sync');
+//     module.exports = async;
+// This does not play nicely with at least one transpilation or interop step, possibly on specific
+// Node versions: `import * as resolve` *usually* gives the `resolve` function, but sometimes it
+// gives an object with property `default`... This is a workaround for either case.
+// eslint-disable-next-line
+const resolveSync = _resolve.sync || _resolve.default?.sync;
+const getCacheKey = (fromDir, packageName) => `${fromDir}::${packageName}`;
+const resolveCache = new Map();
+/**
+ * Resolve the root directory of `packageName` starting from `fromDir`, with caching.
+ * This uses the basic `resolve` package (which doesn't respect exports maps) to resolve
+ * `${packageName}/package.json`, which should always exist.
+ */
+function resolvePackageRoot(fromDir, packageName, debug) {
+    const cacheKey = getCacheKey(fromDir, packageName);
+    const cached = resolveCache.get(cacheKey);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const resolvePath = `${packageName}/package.json`;
+    let resolved = null;
+    try {
+        resolved = path.dirname(resolveSync(resolvePath, { basedir: fromDir, preserveSymlinks: false }));
+    }
+    catch (err) {
+        if (debug) {
+            // eslint-disable-next-line
+            if (err?.code === 'MODULE_NOT_FOUND') {
+                console.error(`Failed to resolve ${resolvePath} from ${fromDir} (module not found)`);
+            }
+            else {
+                console.error(`Failed to resolve ${resolvePath} from ${fromDir}: ${err.message || err}`);
+            }
+        }
+    }
+    // Cache even if resolution failed so we don't waste time trying again
+    resolveCache.set(cacheKey, resolved);
+    return resolved;
+}
+exports.resolvePackageRoot = resolvePackageRoot;
+//# sourceMappingURL=resolvePackageRoot.js.map

package/lib/utils/resolvePackageRoot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolvePackageRoot.js","sourceRoot":"","sources":["../../src/utils/resolvePackageRoot.ts"],"names":[],"mappings":";;;AAAA,6BAA6B;AAC7B,oCAAoC;AAEpC,sCAAsC;AACtC,0CAA0C;AAC1C,0CAA0C;AAC1C,8BAA8B;AAC9B,kGAAkG;AAClG,gGAAgG;AAChG,mFAAmF;AACnF,2BAA2B;AAC3B,MAAM,WAAW,GAAyB,QAAQ,CAAC,IAAI,IAAK,QAAgB,CAAC,OAAO,EAAE,IAAI,CAAC;AAE3F,MAAM,WAAW,GAAG,CAAC,OAAe,EAAE,WAAmB,EAAE,EAAE,CAAC,GAAG,OAAO,KAAK,WAAW,EAAE,CAAC;AAC3F,MAAM,YAAY,GAAG,IAAI,GAAG,EAAyB,CAAC;AAEtD;;;;GAIG;AACH,SAAgB,kBAAkB,CAAC,OAAe,EAAE,WAAmB,EAAE,KAAc;IACrF,MAAM,QAAQ,GAAG,WAAW,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;IACnD,MAAM,MAAM,GAAG,YAAY,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;IAC1C,IAAI,MAAM,KAAK,SAAS,EAAE;QACxB,OAAO,MAAM,CAAC;KACf;IAED,MAAM,WAAW,GAAG,GAAG,WAAW,eAAe,CAAC;IAClD,IAAI,QAAQ,GAAkB,IAAI,CAAC;IACnC,IAAI;QACF,QAAQ,GAAG,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,WAAW,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,gBAAgB,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;KAClG;IAAC,OAAO,GAAG,EAAE;QACZ,IAAI,KAAK,EAAE;YACT,2BAA2B;YAC3B,IAAK,GAAW,EAAE,IAAI,KAAK,kBAAkB,EAAE;gBAC7C,OAAO,CAAC,KAAK,CAAC,qBAAqB,WAAW,SAAS,OAAO,qBAAqB,CAAC,CAAC;aACtF;iBAAM;gBACL,OAAO,CAAC,KAAK,CAAC,qBAAqB,WAAW,SAAS,OAAO,KAAM,GAAa,CAAC,OAAO,IAAI,GAAG,EAAE,CAAC,CAAC;aACrG;SACF;KACF;IAED,sEAAsE;IACtE,YAAY,CAAC,GAAG,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;IACrC,OAAO,QAAQ,CAAC;AAClB,CAAC;AAzBD,gDAyBC","sourcesContent":["import * as path from 'path';\nimport * as _resolve from 'resolve';\n\n// 'resolve' index.js looks like this:\n//     var async = require('./lib/async');\n//     async.sync = require('./lib/sync');\n//     module.exports = async;\n// This does not play nicely with at least one transpilation or interop step, possibly on specific\n// Node versions: `import * as resolve` *usually* gives the `resolve` function, but sometimes it\n// gives an object with property `default`... This is a workaround for either case.\n// eslint-disable-next-line\nconst resolveSync: typeof _resolve.sync = _resolve.sync || (_resolve as any).default?.sync;\n\nconst getCacheKey = (fromDir: string, packageName: string) => `${fromDir}::${packageName}`;\nconst resolveCache = new Map<string, string | null>();\n\n/**\n * Resolve the root directory of `packageName` starting from `fromDir`, with caching.\n * This uses the basic `resolve` package (which doesn't respect exports maps) to resolve\n * `${packageName}/package.json`, which should always exist.\n */\nexport function resolvePackageRoot(fromDir: string, packageName: string, debug: boolean): string | null {\n  const cacheKey = getCacheKey(fromDir, packageName);\n  const cached = resolveCache.get(cacheKey);\n  if (cached !== undefined) {\n    return cached;\n  }\n\n  const resolvePath = `${packageName}/package.json`;\n  let resolved: string | null = null;\n  try {\n    resolved = path.dirname(resolveSync(resolvePath, { basedir: fromDir, preserveSymlinks: false }));\n  } catch (err) {\n    if (debug) {\n      // eslint-disable-next-line\n      if ((err as any)?.code === 'MODULE_NOT_FOUND') {\n        console.error(`Failed to resolve ${resolvePath} from ${fromDir} (module not found)`);\n      } else {\n        console.error(`Failed to resolve ${resolvePath} from ${fromDir}: ${(err as Error).message || err}`);\n      }\n    }\n  }\n\n  // Cache even if resolution failed so we don't waste time trying again\n  resolveCache.set(cacheKey, resolved);\n  return resolved;\n}\n"]}

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@ms-cloudpack/eslint-plugin",
+  "version": "0.1.1",
+  "description": "A set of ESLint rules for Cloudpack",
+  "license": "MIT",
+  "main": "lib/index.js",
+  "scripts": {
+    "build:watch": "cloudpack-scripts build-watch",
+    "build": "cloudpack-scripts build",
+    "lint:update": "cloudpack-scripts lint-update",
+    "lint": "cloudpack-scripts lint",
+    "test:watch": "cloudpack-scripts test-watch",
+    "test": "cloudpack-scripts test"
+  },
+  "dependencies": {
+    "@typescript-eslint/eslint-plugin": "^5.0.0",
+    "@typescript-eslint/parser": "^5.0.0",
+    "resolve": "^1.22.0"
+  },
+  "peerDependencies": {
+    "eslint": ">=8.0.0"
+  },
+  "devDependencies": {
+    "@ms-cloudpack/eslint-config-base": "*",
+    "@ms-cloudpack/scripts": "*",
+    "@ms-cloudpack/test-utilities": "*",
+    "@types/eslint": "8.21.3",
+    "@types/resolve": "1.20.2",
+    "@typescript-eslint/utils": "5.55.0"
+  },
+  "files": [
+    "lib/**/!(*.test.*)"
+  ]
+}