@simplysm/lint 13.0.2

package/dist/utils/create-rule.js

@@ -0,0 +1,8 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+const createRule = ESLintUtils.RuleCreator(
+  (name) => `https://github.com/kslhunter/simplysm/blob/master/packages/eslint-plugin/README.md#${name}`
+);
+export {
+  createRule
+};
+//# sourceMappingURL=create-rule.js.map

package/dist/utils/create-rule.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../src/utils/create-rule.ts"],
+  "mappings": "AAAA,SAAS,mBAAmB;AAmBrB,MAAM,aAAa,YAAY;AAAA,EACpC,CAAC,SAAS,sFAAsF,IAAI;AACtG;",
+  "names": []
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@simplysm/lint",
+  "sideEffects": false,
+  "version": "13.0.2",
+  "description": "심플리즘 패키지 - Lint 설정 (ESLint + Stylelint)",
+  "author": "김석래",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kslhunter/simplysm.git",
+    "directory": "packages/lint"
+  },
+  "license": "Apache-2.0",
+  "type": "module",
+  "exports": {
+    "./eslint-plugin": {
+      "types": "./dist/eslint-plugin.d.ts",
+      "default": "./dist/eslint-plugin.js"
+    },
+    "./eslint-recommended": {
+      "types": "./dist/eslint-recommended.d.ts",
+      "default": "./dist/eslint-recommended.js"
+    },
+    "./stylelint-recommended": {
+      "types": "./dist/stylelint-recommended.d.ts",
+      "default": "./dist/stylelint-recommended.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "dependencies": {
+    "@typescript-eslint/utils": "^8.55.0",
+    "eslint": "^9.39.2",
+    "eslint-plugin-import": "^2.32.0",
+    "eslint-plugin-solid": "^0.14.5",
+    "eslint-plugin-tailwindcss": "^3.18.2",
+    "eslint-plugin-unused-imports": "^4.4.1",
+    "globals": "^17.3.0",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.55.0",
+    "stylelint": "^16.26.1",
+    "stylelint-config-standard": "^37.0.0",
+    "stylelint-config-tailwindcss": "^1.0.1",
+    "stylelint-no-unsupported-browser-features": "^8.1.1",
+    "stylelint-no-unresolved-module": "^2.5.2"
+  },
+  "devDependencies": {
+    "@types/eslint-plugin-tailwindcss": "^3.17.0",
+    "@typescript-eslint/rule-tester": "^8.55.0"
+  }
+}

package/src/eslint-plugin.ts

@@ -0,0 +1,11 @@
+import noHardPrivate from "./rules/no-hard-private";
+import noSubpathImportsFromSimplysm from "./rules/no-subpath-imports-from-simplysm";
+import tsNoThrowNotImplementedError from "./rules/ts-no-throw-not-implemented-error";
+
+export default {
+  rules: {
+    "no-hard-private": noHardPrivate,
+    "no-subpath-imports-from-simplysm": noSubpathImportsFromSimplysm,
+    "ts-no-throw-not-implemented-error": tsNoThrowNotImplementedError,
+  },
+};

package/src/eslint-recommended.ts

