@simplysm/lint 13.0.69 → 13.0.71

package/src/rules/no-hard-private.ts

@@ -18,27 +18,27 @@ function isClassMemberWithAccessibility(
 }
 
 /**
- * ECMAScript private 필드(`#field`) 사용을 제한하고 TypeScript `private` 키워드 사용을 강제하는 ESLint 규칙
+ * ESLint rule that restricts ECMAScript private fields (`#field`) and enforces TypeScript `private` keyword usage.
  *
  * @remarks
- * 이 규칙은 다음을 검사한다:
- * - 클래스 필드 선언: `#field`
- * - 클래스 메서드 선언: `#method()`
- * - 클래스 접근자 선언: `accessor #field`
- * - 멤버 접근 표현식: `this.#field`
+ * This rule checks:
+ * - Class field declarations: `#field`
+ * - Class method declarations: `#method()`
+ * - Class accessor declarations: `accessor #field`
+ * - Member access expressions: `this.#field`
  */
 export default createRule({
   name: "no-hard-private",
   meta: {
     type: "problem",
     docs: {
-      description: '하드 프라이빗 필드(#) 대신 TypeScript "private _" 스타일을 강제한다.',
+      description: 'Enforces TypeScript "private _" style instead of hard private fields (#).',
     },
     messages: {
       preferSoftPrivate:
-        '하드 프라이빗 필드(#)는 허용되지 않습니다. "private _" 스타일을 사용하세요.',
+        'Hard private fields (#) are not allowed. Use the "private _" style instead.',
       nameConflict:
-        '하드 프라이빗 필드 "#{{name}}"을 "_{{name}}"으로 변환할 수 없습니다. 동일한 이름의 멤버가 이미 존재합니다.',
+        'Cannot convert hard private field "#{{name}}" to "_{{name}}". A member with the same name already exists.',
     },
     fixable: "code",
     schema: [],
@@ -46,11 +46,11 @@ export default createRule({
   defaultOptions: [],
   create(context) {
     const sourceCode = context.sourceCode;
-    // 중첩 클래스 지원을 위한 스택 구조
+    // Stack structure for supporting nested classes
     const classStack: Set<string>[] = [];
 
     return {
-      // 0. 클래스 진입 시 멤버 이름 수집
+      // 0. Collect member names when entering a class
       "ClassBody"(node: TSESTree.ClassBody) {
         const memberNames = new Set<string>();
         for (const member of node.body) {
@@ -67,7 +67,7 @@ export default createRule({
         classStack.pop();
       },
 
-      // 1. 선언부 감지 (PropertyDefinition, MethodDefinition, AccessorProperty)
+      // 1. Detect declarations (PropertyDefinition, MethodDefinition, AccessorProperty)
       "PropertyDefinition > PrivateIdentifier, MethodDefinition > PrivateIdentifier, AccessorProperty > PrivateIdentifier"(
         node: TSESTree.PrivateIdentifier,
       ) {
@@ -76,11 +76,11 @@ export default createRule({
           return;
         }
 
-        const identifierName = node.name; // '#'을 제외한 이름
+        const identifierName = node.name; // Name without the '#' character
         const targetName = `_${identifierName}`;
         const currentClassMembers = classStack.at(-1);
 
-        // 이름 충돌 검사
+        // Check for name conflicts
         if (currentClassMembers?.has(targetName)) {
           context.report({
             node,
@@ -96,25 +96,25 @@ export default createRule({
           fix(fixer) {
             const fixes: RuleFix[] = [];
 
-            // 1-1. 이름 변경 (#a -> _a)
+            // 1-1. Rename (#a -> _a)
             fixes.push(fixer.replaceText(node, targetName));
 
-            // 1-2. 'private' 접근 제어자 추가 위치 계산
+            // 1-2. Calculate the position to add the 'private' access modifier
             if (parent.accessibility == null) {
-              // 기본 삽입 위치: 부모 노드의 시작 지점 (static, async 등 포함)
+              // Default insertion position: beginning of parent node (including static, async, etc)
               let tokenToInsertBefore = sourceCode.getFirstToken(parent);
 
-              // 데코레이터가 있다면, 마지막 데코레이터 '다음' 토큰 앞에 삽입
+              // If decorators exist, insert before the token after the last decorator
               // (@Deco private static _foo)
               if (parent.decorators.length > 0) {
                 const lastDecorator = parent.decorators.at(-1)!;
                 tokenToInsertBefore = sourceCode.getTokenAfter(lastDecorator);
               }
 
-              // tokenToInsertBefore는 이제 'static', 'async', 'readonly' 또는 변수명('_foo')입니다.
-              // 이 앞에 'private '를 붙이면 자연스럽게 'private static ...' 순서가 됩니다.
-              // tokenToInsertBefore가 null인 경우는 AST 파싱 오류 등 예외 상황이므로,
-              // 이름만 변경되는 불완전한 fix를 방지하기 위해 전체 fix를 생략한다.
+              // tokenToInsertBefore is now 'static', 'async', 'readonly', or a variable name ('_foo').
+              // Inserting 'private ' before it naturally results in the correct order 'private static ...'.
+              // If tokenToInsertBefore is null, it indicates an exceptional situation such as an AST parsing error.
+              // In such cases, skip the entire fix to prevent an incomplete fix that only renames.
               if (tokenToInsertBefore == null) {
                 return [];
               }
@@ -126,7 +126,7 @@ export default createRule({
         });
       },
 
-      // 2. 사용부 감지 (this.#field)
+      // 2. Detect usage (this.#field)
       "MemberExpression > PrivateIdentifier"(node: TSESTree.PrivateIdentifier) {
         const identifierName = node.name;
         context.report({

package/src/rules/no-subpath-imports-from-simplysm.ts

@@ -2,13 +2,13 @@ import { AST_NODE_TYPES, TSESTree } from "@typescript-eslint/utils";
 import { createRule } from "../utils/create-rule";
 
 /**
- * `@simplysm/*` 패키지에서 'src' 서브경로 import를 금지하는 ESLint 규칙
+ * ESLint rule that prohibits 'src' subpath imports from `@simplysm/*` packages.
  *
  * @remarks
- * 이 규칙은 다음을 검사한다:
- * - 정적 import 문: `import ... from '...'`
- * - 동적 import: `import('...')`
- * - re-export 문: `export { ... } from '...'`, `export * from '...'`
+ * This rule checks:
+ * - Static import statements: `import ... from '...'`
+ * - Dynamic imports: `import('...')`
+ * - Re-export statements: `export { ... } from '...'`, `export * from '...'`
  */
 export default createRule({
   name: "no-subpath-imports-from-simplysm",
@@ -16,13 +16,13 @@ export default createRule({
     type: "problem",
     docs: {
       description:
-        "@simplysm 패키지에서 'src' 서브경로 import를 금지한다. (ex: @simplysm/pkg/src/x → 금지)",
+        "Prohibits 'src' subpath imports from @simplysm packages. (e.g., @simplysm/pkg/src/x → prohibited)",
     },
     fixable: "code",
     schema: [],
     messages: {
       noSubpathImport:
-        "'@simplysm/{{pkg}}' 패키지는 'src' 서브경로를 import할 수 없습니다: '{{importPath}}'",
+        "Cannot import 'src' subpath from '@simplysm/{{pkg}}' package: '{{importPath}}'",
     },
   },
   defaultOptions: [],
@@ -32,8 +32,8 @@ export default createRule({
 
       const parts = importPath.split("/");
 
-      // 허용: @simplysm/pkg, @simplysm/pkg/xxx, @simplysm/pkg/xxx/yyy
-      // 금지: @simplysm/pkg/src, @simplysm/pkg/src/xxx
+      // Allowed: @simplysm/pkg, @simplysm/pkg/xxx, @simplysm/pkg/xxx/yyy
+      // Prohibited: @simplysm/pkg/src, @simplysm/pkg/src/xxx
       if (parts.length >= 3 && parts[2] === "src") {
         const fixedPath = `@simplysm/${parts[1]}`;
         context.report({
@@ -52,12 +52,12 @@ export default createRule({
     }
 
     return {
-      // 정적 import: import { x } from '...'
+      // Static import: import { x } from '...'
       ImportDeclaration(node) {
         checkAndReport(node.source, node.source.value);
       },
 
-      // 동적 import: import('...')
+      // Dynamic import: import('...')
       ImportExpression(node) {
         if (node.source.type !== AST_NODE_TYPES.Literal) return;
         const importPath = node.source.value;
@@ -65,13 +65,13 @@ export default createRule({
         checkAndReport(node.source, importPath);
       },
 
-      // re-export: export { x } from '...'
+      // Re-export: export { x } from '...'
       ExportNamedDeclaration(node) {
         if (!node.source) return;
         checkAndReport(node.source, node.source.value);
       },
 
-      // re-export all: export * from '...'
+      // Re-export all: export * from '...'
       ExportAllDeclaration(node) {
         checkAndReport(node.source, node.source.value);
       },

package/src/rules/ts-no-throw-not-implemented-error.ts

@@ -2,25 +2,25 @@ import { AST_NODE_TYPES, ASTUtils, type TSESTree } from "@typescript-eslint/util
 import { createRule } from "../utils/create-rule";
 
 /**
- * `@simplysm/core-common`의 `NotImplementedError` 사용을 감지하여 경고하는 ESLint 규칙
+ * ESLint rule that detects and warns about the use of `NotImplementedError` from `@simplysm/core-common`.
  *
  * @remarks
- * 이 규칙은 `@simplysm/core-common`에서 import된 `NotImplementedError`를 `new`로 생성하는 코드를 감지한다.
- * 미구현 코드가 프로덕션에 포함되는 것을 방지한다.
+ * This rule detects code that instantiates `NotImplementedError` imported from `@simplysm/core-common` using `new`.
+ * It prevents unimplemented code from being included in production.
  *
- * 지원하는 import 형태:
+ * Supported import forms:
  * - named import: `import { NotImplementedError } from "@simplysm/core-common"`
  * - aliased import: `import { NotImplementedError as NIE } from "@simplysm/core-common"`
  * - namespace import: `import * as CC from "@simplysm/core-common"` → `new CC.NotImplementedError()`
  *
- * 동적 import(`await import(...)`)는 감지하지 않는다.
+ * Dynamic imports (`await import(...)`) are not detected.
  */
 export default createRule({
   name: "ts-no-throw-not-implemented-error",
   meta: {
     type: "suggestion",
     docs: {
-      description: "'NotImplementedError' 사용 경고",
+      description: "Warns about 'NotImplementedError' usage",
     },
     schema: [],
     messages: {
@@ -30,10 +30,10 @@ export default createRule({
   defaultOptions: [],
   create(context) {
     /**
-     * identifier가 @simplysm/core-common에서 import된 것인지 확인
-     * @param identifier - 확인할 identifier
-     * @param expectedImportedName - named import인 경우 확인할 원본 이름 (namespace import는 undefined)
-     * @returns import 출처가 @simplysm/core-common이면 true, 아니면 false
+     * Checks if an identifier is imported from @simplysm/core-common.
+     * @param identifier - The identifier to check
+     * @param expectedImportedName - The original name to check for named imports (undefined for namespace imports)
+     * @returns true if the import source is @simplysm/core-common, false otherwise
      */
     function isImportedFromSimplysm(
       identifier: TSESTree.Identifier,
@@ -48,7 +48,7 @@ export default createRule({
         if (def.parent.type !== AST_NODE_TYPES.ImportDeclaration) continue;
         if (def.parent.source.value !== "@simplysm/core-common") continue;
 
-        // named/aliased import: import { NotImplementedError } 또는 import { NotImplementedError as NIE }
+        // named/aliased import: import { NotImplementedError } or import { NotImplementedError as NIE }
         if (def.node.type === AST_NODE_TYPES.ImportSpecifier && expectedImportedName != null) {
           const imported = def.node.imported;
           if (
@@ -75,7 +75,7 @@ export default createRule({
       NewExpression(node: TSESTree.NewExpression) {
         let shouldReport = false;
 
-        // Case 1: new NotImplementedError() 또는 new NIE() (named/aliased import)
+        // Case 1: new NotImplementedError() or new NIE() (named/aliased import)
         if (node.callee.type === AST_NODE_TYPES.Identifier) {
           shouldReport = isImportedFromSimplysm(node.callee, "NotImplementedError");
         }
@@ -92,7 +92,7 @@ export default createRule({
 
         if (!shouldReport) return;
 
-        let msg = "미구현";
+        let msg = "Not implemented";
         const firstArg = node.arguments.at(0);
         if (
           firstArg?.type === AST_NODE_TYPES.Literal &&

package/src/stylelint-recommended.ts

@@ -2,7 +2,7 @@ export default {
   extends: ["stylelint-config-standard", "stylelint-config-tailwindcss"],
   plugins: ["stylelint-no-unsupported-browser-features", "stylelint-no-unresolved-module"],
   rules: {
-    // Chrome 84+ 호환성 체크
+    // Chrome 84+ compatibility check
     "plugin/no-unsupported-browser-features": [
       true,
       {
@@ -11,9 +11,9 @@ export default {
         ignore: ["css-cascade-layers", "css-nesting", "css-overflow"],
       },
     ],
-    // inset은 Chrome 87+이므로 shorthand 강제 비활성화
+    // inset requires Chrome 87+, so enforce shorthand is disabled
     "declaration-block-no-redundant-longhand-properties": [true, { ignoreShorthands: ["inset"] }],
-    // @import, url() 파일 존재 체크
+    // Check for file existence in @import and url()
     "plugin/no-unresolved-module": true,
   },
 };

package/src/utils/create-rule.ts

@@ -1,11 +1,11 @@
 import { ESLintUtils } from "@typescript-eslint/utils";
 
 /**
- * ESLint 규칙을 생성하는 팩토리 함수
+ * Factory function to create ESLint rules.
  *
  * @remarks
- * `@typescript-eslint/utils`의 `RuleCreator`를 래핑하여
- * 규칙 문서 URL을 자동으로 생성한다.
+ * Wraps `RuleCreator` from `@typescript-eslint/utils` and
+ * automatically generates rule documentation URLs.
  *
  * @example
  * ```typescript