Files
clean-architecture-frontend…/eslint.config.ts
T
DongHyeonka d1db7e7887 fix(architecture): 금지 fixture를 그 계층의 운영 ESLint 설정으로 검사한다
문제
tests/fixtures/architecture/forbidden/**에는 fixture 전용 ESLint 블록이
붙어 있었다. 모든 계층의 금지 import와 fetch·localStorage·sessionStorage
금지를 합친 것이다. check-architecture.ts는 fixture마다 ESLint 종료 코드가
0이 아니면 거부됐다고 셌다. 그래서 운영 src/presentation/** 블록에서 계층
import 금지와 fetch 금지를 지워도(변이 M2) check:architecture는 "9 forbidden
rejected"로 통과했다. 전역 fetch·localStorage 금지는 이 ESLint 블록 말고 지키는
검사가 없다.

고른 방법
- 새 scripts/lib/architecture-lint-fixtures.ts가 fixture마다 그것이 대표하는
  운영 경로(lintAs, 예: src/presentation/__architecture_fixture__/…)와 거부해야
  하는 규칙(rejectedBy)을 적는다. ESLint API lintText(code, { filePath })로
  그 경로의 운영 설정을 그대로 적용한다. 금지 fixture는 그 규칙이 보고해야
  통과하고, 허용 fixture는 계층 규칙(no-restricted-imports·globals)이 아무것도
  보고하지 않아야 통과한다. 목록에 없는 fixture 파일도 실패로 센다.
- domain fixture는 domain 코드가 실제로 사는 src/features/*/domain 블록으로
  검사한다(최상위 src/domain 폴더는 없다).
- fixture 전용 ESLint 블록을 지운다. check-architecture.ts에서 쓰이지 않게 된
  pnpm 하위 프로세스 실행과 npm_execpath 요구를 지운다.
- 버린 대안: 금지 fixture 삭제. import 방향은 그래프가 지키지만 전역 금지의
  검출이 0이 된다. 종료 코드만 보고 운영 경로로 옮기기. 다른 규칙(화면 문구
  등)이 걸려도 거부로 센다.

위험·한계
- 계층 규칙 이름이 바뀌면 fixture 표의 rejectedBy도 같이 고쳐야 한다(고치지
  않으면 실패로 드러난다).
- 출력 문구가 "3 allowed PASS, 9 forbidden rejected by the production rule for
  their layer"로 바뀐다. 이 문구를 읽는 스크립트는 없다.

검증
- RED: 수정 전 변이 M2(운영 presentation 블록의 계층 import 금지와 fetch 금지
  삭제)에서 check:architecture exit 0, "9 forbidden rejected".
- 수정 뒤 같은 변이에서 check:architecture exit 1, presentation fixture 5개가
  "was accepted"로 실패. 되돌린 뒤 exit 0.
- 새 tests/unit/architecture-lint-fixtures.test.ts 3건(운영 설정 통과,
  overrideConfig로 규칙을 끄면 실패, 목록 밖 fixture 실패) 통과.
  architecture-report 3건 통과. check:types 통과, eslint 통과.

Refs: docs/reviews/2026-11-03-maturity-review/12-guardrails-ci.md 12-04
2026-11-04 21:10:19 +09:00

1010 lines
29 KiB
TypeScript