@@ -0,0 +1,274 @@
+import globals from "globals";
+import tseslint, { type FlatConfig } from "typescript-eslint";
+import plugin from "./eslint-plugin";
+import importPlugin from "eslint-plugin-import";
+import unusedImportsPlugin from "eslint-plugin-unused-imports";
+import solidPlugin from "eslint-plugin-solid";
+import tailwindcssPlugin from "eslint-plugin-tailwindcss";
+import { defineConfig, globalIgnores } from "eslint/config";
+import { ESLint } from "eslint";
+
+//#region 공통 규칙 설정
+
+/**
+ * JS/TS 공통 규칙
+ * - no-console: 프로덕션 코드에서 console 사용 금지 (성능 저하 방지)
+ * - no-warning-comments: TODO/FIXME 주석 경고 (미완성 코드 확인용)
+ * - eqeqeq: `===` 사용 강제 (null 체크는 `== null` 허용)
+ * - no-self-compare: `x === x` 같은 오타 방지
+ * - array-callback-return: map/filter 등에서 return 빠뜨림 방지
+ */
+const commonRules: FlatConfig.Rules = {
+  "no-console": "error",
+  "no-warning-comments": "warn",
+  "eqeqeq": ["error", "always", { null: "ignore" }],
+  "no-self-compare": "error",
+  "array-callback-return": "error",
+};
+
+/**
+ * 모든 패키지에서 Node.js 전용 API 사용 금지 (코드 통일)
+ * - Buffer → Uint8Array, bytesToHex/bytesFromHex/bytesConcat 사용
+ * - EventEmitter → SdEventEmitter 사용
+ */
+const noNodeBuiltinsRules: FlatConfig.Rules = {
+  "no-restricted-globals": [
+    "error",
+    {
+      name: "Buffer",
+      message: "Uint8Array를 사용하세요. 복잡한 연산은 @simplysm/core-common의 BytesUtils를 사용하세요.",
+    },
+  ],
+  "no-restricted-imports": [
+    "error",
+    {
+      paths: [
+        {
+          name: "buffer",
+          message: "Uint8Array를 사용하세요. 복잡한 연산은 @simplysm/core-common의 BytesUtils를 사용하세요.",
+        },
+        {
+          name: "events",
+          message: "@simplysm/core-common의 SdEventEmitter를 사용하세요.",
+        },
+        {
+          name: "eventemitter3",
+          message: "@simplysm/core-common의 SdEventEmitter를 사용하세요.",
+        },
+      ],
+    },
+  ],
+};
+
+/**
+ * 미사용 import 처리 규칙
+ * - 미사용 import 자동 제거
+ * - `_` 접두사 변수/인자는 미사용 허용 (예: `_unused`)
+ */
+const unusedImportsRules: FlatConfig.Rules = {
+  "unused-imports/no-unused-imports": "error",
+  "unused-imports/no-unused-vars": [
+    "error",
+    {
+      vars: "all",
+      varsIgnorePattern: "^_",
+      args: "after-used",
+      argsIgnorePattern: "^_",
+    },
+  ],
+};
+
+//#endregion
+
+export default defineConfig([
+  globalIgnores([
+    // directory/** 형태로 순회 자체를 건너뜀
+    "**/node_modules/**",
+    "**/dist/**",
+    "**/.*/**",
+    "**/_*/**",
+  ]),
+  {
+    languageOptions: {
+      globals: {
+        ...globals.node,
+        ...globals.es2024,
+        ...globals.browser,
+      },
+      ecmaVersion: 2024,
+      sourceType: "module",
+    },
+  },
+  {
+    files: ["**/*.js", "**/*.jsx"],
+    plugins: {
+      "import": importPlugin,
+      "@simplysm": plugin as unknown as ESLint.Plugin,
+      "unused-imports": unusedImportsPlugin,
+    },
+    rules: {
+      ...commonRules,
+
+      "require-await": "error",
+      "no-shadow": "error",
+      "no-duplicate-imports": "error",
+      "no-unused-expressions": "error",
+      "no-undef": "error",
+
+      ...unusedImportsRules,
+
+      "import/no-extraneous-dependencies": [
+        "error",
+        {
+          devDependencies: ["**/lib/**", "**/eslint.config.js", "**/simplysm.js", "**/vitest.config.js"],
+        },
+      ],
+
+      // JS/TS 공통
+      "@simplysm/no-subpath-imports-from-simplysm": "error",
+      "@simplysm/no-hard-private": "error",
+
+      ...noNodeBuiltinsRules,
+    },
+  },
+  {
+    files: ["**/*.ts", "**/*.tsx"],
+    plugins: {
+      "@typescript-eslint": tseslint.plugin,
+      "@simplysm": plugin as unknown as ESLint.Plugin,
+      "import": importPlugin,
+      "unused-imports": unusedImportsPlugin,
+    },
+    languageOptions: {
+      parser: tseslint.parser,
+      parserOptions: {
+        project: true,
+      },
+    },
+    rules: {
+      ...commonRules,
+
+      "@typescript-eslint/require-await": "error",
+      "@typescript-eslint/await-thenable": "error",
+      "@typescript-eslint/return-await": ["error", "in-try-catch"],
+      "@typescript-eslint/no-floating-promises": "error",
+      "@typescript-eslint/no-shadow": "error",
+      "@typescript-eslint/no-unnecessary-condition": ["error", { allowConstantLoopConditions: true }],
+      "@typescript-eslint/no-unnecessary-type-assertion": "error",
+      // "@typescript-eslint/non-nullable-type-assertion-style": "error",
+      "@typescript-eslint/prefer-reduce-type-parameter": "error",
+      "@typescript-eslint/prefer-return-this-type": "error",
+      "@typescript-eslint/no-unused-expressions": "error",
+      "@typescript-eslint/strict-boolean-expressions": [
+        "error",
+        {
+          allowNullableBoolean: true,
+          allowNullableObject: true,
+        },
+      ],
+      "@typescript-eslint/ban-ts-comment": [
+        "error",
+        {
+          "ts-expect-error": "allow-with-description",
+          "minimumDescriptionLength": 3,
+        },
+      ],
+      "@typescript-eslint/prefer-readonly": "error",
+
+      // 실수 방지: void 콜백에 async 함수 전달 (에러 누락 방지)
+      // - arguments: false → socket.on("event", async () => {}) 허용 (내부 try-catch로 처리)
+      // - attributes: false → JSX 이벤트 핸들러 허용 (SolidJS 호환)
+      "@typescript-eslint/no-misused-promises": [
+        "error",
+        { checksVoidReturn: { arguments: false, attributes: false } },
+      ],
+      // 실수 방지: Error 아닌 것을 throw (스택 트레이스 손실 방지)
+      "@typescript-eslint/only-throw-error": "error",
+      // 실수 방지: 배열에 delete 사용 (희소 배열 버그 방지)
+      "@typescript-eslint/no-array-delete": "error",
+
+      "@simplysm/no-hard-private": "error",
+      "@simplysm/no-subpath-imports-from-simplysm": "error",
+      "@simplysm/ts-no-throw-not-implemented-error": "warn",
+
+      ...unusedImportsRules,
+      ...noNodeBuiltinsRules,
+
+      "import/no-extraneous-dependencies": [
+        "error",
+        {
+          devDependencies: [
+            "**/lib/**",
+            "**/eslint.config.ts",
+            "**/simplysm.ts",
+            "**/vitest.config.ts",
+            "**/vitest.setup.ts",
+          ],
+        },
+      ],
+    },
+  },
+  // 테스트 폴더: 루트 devDependencies(vitest 등) 사용 허용
+  {
+    files: ["**/tests/**/*.ts", "**/tests/**/*.tsx"],
+    rules: {
+      "no-console": "off",
+      "import/no-extraneous-dependencies": "off",
+      "@simplysm/ts-no-throw-not-implemented-error": "off",
+    },
+  },
+  // SolidJS TSX 파일: 모든 규칙 명시적으로 설정 (error)
+  {
+    files: ["**/*.ts", "**/*.tsx"],
+    plugins: {
+      solid: solidPlugin as unknown as ESLint.Plugin,
+      tailwindcss: tailwindcssPlugin as unknown as ESLint.Plugin,
+    },
+    settings: {
+      tailwindcss: {
+        // 템플릿 리터럴 태그 지원: clsx`py-0.5 px-1.5` 형태 인식
+        tags: ["clsx"],
+      },
+    },
+    rules: {
+      // ─── 실수 방지 ───
+      "solid/reactivity": ["error", { customReactiveFunctions: ["makePersisted"] }], // 반응성 손실 (가장 중요!)
+      "solid/no-destructure": "error", // props 구조분해 → 반응성 손실
+      "solid/components-return-once": "error", // early return → 버그
+      "solid/jsx-no-duplicate-props": "error", // 중복 props
+      "solid/jsx-no-undef": ["error", { typescriptEnabled: true }], // 정의 안 된 변수
+      "solid/no-react-deps": "error", // React 의존성 배열 실수
+      "solid/no-react-specific-props": "error", // React props 실수 (className 등)
+
+      // ─── 보안 ───
+      "solid/no-innerhtml": "error", // XSS 방지
+      "solid/jsx-no-script-url": "error", // javascript: URL 방지
+
+      // ─── 도구 지원 ───
+      "solid/jsx-uses-vars": "error", // unused import 오탐 방지
+
+      // ─── 컨벤션 ───
+      "solid/prefer-for": "error", // For 컴포넌트 권장
+      "solid/event-handlers": "error", // 이벤트 핸들러 네이밍
+      "solid/imports": "error", // import 일관성
+      "solid/style-prop": "error", // style prop 형식
+      "solid/self-closing-comp": "error", // 자체 닫기 태그
+
+      // ─── Tailwind CSS ───
+      "tailwindcss/classnames-order": "warn", // 클래스 순서 자동 정렬
+      "tailwindcss/enforces-negative-arbitrary-values": "error", // 음수 임의값 형식 통일
+      "tailwindcss/enforces-shorthand": "error", // 축약형 사용 권장
+      "tailwindcss/no-contradicting-classname": "error", // 충돌하는 클래스 금지 (p-2 p-4 등)
+      "tailwindcss/no-custom-classname": "error", // Tailwind에 없는 커스텀 클래스 금지
+      "tailwindcss/no-unnecessary-arbitrary-value": "error", // 불필요한 임의값 금지
+    },
+  },
+  // 테스트 폴더: solid/reactivity 비활성화
+  {
+    files: ["**/tests/**/*.ts", "**/tests/**/*.tsx"],
+    rules: {
+      // 테스트에서는 waitFor 등 비동기 콜백 내 signal 접근이 의도된 동작
+      "solid/reactivity": "off",
+    },
+  },
+]);

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

@@ -0,0 +1,136 @@
+import { AST_NODE_TYPES, type TSESTree } from "@typescript-eslint/utils";
+import type { RuleFix } from "@typescript-eslint/utils/ts-eslint";
+import { createRule } from "../utils/create-rule";
+
+type ClassMemberWithAccessibility = TSESTree.PropertyDefinition | TSESTree.MethodDefinition | TSESTree.AccessorProperty;
+
+function isClassMemberWithAccessibility(node: TSESTree.Node | undefined): node is ClassMemberWithAccessibility {
+  return (
+    node?.type === AST_NODE_TYPES.PropertyDefinition ||
+    node?.type === AST_NODE_TYPES.MethodDefinition ||
+    node?.type === AST_NODE_TYPES.AccessorProperty
+  );
+}
+
+/**
+ * ECMAScript private 필드(`#field`) 사용을 제한하고 TypeScript `private` 키워드 사용을 강제하는 ESLint 규칙
+ *
+ * @remarks
+ * 이 규칙은 다음을 검사한다:
+ * - 클래스 필드 선언: `#field`
+ * - 클래스 메서드 선언: `#method()`
+ * - 클래스 접근자 선언: `accessor #field`
+ * - 멤버 접근 표현식: `this.#field`
+ */
+export default createRule({
+  name: "no-hard-private",
+  meta: {
+    type: "problem",
+    docs: {
+      description: '하드 프라이빗 필드(#) 대신 TypeScript "private _" 스타일을 강제한다.',
+    },
+    messages: {
+      preferSoftPrivate: '하드 프라이빗 필드(#)는 허용되지 않습니다. "private _" 스타일을 사용하세요.',
+      nameConflict:
+        '하드 프라이빗 필드 "#{{name}}"을 "_{{name}}"으로 변환할 수 없습니다. 동일한 이름의 멤버가 이미 존재합니다.',
+    },
+    fixable: "code",
+    schema: [],
+  },
+  defaultOptions: [],
+  create(context) {
+    const sourceCode = context.sourceCode;
+    // 중첩 클래스 지원을 위한 스택 구조
+    const classStack: Set<string>[] = [];
+
+    return {
+      // 0. 클래스 진입 시 멤버 이름 수집
+      "ClassBody"(node: TSESTree.ClassBody) {
+        const memberNames = new Set<string>();
+        for (const member of node.body) {
+          if (!("key" in member)) continue;
+          const key = member.key;
+          if (key.type === AST_NODE_TYPES.Identifier) {
+            memberNames.add(key.name);
+          }
+        }
+        classStack.push(memberNames);
+      },
+
+      "ClassBody:exit"() {
+        classStack.pop();
+      },
+
+      // 1. 선언부 감지 (PropertyDefinition, MethodDefinition, AccessorProperty)
+      "PropertyDefinition > PrivateIdentifier, MethodDefinition > PrivateIdentifier, AccessorProperty > PrivateIdentifier"(
+        node: TSESTree.PrivateIdentifier,
+      ) {
+        const parent = node.parent;
+        if (!isClassMemberWithAccessibility(parent)) {
+          return;
+        }
+
+        const identifierName = node.name; // '#'을 제외한 이름
+        const targetName = `_${identifierName}`;
+        const currentClassMembers = classStack.at(-1);
+
+        // 이름 충돌 검사
+        if (currentClassMembers?.has(targetName)) {
+          context.report({
+            node,
+            messageId: "nameConflict",
+            data: { name: identifierName },
+          });
+          return;
+        }
+
+        context.report({
+          node,
+          messageId: "preferSoftPrivate",
+          fix(fixer) {
+            const fixes: RuleFix[] = [];
+
+            // 1-1. 이름 변경 (#a -> _a)
+            fixes.push(fixer.replaceText(node, targetName));
+
+            // 1-2. 'private' 접근 제어자 추가 위치 계산
+            if (parent.accessibility == null) {
+              // 기본 삽입 위치: 부모 노드의 시작 지점 (static, async 등 포함)
+              let tokenToInsertBefore = sourceCode.getFirstToken(parent);
+
+              // 데코레이터가 있다면, 마지막 데코레이터 '다음' 토큰 앞에 삽입
+              // (@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를 생략한다.
+              if (tokenToInsertBefore == null) {
+                return [];
+              }
+              fixes.push(fixer.insertTextBefore(tokenToInsertBefore, "private "));
+            }
+
+            return fixes;
+          },
+        });
+      },
+
+      // 2. 사용부 감지 (this.#field)
+      "MemberExpression > PrivateIdentifier"(node: TSESTree.PrivateIdentifier) {
+        const identifierName = node.name;
+        context.report({
+          node,
+          messageId: "preferSoftPrivate",
+          fix(fixer) {
+            return fixer.replaceText(node, `_${identifierName}`);
+          },
+        });
+      },
+    };
+  },
+});

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