import babelParser from "@babel/eslint-parser";
import eslint from "@eslint/js";
import reactHooks from "eslint-plugin-react-hooks";
import globals from "globals";
import type { Rule } from "eslint";
const sourceExtensions = "{ts,tsx,mts,cts}";
// 12-09. Editor-time aid only: these patterns show a layer violation while
// typing. The layer rules themselves live in .dependency-cruiser.json and are
// enforced by check:architecture, which resolves every import. Change a rule
// there first; these lists cover a subset and may lag behind it.
const layerPatterns = {
domain: [
"**/application/**",
"**/presentation/**",
"**/adapters/**",
"**/bootstrap/**",
"react",
"react-dom",
"@tanstack/**",
],
application: [
"**/presentation/**",
"**/adapters/**",
"**/bootstrap/**",
"react",
"react-dom",
"@tanstack/**",
],
presentation: [
"**/adapters/**",
"**/bootstrap/**",
"**/application/ports/out/**",
"@tanstack/**",
],
adapters: ["**/presentation/**", "**/bootstrap/**"],
};
// 12-11. Each pattern group carries the reason and the way out; the default
// message only named the pattern.
const layerMessages = {
domain:
"domain stays framework-neutral (.dependency-cruiser.json domain-is-framework-neutral). Move the code to application or pass the value in.",
application:
"application declares ports and never imports UI, adapters or bootstrap (application-does-not-know-concrete-runtime). Add a port under application/ports; bootstrap passes the adapter.",
presentation:
"presentation reaches the runtime through the application API (presentation-does-not-know-adapters). Use the application facade; bootstrap composes adapters.",
adapters:
"an adapter implements an application port and never imports UI or bootstrap (adapters-do-not-know-presentation). Pass what it needs through the port.",
} as const;
// 07-01. Deprecated aliases stay exported for downstream projects until they
// are removed, but nothing in this repository imports them. The ESLint parser
// here has no type information, so this stands in for a no-deprecated rule.
const deprecatedAliasImports = [
{
group: ["**/contracts/boundary-mapper.ts", "**/contracts/boundary-mapper"],
importNames: ["MappingResult"],
message:
"deprecated alias: import BoundaryMappingResult. The contract-side MappingResult lives in external-contract-runtime.ts.",
},
{
group: ["**/contracts/errors.ts", "**/contracts/errors"],
importNames: ["ApiFailure"],
message: "deprecated alias: import AppFailure.",
},
];
function restrictedImports(patterns: readonly string[], message: string) {
return [
"error",
{ patterns: [{ group: [...patterns], message }, ...deprecatedAliasImports] },
];
}
const restrictedBrowserDataProperties = [
"error",
...(["globalThis", "window", "self"] as const).flatMap((object) =>
[
"BroadcastChannel",
"localStorage",
"sessionStorage",
"indexedDB",
"caches",
"navigator",
"File",
"Blob",
"FileSystemFileHandle",
"FileSystemDirectoryHandle",
"showOpenFilePicker",
"showSaveFilePicker",
"URL",
].map((property) => ({
object,
property,
message:
"Browser file/storage APIs are adapter-owned; use the policy port.",
})),
),
{
object: "navigator",
property: "storage",
message: "StorageManager and OPFS access are adapter-owned.",
},
{
object: "URL",
property: "createObjectURL",
message: "Object URL allocation is owned by the preview/download adapter.",
},
{
object: "URL",
property: "revokeObjectURL",
message: "Object URL revocation is owned by the preview/download adapter.",
},
] as const;
const browserCapabilityRoots = new Set([
"globalThis",
"window",
"self",
"navigator",
"URL",
]);
const browserCapabilityProperties = new Set([
"BroadcastChannel",
"localStorage",
"sessionStorage",
"indexedDB",
"caches",
"navigator",
"storage",
"File",
"Blob",
"FileSystemFileHandle",
"FileSystemDirectoryHandle",
"showOpenFilePicker",
"showSaveFilePicker",
"URL",
"createObjectURL",
"revokeObjectURL",
]);
/**
* no-restricted-properties only recognizes the literal object identifier.
* This rule follows local aliases of browser roots so `const host =
* globalThis; host.indexedDB` cannot bypass the owned-adapter boundary.
*/
const noBrowserCapabilityAliasRule: Rule.RuleModule = {
meta: {
type: "problem",
schema: [],
messages: {
owned:
"Browser file/storage capabilities are owned by the approved common adapters.",
},
},
create(context) {
const aliases = new Set<string>();
const unwrap = (input: any): any => {
let node = input;
while (
node &&
[
"ChainExpression",
"TSAsExpression",
"TSNonNullExpression",
"TSTypeAssertion",
].includes(node.type)
) {
node = node.expression;
}
return node;
};
const propertyName = (input: any): string | null => {
const node = unwrap(input);
if (!node) return null;
if (!node.computed && node.property?.type === "Identifier") {
return node.property.name;
}
if (
node.computed &&
node.property?.type === "Literal" &&
typeof node.property.value === "string"
) {
return node.property.value;
}
if (
node.computed &&
node.property?.type === "StringLiteral"
) {
return node.property.value;
}
return null;
};
const isRootAlias = (input: any): boolean => {
const node = unwrap(input);
if (!node) return false;
if (node.type === "Identifier") {
return browserCapabilityRoots.has(node.name) ||
aliases.has(node.name);
}
if (node.type === "MemberExpression") {
return isRootAlias(node.object);
}
if (node.type === "LogicalExpression") {
return isRootAlias(node.left) || isRootAlias(node.right);
}
if (node.type === "ConditionalExpression") {
return (
isRootAlias(node.consequent) ||
isRootAlias(node.alternate)
);
}
if (node.type === "SequenceExpression") {
return node.expressions.some(isRootAlias);
}
return false;
};
const isBareRootAlias = (input: any): boolean => {
const node = unwrap(input);
if (!node) return false;
if (node.type === "Identifier") {
return browserCapabilityRoots.has(node.name) ||
aliases.has(node.name);
}
if (node.type === "LogicalExpression") {
return (
isBareRootAlias(node.left) ||
isBareRootAlias(node.right)
);
}
if (node.type === "ConditionalExpression") {
return (
isBareRootAlias(node.consequent) ||
isBareRootAlias(node.alternate)
);
}
if (node.type === "SequenceExpression") {
return node.expressions.some(isBareRootAlias);
}
return false;
};
const isDirectBrowserRoot = (input: any): boolean => {
const node = unwrap(input);
return (
node?.type === "Identifier" &&
browserCapabilityRoots.has(node.name)
);
};
const safeMethodThisBinding = (
call: any,
argumentIndex: number,
): boolean => {
if (argumentIndex !== 0) return false;
const callee = unwrap(call.callee);
if (
callee?.type !== "MemberExpression" ||
propertyName(callee) !== "bind"
) {
return false;
}
const target = unwrap(callee.object);
const targetName =
target?.type === "MemberExpression"
? propertyName(target)
: null;
return (
targetName !== null &&
!browserCapabilityProperties.has(targetName) &&
isRootAlias(target.object)
);
};
const rememberPattern = (patternInput: any, source: any): void => {
const pattern = unwrap(patternInput);
if (!pattern || !isRootAlias(source)) return;
if (pattern.type === "Identifier") {
aliases.add(pattern.name);
return;
}
if (pattern.type !== "ObjectPattern") return;
for (const property of pattern.properties ?? []) {
if (property.type !== "Property") continue;
const name =
property.computed
? property.key?.value
: property.key?.name ?? property.key?.value;
if (
typeof name === "string" &&
browserCapabilityProperties.has(name)
) {
context.report({ node: property, messageId: "owned" });
}
}
};
return {
VariableDeclarator(node: any) {
rememberPattern(node.id, node.init);
},
AssignmentExpression(node: any) {
rememberPattern(node.left, node.right);
const target = unwrap(node.left);
if (
target?.type !== "Identifier" &&
target?.type !== "ObjectPattern" &&
isBareRootAlias(node.right)
) {
context.report({ node: node.right, messageId: "owned" });
}
},
AssignmentPattern(node: any) {
rememberPattern(node.left, node.right);
},
PropertyDefinition(node: any) {
if (isBareRootAlias(node.value)) {
context.report({ node: node.value, messageId: "owned" });
}
},
MemberExpression(node: any) {
const name = propertyName(node);
if (
isRootAlias(node.object) &&
((name !== null &&
browserCapabilityProperties.has(name)) ||
(name === null && node.computed))
) {
context.report({ node, messageId: "owned" });
}
},
CallExpression(node: any) {
for (const [index, argument] of (
node.arguments ?? []
).entries()) {
const candidate =
argument.type === "SpreadElement"
? argument.argument
: argument;
if (
isDirectBrowserRoot(candidate) &&
!safeMethodThisBinding(node, index)
) {
context.report({ node: argument, messageId: "owned" });
}
}
const callee = unwrap(node.callee);
if (
callee?.type !== "MemberExpression" ||
propertyName(callee) !== "get" ||
unwrap(callee.object)?.type !== "Identifier" ||
unwrap(callee.object).name !== "Reflect" ||
!isRootAlias(node.arguments?.[0])
) {
return;
}
const key = unwrap(node.arguments?.[1]);
if (
(key?.type === "Literal" ||
key?.type === "StringLiteral") &&
typeof key.value === "string" &&
browserCapabilityProperties.has(key.value)
) {
context.report({ node, messageId: "owned" });
}
},
NewExpression(node: any) {
for (const argument of node.arguments ?? []) {
const candidate =
argument.type === "SpreadElement"
? argument.argument
: argument;
if (isBareRootAlias(candidate)) {
context.report({ node: argument, messageId: "owned" });
}
}
},
Property(node: any) {
if (
node.parent?.type === "ObjectExpression" &&
isBareRootAlias(node.value)
) {
context.report({ node: node.value, messageId: "owned" });
}
},
ArrayExpression(node: any) {
for (const element of node.elements ?? []) {
if (isBareRootAlias(element)) {
context.report({ node: element, messageId: "owned" });
}
}
},
ReturnStatement(node: any) {
if (isBareRootAlias(node.argument)) {
context.report({ node: node.argument, messageId: "owned" });
}
},
ArrowFunctionExpression(node: any) {
if (
node.expression === true &&
isBareRootAlias(node.body)
) {
context.report({ node: node.body, messageId: "owned" });
}
},
};
},
};
const browserDataBoundaryPlugin = {
rules: {
"no-capability-alias": noBrowserCapabilityAliasRule,
},
};
const commonLanguageOptions = {
ecmaVersion: "latest",
sourceType: "module",
globals: {
...globals.browser,
...globals.node,
},
};
const commonSecurityRules = {
"no-eval": "error",
"no-new-func": "error",
"no-script-url": "error",
"no-restricted-syntax": [
"error",
{
selector: "JSXAttribute[name.name='dangerouslySetInnerHTML']",
message: "Raw HTML injection is prohibited by FE-OC-019.",
},
{
selector:
"CallExpression[callee.object.name='document'][callee.property.name='createElement'][arguments.0.value='script']",
message: "Runtime script construction is prohibited by FE-OC-019.",
},
],
};
const hookRules = {
"react-hooks/rules-of-hooks": "error",
"react-hooks/exhaustive-deps": "error",
};
// 0929/08-02. Screen code takes its words from the message catalog. Comments
// are not in the AST, so only rendered text and accessible names are checked:
// JSX text and the display/accessibility attributes below that hold a letter
// in any script. Punctuation and numbers pass. Text built in an expression (a
// template literal, a ternary, an object prop such as `heading.title`) is not
// seen; review catches those. A product replaces these selectors in its own
// config, for example to allow a brand name or to drop the rule for a
// one-locale product. The component gallery (src/presentation/examples) and
// stories are workshop code and stay out; tests are outside these folders.
const screenTextDirectories = [
"src/presentation/boundaries",
"src/presentation/components",
"src/presentation/design-system",
"src/presentation/forms",
"src/presentation/layouts",
"src/presentation/pages",
"src/presentation/routes",
"src/presentation/templates",
"src/features/*/presentation",
];
const screenTextAttributes =
"/^(?:aria-label|aria-description|aria-roledescription|aria-valuetext|aria-placeholder|title|placeholder|alt|label)$/";
const screenTextMessage =
"Screen words come from the message catalog: use message(key) (0929/08-02).";
const screenTextSelectors = [
{
selector: "JSXText[value=/\\p{L}/u]",
message: screenTextMessage,
},
{
selector: `JSXElement > JSXExpressionContainer > Literal[value=/\\p{L}/u]`,
message: screenTextMessage,
},
{
selector: `JSXAttribute[name.name=${screenTextAttributes}] > Literal[value=/\\p{L}/u]`,
message: screenTextMessage,
},
{
selector: `JSXAttribute[name.name=${screenTextAttributes}] > JSXExpressionContainer > Literal[value=/\\p{L}/u]`,
message: screenTextMessage,
},
];
export default [
{
ignores: [
"dist/**",
"node_modules/**",
"artifacts/**",
"tests/fixtures/typecheck/**",
"tests/fixtures/architecture/forbidden/**",
"tests/fixtures/diagnostics/forbidden/**",
"tests/fixtures/i18n/forbidden/**",
"tests/fixtures/security/forbidden/**",
"tests/fixtures/optional-recipes/**",
"tests/fixtures/browser-file-storage-boundaries/**",
],
},
eslint.configs.recommended,
{
files: [`**/*.${sourceExtensions}`],
languageOptions: {
...commonLanguageOptions,
parserOptions: {
ecmaFeatures: { jsx: true },
},
},
plugins: {
"react-hooks": reactHooks,
},
rules: {
...commonSecurityRules,
...hookRules,
},
},
{
files: ["**/*.{ts,mts,cts}"],
languageOptions: {
...commonLanguageOptions,
parser: babelParser,
parserOptions: {
requireConfigFile: false,
babelOptions: {
plugins: [
["@babel/plugin-syntax-typescript", { isTSX: false }],
],
},
},
},
rules: {
"no-undef": "off",
"no-unused-vars": "off",
},
},
{
files: ["**/*.d.ts"],
languageOptions: {
...commonLanguageOptions,
parser: babelParser,
parserOptions: {
requireConfigFile: false,
babelOptions: {
plugins: [
["@babel/plugin-syntax-typescript", { dts: true }],
],
},
},
},
rules: {
"no-undef": "off",
"no-unused-vars": "off",
},
},
{
files: ["**/*.tsx"],
languageOptions: {
...commonLanguageOptions,
parser: babelParser,
parserOptions: {
requireConfigFile: false,
babelOptions: {
plugins: [
[
"@babel/plugin-syntax-typescript",
{ allExtensions: true, isTSX: true },
],
"@babel/plugin-syntax-jsx",
],
},
},
},
rules: {
"no-undef": "off",
"no-unused-vars": "off",
},
},
{
files: [
`src/domain/**/*.${sourceExtensions}`,
`src/application/**/*.${sourceExtensions}`,
`src/presentation/**/*.${sourceExtensions}`,
`src/bootstrap/**/*.${sourceExtensions}`,
`src/features/**/*.${sourceExtensions}`,
`src/adapters/**/*.${sourceExtensions}`,
],
ignores: [
`src/adapters/browser-file-storage/**/*.${sourceExtensions}`,
`src/adapters/browser-files/**/*.${sourceExtensions}`,
`src/adapters/browser-transfer/**/*.${sourceExtensions}`,
`src/adapters/cache-storage/**/*.${sourceExtensions}`,
`src/adapters/cross-context-invalidation/**/*.${sourceExtensions}`,
`src/adapters/service-worker/**/*.${sourceExtensions}`,
`src/bootstrap/register-service-worker.ts`,
`src/adapters/platform/browser-lifecycle.ts`,
`src/adapters/storage/**/*.${sourceExtensions}`,
`src/adapters/storage/indexeddb/**/*.${sourceExtensions}`,
`src/adapters/storage/opfs/**/*.${sourceExtensions}`,
],
plugins: {
"browser-data-boundary": browserDataBoundaryPlugin,
},
rules: {
"browser-data-boundary/no-capability-alias": "error",
},
},
{
// 07-01. Every file outside a layer rule; the layer rules below replace
// this entry and carry the same aliases through restrictedImports.
files: [`src/**/*.${sourceExtensions}`, `tests/**/*.${sourceExtensions}`],
rules: {
"no-restricted-imports": ["error", { patterns: deprecatedAliasImports }],
},
},
{
files: [`src/domain/**/*.${sourceExtensions}`],
rules: {
"no-restricted-imports": restrictedImports(layerPatterns.domain, layerMessages.domain),
"no-restricted-properties": restrictedBrowserDataProperties,
"no-restricted-globals": [
"error",
"window",
"document",
"BroadcastChannel",
"localStorage",
"sessionStorage",
"fetch",
"indexedDB",
"caches",
"navigator",
"File",
"Blob",
"FileSystemFileHandle",
"FileSystemDirectoryHandle",
"showOpenFilePicker",
"showSaveFilePicker",
],
},
},
{
files: [`src/application/**/*.${sourceExtensions}`],
rules: {
"no-restricted-imports": restrictedImports(layerPatterns.application, layerMessages.application),
"no-restricted-properties": restrictedBrowserDataProperties,
"no-restricted-globals": [
"error",
"window",
"document",
"BroadcastChannel",
"localStorage",
"sessionStorage",
"fetch",
"indexedDB",
"caches",
"navigator",
"File",
"Blob",
"FileSystemFileHandle",
"FileSystemDirectoryHandle",
"showOpenFilePicker",
"showSaveFilePicker",
],
},
},
{
files: [`src/presentation/**/*.${sourceExtensions}`],
rules: {
"no-restricted-imports": restrictedImports(layerPatterns.presentation, layerMessages.presentation),
"no-restricted-properties": restrictedBrowserDataProperties,
"no-restricted-globals": [
"error",
"fetch",
"BroadcastChannel",
"localStorage",
"sessionStorage",
"indexedDB",
"caches",
"File",
"Blob",
"FileSystemFileHandle",
"FileSystemDirectoryHandle",
"showOpenFilePicker",
"showSaveFilePicker",
],
},
},
{
files: [
`src/presentation/adapters/query/**/*.${sourceExtensions}`,
],
rules: {
"no-restricted-imports": restrictedImports(
[
"**/adapters/http/**",
"**/adapters/storage/**",
"**/adapters/auth/**",
"**/bootstrap/**",
"**/application/ports/out/**",
],
"the TanStack Query binding may import @tanstack only; reach adapters through application ports (presentation-does-not-know-adapters).",
),
},
},
{
files: [`src/presentation/templates/**/*.${sourceExtensions}`],
rules: {
"no-restricted-imports": restrictedImports(
[
"**/application/**",
"**/adapters/**",
"**/bootstrap/**",
"@tanstack/**",
],
"page templates own layout only (page-templates-own-layout-only). Take data and actions as props from the page.",
),
},
},
{
files: [
`src/bootstrap/**/*.${sourceExtensions}`,
`src/features/installed-feature-*.${sourceExtensions}`,
],
rules: {
"no-restricted-properties": restrictedBrowserDataProperties,
"no-restricted-globals": [
"error",
"BroadcastChannel",
"localStorage",
"sessionStorage",
"indexedDB",
"caches",
"File",
"Blob",
"FileSystemFileHandle",
"FileSystemDirectoryHandle",
"showOpenFilePicker",
"showSaveFilePicker",
],
},
},
{
files: [`src/adapters/**/*.${sourceExtensions}`],
rules: {
"no-restricted-imports": restrictedImports(layerPatterns.adapters, layerMessages.adapters),
"no-restricted-properties": restrictedBrowserDataProperties,
"no-restricted-globals": [
"error",
"BroadcastChannel",
"localStorage",
"sessionStorage",
"indexedDB",
"caches",
"navigator",
"File",
"Blob",
"FileSystemFileHandle",
"FileSystemDirectoryHandle",
"showOpenFilePicker",
"showSaveFilePicker",
],
},
},
{
files: [
`src/adapters/browser-file-storage/**/*.${sourceExtensions}`,
`src/adapters/browser-files/**/*.${sourceExtensions}`,
`src/adapters/browser-transfer/**/*.${sourceExtensions}`,
`src/adapters/cache-storage/**/*.${sourceExtensions}`,
`src/adapters/cross-context-invalidation/**/*.${sourceExtensions}`,
`src/adapters/service-worker/**/*.${sourceExtensions}`,
`src/bootstrap/register-service-worker.ts`,
`src/adapters/platform/browser-lifecycle.ts`,
`src/adapters/storage/**/*.${sourceExtensions}`,
`src/adapters/storage/indexeddb/**/*.${sourceExtensions}`,
`src/adapters/storage/opfs/**/*.${sourceExtensions}`,
],
rules: {
"no-restricted-properties": "off",
"no-restricted-globals": "off",
},
},
{
files: [`src/features/*/domain/**/*.${sourceExtensions}`],
rules: {
"no-restricted-imports": restrictedImports(layerPatterns.domain, layerMessages.domain),
"no-restricted-properties": restrictedBrowserDataProperties,
"no-restricted-globals": [
"error",
"window",
"document",
"BroadcastChannel",
"localStorage",
"sessionStorage",
"fetch",
"indexedDB",
"caches",
"navigator",
"File",
"Blob",
"FileSystemFileHandle",
"FileSystemDirectoryHandle",
"showOpenFilePicker",
"showSaveFilePicker",
],
},
},
{
files: [`src/features/*/application/**/*.${sourceExtensions}`],
rules: {
"no-restricted-imports": restrictedImports(layerPatterns.application, layerMessages.application),
"no-restricted-properties": restrictedBrowserDataProperties,
"no-restricted-globals": [
"error",
"window",
"document",
"BroadcastChannel",
"localStorage",
"sessionStorage",
"fetch",
"indexedDB",
"caches",
"navigator",
"File",
"Blob",
"FileSystemFileHandle",
"FileSystemDirectoryHandle",
"showOpenFilePicker",
"showSaveFilePicker",
],
},
},
{
files: [`src/features/*/presentation/**/*.${sourceExtensions}`],
rules: {
"no-restricted-imports": restrictedImports(
[
"**/features/*/adapters/**",
"**/adapters/http/**",
"**/adapters/storage/**",
"**/adapters/auth/**",
"**/bootstrap/**",
"**/application/ports/out/**",
"@tanstack/**",
],
"feature presentation calls its application API (feature-presentation-does-not-know-outbound-adapters). Bootstrap wires the adapters.",
),
"no-restricted-properties": restrictedBrowserDataProperties,
"no-restricted-globals": [
"error",
"fetch",
"BroadcastChannel",
"localStorage",
"sessionStorage",
"indexedDB",
"caches",
"File",
"Blob",
"FileSystemFileHandle",
"FileSystemDirectoryHandle",
"showOpenFilePicker",
"showSaveFilePicker",
],
},
},
{
files: [`src/features/*/adapters/**/*.${sourceExtensions}`],
rules: {
"no-restricted-imports": restrictedImports(
[
"**/presentation/**",
"**/bootstrap/**",
"@tanstack/**",
],
"a feature adapter implements the feature's ports and never imports UI or bootstrap (feature-adapters-do-not-know-presentation).",
),
"no-restricted-properties": restrictedBrowserDataProperties,
"no-restricted-globals": [
"error",
"BroadcastChannel",
"localStorage",
"sessionStorage",
"indexedDB",
"caches",
"navigator",
"File",
"Blob",
"FileSystemFileHandle",
"FileSystemDirectoryHandle",
"showOpenFilePicker",
"showSaveFilePicker",
],
},
},
{
// The same folders inside an i18n fixture tree, so check:i18n:fixture
// runs this rule on its fixtures. This entry replaces the general
// no-restricted-syntax list, so it carries the FE-OC-019 selectors too.
files: screenTextDirectories.flatMap((directory) => [
`${directory}/**/*.tsx`,
`tests/fixtures/i18n/*/${directory}/**/*.tsx`,
]),
ignores: ["**/*.stories.tsx"],
rules: {
"no-restricted-syntax": [
...commonSecurityRules["no-restricted-syntax"],
...screenTextSelectors,
],
},
},
{
files: [`tests/**/*.${sourceExtensions}`],
languageOptions: {
globals: {
...globals.browser,
...globals.node,
},
},
},
{
files: [`tests/support/browser/**/*.${sourceExtensions}`],
rules: {
"react-hooks/rules-of-hooks": "off",
},
},
{
files: [
`tests/fixtures/browser-file-storage-boundaries/forbidden/**/*.${sourceExtensions}`,
],
plugins: {
"browser-data-boundary": browserDataBoundaryPlugin,
},
rules: {
"browser-data-boundary/no-capability-alias": "error",
"no-restricted-properties": restrictedBrowserDataProperties,
"no-restricted-globals": [
"error",
"BroadcastChannel",
"localStorage",
"sessionStorage",
"indexedDB",
"caches",
"File",
"Blob",
"FileSystemFileHandle",
"FileSystemDirectoryHandle",
"showOpenFilePicker",
"showSaveFilePicker",
],
},
},
{
// 13-06. Vite inlines every loaded VITE_* value into the bundle wherever
// code references the whole `import.meta.env` object, including values no
// code reads. Keyed reads are replaced one by one.
files: [`src/**/*.${sourceExtensions}`],
plugins: {
"build-env": {
rules: {
"no-whole-import-meta-env": {
meta: {
type: "problem",
schema: [],
messages: {
whole:
"Read build variables by key (import.meta.env.VITE_NAME). Referencing import.meta or import.meta.env as a whole bundles every VITE_* value (13-06).",
},
},
create(context: any) {
const isMember = (node: any) =>
node?.type === "MemberExpression" ||
node?.type === "OptionalMemberExpression";
return {
MetaProperty(node: any) {
if (node.meta?.name !== "import") return;
const member = node.parent;
if (!isMember(member) || member.object !== node || member.computed) {
context.report({ node, messageId: "whole" });
return;
}
if (member.property?.name !== "env") return;
const read = member.parent;
if (isMember(read) && read.object === member && !read.computed) {
return;
}
context.report({ node: member, messageId: "whole" });
},
};
},
},
},
},
},
rules: {
"build-env/no-whole-import-meta-env": "error",
},
},
];