@@ -0,0 +1,78 @@
+import { AST_NODE_TYPES, TSESTree } from "@typescript-eslint/utils";
+import { createRule } from "../utils/create-rule";
+
+/**
+ * `@simplysm/*` 패키지에서 'src' 서브경로 import를 금지하는 ESLint 규칙
+ *
+ * @remarks
+ * 이 규칙은 다음을 검사한다:
+ * - 정적 import 문: `import ... from '...'`
+ * - 동적 import: `import('...')`
+ * - re-export 문: `export { ... } from '...'`, `export * from '...'`
+ */
+export default createRule({
+  name: "no-subpath-imports-from-simplysm",
+  meta: {
+    type: "problem",
+    docs: {
+      description: "@simplysm 패키지에서 'src' 서브경로 import를 금지한다. (ex: @simplysm/pkg/src/x → 금지)",
+    },
+    fixable: "code",
+    schema: [],
+    messages: {
+      noSubpathImport: "'@simplysm/{{pkg}}' 패키지는 'src' 서브경로를 import할 수 없습니다: '{{importPath}}'",
+    },
+  },
+  defaultOptions: [],
+  create(context) {
+    function checkAndReport(sourceNode: TSESTree.StringLiteral, importPath: string) {
+      if (!importPath.startsWith("@simplysm/")) return;
+
+      const parts = importPath.split("/");
+
+      // 허용: @simplysm/pkg, @simplysm/pkg/xxx, @simplysm/pkg/xxx/yyy
+      // 금지: @simplysm/pkg/src, @simplysm/pkg/src/xxx
+      if (parts.length >= 3 && parts[2] === "src") {
+        const fixedPath = `@simplysm/${parts[1]}`;
+        context.report({
+          node: sourceNode,
+          messageId: "noSubpathImport",
+          data: {
+            pkg: parts[1],
+            importPath,
+          },
+          fix(fixer) {
+            const quote = sourceNode.raw[0];
+            return fixer.replaceText(sourceNode, `${quote}${fixedPath}${quote}`);
+          },
+        });
+      }
+    }
+
+    return {
+      // 정적 import: import { x } from '...'
+      ImportDeclaration(node) {
+        checkAndReport(node.source, node.source.value);
+      },
+
+      // 동적 import: import('...')
+      ImportExpression(node) {
+        if (node.source.type !== AST_NODE_TYPES.Literal) return;
+        const importPath = node.source.value;
+        if (typeof importPath !== "string") return;
+        checkAndReport(node.source, importPath);
+      },
+
+      // re-export: export { x } from '...'
+      ExportNamedDeclaration(node) {
+        if (!node.source) return;
+        checkAndReport(node.source, node.source.value);
+      },
+
+      // re-export all: export * from '...'
+      ExportAllDeclaration(node) {
+        checkAndReport(node.source, node.source.value);
+      },
+    };
+  },
+});

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

@@ -0,0 +1,103 @@
+import { AST_NODE_TYPES, ASTUtils, type TSESTree } from "@typescript-eslint/utils";
+import { createRule } from "../utils/create-rule";
+
+/**
+ * `@simplysm/core-common`의 `NotImplementedError` 사용을 감지하여 경고하는 ESLint 규칙
+ *
+ * @remarks
+ * 이 규칙은 `@simplysm/core-common`에서 import된 `NotImplementedError`를 `new`로 생성하는 코드를 감지한다.
+ * 미구현 코드가 프로덕션에 포함되는 것을 방지한다.
+ *
+ * 지원하는 import 형태:
+ * - 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(...)`)는 감지하지 않는다.
+ */
+export default createRule({
+  name: "ts-no-throw-not-implemented-error",
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "'NotImplementedError' 사용 경고",
+    },
+    schema: [],
+    messages: {
+      noThrowNotImplementedError: "{{text}}",
+    },
+  },
+  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
+     */
+    function isImportedFromSimplysm(
+      identifier: TSESTree.Identifier,
+      expectedImportedName: string | undefined,
+    ): boolean {
+      const scope = context.sourceCode.getScope(identifier);
+      const variable = ASTUtils.findVariable(scope, identifier.name);
+      if (!variable) return false;
+
+      for (const def of variable.defs) {
+        if (def.type !== "ImportBinding") continue;
+        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 }
+        if (def.node.type === AST_NODE_TYPES.ImportSpecifier && expectedImportedName != null) {
+          const imported = def.node.imported;
+          if (imported.type === AST_NODE_TYPES.Identifier && imported.name === expectedImportedName) {
+            return true;
+          }
+        }
+
+        // namespace import: import * as CC
+        if (def.node.type === AST_NODE_TYPES.ImportNamespaceSpecifier && expectedImportedName == null) {
+          return true;
+        }
+      }
+
+      return false;
+    }
+
+    return {
+      NewExpression(node: TSESTree.NewExpression) {
+        let shouldReport = false;
+
+        // Case 1: new NotImplementedError() 또는 new NIE() (named/aliased import)
+        if (node.callee.type === AST_NODE_TYPES.Identifier) {
+          shouldReport = isImportedFromSimplysm(node.callee, "NotImplementedError");
+        }
+
+        // Case 2: new CC.NotImplementedError() (namespace import)
+        else if (
+          node.callee.type === AST_NODE_TYPES.MemberExpression &&
+          node.callee.property.type === AST_NODE_TYPES.Identifier &&
+          node.callee.property.name === "NotImplementedError" &&
+          node.callee.object.type === AST_NODE_TYPES.Identifier
+        ) {
+          shouldReport = isImportedFromSimplysm(node.callee.object, undefined);
+        }
+
+        if (!shouldReport) return;
+
+        let msg = "미구현";
+        const firstArg = node.arguments.at(0);
+        if (firstArg?.type === AST_NODE_TYPES.Literal && typeof firstArg.value === "string" && firstArg.value !== "") {
+          msg = firstArg.value;
+        }
+
+        context.report({
+          node,
+          messageId: "noThrowNotImplementedError",
+          data: { text: msg },
+        });
+      },
+    };
+  },
+});