@omermohideen/react-crap 1.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Omer Mohideen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,400 @@
+# react-crap
+
+[![npm](https://img.shields.io/npm/v/@omermohideen/react-crap?style=for-the-badge&logo=npm&logoColor=white)](https://www.npmjs.com/package/@omermohideen/react-crap)
+[![license](https://img.shields.io/badge/license-MIT-2563eb?style=for-the-badge)](LICENSE)
+
+Compute the **CRAP** (Change Risk Anti-Patterns) metric for React TypeScript projects.
+
+CRAP combines cyclomatic complexity and test coverage into a single number that is high when code is both hard to understand and poorly tested — i.e. where bugs love to hide. The metric was introduced by Savoia & Evans in 2007 and was originally implemented for Java (Crap4j) and .NET (NDepend). `react-crap` brings it to the TypeScript / React ecosystem.
+
+```
+CRAP(m) = comp(m)² × (1 − cov(m)/100)³ + comp(m)
+```
+
+A few properties worth internalizing before you use the output:
+
+- A trivial function (CC=1, 100% covered) scores exactly 1.0. That's the lower bound.
+- At 100% coverage the quadratic term collapses and **CRAP equals CC**. When you see matching values in those two columns, that function is fully covered — tests are capping the damage, but the complexity itself remains. It's a good sign, not a bug.
+- Above CC ≈ 30 no amount of coverage keeps you under the default threshold of 30. That's not a bug in the formula — it's the formula saying "this function is too big to certify as clean, regardless of tests."
+
+## Install
+
+**Via `npx`** (no install):
+
+```bash
+npx @omermohideen/react-crap --lcov coverage/lcov.info --path src
+```
+
+**Via `npm`** (global):
+
+```bash
+npm install -g @omermohideen/react-crap
+```
+
+**Via `npm`** (local dev dependency):
+
+```bash
+npm install --save-dev @omermohideen/react-crap
+```
+
+## Quick start
+
+```bash
+# 1. Generate an LCOV coverage report.
+npx vitest run --coverage
+
+# 2. Score every function.
+npx react-crap --lcov coverage/lcov.info --path src
+
+# 3. Gate CI on the threshold.
+npx react-crap --lcov coverage/lcov.info --fail-above
+
+# 4. Whole-workspace analysis (monorepos).
+npx react-crap --lcov coverage/lcov.info --path . --workspace --top 20
+
+# 5. Quick aggregate summary (no table).
+npx react-crap --lcov coverage/lcov.info --summary
+
+# 6. Watch mode during local development.
+npx react-crap --lcov coverage/lcov.info --path src --watch --verbose
+
+# 7. Generate an HTML report.
+npx react-crap --lcov coverage/lcov.info --path src --format html --output crap-report.html
+```
+
+Example output:
+
+```
+┌───┬───────┬────┬───────────────────┬──────────┬───────────────┐
+│   │  CRAP │ CC │ Coverage          │ Function │ Location      │
+╞═══╪═══════╪════╪═══════════════════╪══════════╪═══════════════╡
+│ ✗ │ 156.0 │ 12 │ ░░░░░░░░░░   0.0% │ crappy   │ src/lib.ts:24 │
+│ ▲ │   6.7 │  4 │ ████░░░░░░  44.4% │ moderate │ src/lib.ts:12 │
+│ ✓ │   1.0 │  1 │ ██████████ 100.0% │ trivial  │ src/lib.ts:8  │
+└───┴───────┴────┴───────────────────┴──────────┴───────────────┘
+✗ 1/3 function(s) exceed CRAP threshold 30.
+```
+
+## Flags
+
+| Flag | Default | Purpose |
+|------|---------|---------|
+| `--lcov <FILE>` | `coverage/lcov.info` | LCOV file from your test runner (Vitest, Jest, etc.). |
+| `--path <DIR>` | `src` | Root to walk for `.ts` / `.tsx` files (respects `.gitignore`). |
+| `--threshold <N>` | `30` | Score above which a function is flagged. |
+| `--min <SCORE>` | — | Hide entries **below** this CRAP score. |
+| `--max <SCORE>` | — | Hide entries **above** this CRAP score. |
+| `--top <N>` | — | Show only the **N worst** offenders. |
+| `--only-failures` | — | Only show functions **exceeding** the threshold. |
+| `--missing {pessimistic,optimistic,skip}` | `pessimistic` | How to score a function with no coverage data. |
+| `--exclude <GLOB>` | — | Skip files matching this pattern (repeatable). `**` crosses directories. |
+| `--allow <GLOB>` | — | Suppress matching functions (repeatable). An entry containing `/` or `**` is a path glob and matches the file the function is in (e.g. `src/generated/**`); otherwise it matches the function name and `*` is a wildcard (e.g. `use*`). |
+| `--format {human,json,github,markdown,html,pr-comment,sarif}` | `human` | Output format. `json` emits a versioned envelope (see [JSON output schema](#json-output-schema) below). `github` emits `::warning` annotations. `markdown` emits a GFM table (exhaustive). `html` emits a self-contained styled HTML page. `pr-comment` is the opinionated PR-bot variant: hides unchanged rows, caps each section, collapses non-critical info into `<details>` blocks. `sarif` emits SARIF 2.1.0 JSON for upload to GitHub Code Scanning, VS Code, and other static-analysis tooling (see [SARIF output](#sarif-output) below). |
+| `--summary` | off | Print only aggregate stats (total, crappy count, worst offender) — no per-function table. In `--workspace` mode this becomes the per-package summary plus the aggregate line. |
+| `--workspace` | off | Analyze all workspace packages (discovered via `package.json` workspaces or `pnpm-workspace.yaml`). Ignores `--path`. Adds a *Per-package summary* table to human and markdown output, and a `package` field to JSON entries. |
+| `--verbose` | off | Print step-by-step progress to stderr (file discovery, analysis progress, merge/scoring steps). |
+| `--watch` | off | Re-run automatically when source files or LCOV change. Uses 1-second polling. Press Ctrl+C to stop. |
+| `--fail-above` | off | Exit 1 if any function exceeds `--threshold`. |
+| `--baseline <FILE>` | — | JSON from a previous `--format json` run. Enables delta mode (shows Δ column). Functions that moved between files (same name, body unchanged) are detected and reported as `Moved` rather than as separate New + Removed entries; renderers show `← <previous_file>` next to the new location. |
+| `--fail-regression` | off | Exit 1 if any function's score increased since `--baseline`. `Moved` (pure relocation, no score change) is not a regression. |
+| `--epsilon <VALUE>` | `0.01` | Tolerance for the regression detector. Score deltas with absolute value at or below this count as `Unchanged`. Set to `0.0` to flag every increase, or higher to tolerate noisy coverage. Must be non-negative. |
+| `--jobs <N>` | host CPUs | Cap parallel source-file analysis at `N` threads. Useful in memory-constrained CI/Docker environments. Must be a positive integer. |
+| `--output <FILE>` | — | Write output to FILE instead of stdout (useful for saving JSON baselines). |
+| `--no-color` | — | Disable colored output. |
+
+### Filtering order
+
+Flags are applied in this order:
+
+1. `--min` — filter out low CRAP scores
+2. `--max` — filter out high CRAP scores
+3. `--only-failures` — keep only functions above threshold
+4. `--top` — slice to N worst remaining
+
+## Configuration file
+
+Any flag can be set persistently in `.react-crap.json` at the project root (or any parent directory — the tool walks up until it finds one). CLI flags always take precedence.
+
+```json
+{
+  "threshold": 30,
+  "top": 10,
+  "min": 10,
+  "max": 5000,
+  "onlyFailures": false,
+  "missing": "pessimistic",
+  "exclude": ["**/*.test.ts", "**/*.test.tsx"],
+  "allow": ["src/generated/**"],
+  "failAbove": true,
+  "workspace": false,
+  "verbose": false
+}
+```
+
+All keys are optional. Unknown keys are rejected to catch typos.
+
+## Inline annotations
+
+You can control individual functions directly in your source code with leading comments:
+
+```typescript
+// react-crap-ignore
+export function legacyHelper() {
+  // This function will be excluded from analysis entirely.
+}
+
+// @crap-threshold 50
+export function parser(input: string) {
+  // This function is allowed a higher threshold (50 instead of the global default).
+}
+```
+
+- `// react-crap-ignore` — excludes the next function from analysis
+- `// @crap-threshold N` — overrides the global threshold for the next function
+
+## Context-aware function naming
+
+Anonymous arrow functions and function expressions are resolved from their surrounding context, so you never see generic `<anonymous>` spam:
+
+| Pattern | Displayed name |
+|---------|----------------|
+| `return () => {}` | `handleAuthErrors return` |
+| `useEffect(() => {})` | `useEffect callback` |
+| `dedupePromise(() => {})` | `dedupePromise callback` |
+| `<Sheet>{() => ...}</Sheet>` | `Sheet child` |
+| `(async () => {})()` | `useEffect callback IIFE` |
+| `const dropSpec = () => () => {}` | `dropSpec nested` |
+
+If a name cannot be resolved, the tool walks up the AST to the nearest named parent function to provide useful context.
+
+## Caching
+
+Complexity analysis results are cached in `.react-crap-cache.json` (created next to `.react-crap.json`). Only files whose content has changed are re-analyzed. This makes repeated runs near-instant on large codebases. The cache is automatically invalidated when the file hash changes.
+
+## JSON output schema
+
+`--format json` produces a versioned envelope with a `$schema` URL pointing at the published JSON Schema. Consumers can validate output offline or generate types directly from the schema.
+
+| Variant | Schema |
+|---------|--------|
+| Absolute (no `--baseline`) | [`schemas/report-v1.json`](https://raw.githubusercontent.com/OmerMohideen/react-crap/master/schemas/report-v1.json) |
+| Delta (with `--baseline`) | [`schemas/delta-v2.json`](https://raw.githubusercontent.com/OmerMohideen/react-crap/master/schemas/delta-v2.json) |
+
+```json
+// react-crap --format json
+{
+  "$schema": "https://raw.githubusercontent.com/OmerMohideen/react-crap/master/schemas/report-v1.json",
+  "version": "0.1.0",
+  "entries": [
+    {
+      "file": "src/lib.ts",
+      "function": "doThing",
+      "line": 12,
+      "cyclomatic": 4,
+      "coverage": 75.0,
+      "crap": 5.6,
+      "package": "my-pkg"
+    }
+  ]
+}
+
+// react-crap --format json --baseline baseline.json
+{
+  "$schema": "https://raw.githubusercontent.com/OmerMohideen/react-crap/master/schemas/delta-v2.json",
+  "version": "0.1.0",
+  "entries": [],
+  "removed": []
+}
+```
+
+`--baseline` only reads files in this envelope shape; bare-array baselines from older runs must be regenerated.
+
+## SARIF output
+
+`--format sarif` emits a [SARIF 2.1.0](https://docs.oasis-open.org/sarif/sarif/v2.1.0/sarif-v2.1.0.html) JSON document — the format consumed by GitHub Code Scanning, VS Code, and most static-analysis tooling.
+
+- Each crappy function (entry above `--threshold`) becomes one `result` with `level: "warning"` and a physical location pointing at the function's start line.
+- Functions below the threshold are not included.
+- An empty result set still produces a valid SARIF document with the full `runs[0].tool.driver` envelope.
+- `--baseline` is rejected with `--format sarif`; SARIF describes findings, not deltas. Use `--format json` for delta output.
+
+## Design
+
+The tool has six orthogonal modules. Each is testable in isolation; the join between them has its own integration test.
+
+```
+  vitest --coverage                  typescript
+  (LCOV file)                      (TS AST)
+        │                              │
+        ▼                              ▼
+  ┌───────────┐                 ┌────────────┐
+  │ coverage  │                 │ complexity │
+  │  module   │                 │   module   │
+  └─────┬─────┘                 └──────┬─────┘
+        │                              │
+        └──────────┬───────────────────┘
+                   ▼
+             ┌──────────┐
+             │  merge   │  ← path normalization lives here
+             └─────┬────┘
+                   ▼
+             ┌──────────┐     ┌───────┐
+             │  score   │ ──▶ │ delta │  ← baseline comparison (optional)
+             └─────┬────┘     └───────┘
+                   ▼
+             ┌──────────┐
+             │  report  │  ← human / JSON / GitHub / Markdown
+             └──────────┘
+```
+
+### The path-matching problem
+
+This is where silent failures happen. Complexity analysis produces absolute paths (whatever was passed to the walker). LCOV files contain whatever the coverage tool decided to write:
+
+1. Absolute paths — `/home/alice/project/src/foo.ts`
+2. Project-relative paths — `src/foo.ts`
+3. Workspace-relative paths in a monorepo — `packages/core/src/foo.ts`
+4. Paths with `./` or `../` components
+
+A naïve `Map<string, _>` lookup silently returns `None` for 100% of files when the two don't agree, and every function reports as 0% covered. `react-crap` handles this with a two-level index:
+
+- Absolute coverage paths → direct canonical-path hash lookup.
+- Relative coverage paths → suffix match on path components (not bytes — `/foo/bar.ts` must not match `oofoo/bar.ts`).
+
+Relative paths are **never** canonicalized against the process's CWD, which would otherwise silently bind them to whatever file happened to exist under the tool's working directory.
+
+### The `--missing` policy
+
+Some functions have complexity data but no coverage data — the coverage tool didn't instrument them, or they were excluded via `test` files, or the coverage run was scoped to a subset of the workspace. Three policies:
+
+- **pessimistic** (default): treat as 0% covered. Surfaces unmapped code as a red flag. Correct for CI gates.
+- **optimistic**: treat as 100% covered. Useful during local development when you're iterating on a specific module.
+- **skip**: drop the row entirely.
+
+## Integrating with CI
+
+### Absolute threshold gate
+
+```yaml
+- run: npx vitest run --coverage
+- run: npx react-crap --lcov coverage/lcov.info --fail-above --threshold 30
+```
+
+### Regression gate (recommended for teams)
+
+Save a baseline on `master`, then fail on any PR that makes a score go up. This works regardless of the absolute threshold and catches regressions as they are introduced, not weeks later.
+
+```yaml
+# On master branch — upload baseline as a CI artifact
+- run: npx vitest run --coverage
+- run: npx react-crap --lcov coverage/lcov.info --format json --output baseline.json
+- uses: actions/upload-artifact@v4
+  with:
+    name: crap-baseline
+    path: baseline.json
+
+# On pull requests — download baseline and compare
+- uses: actions/download-artifact@v4
+  with:
+    name: crap-baseline
+    path: baseline
+- run: npx vitest run --coverage
+- run: npx react-crap --lcov coverage/lcov.info --baseline baseline/baseline.json --fail-regression
+```
+
+### GitHub Code Scanning (SARIF)
+
+Upload `--format sarif` output to surface crappy functions in the repository's **Security → Code scanning** tab. The job needs `security-events: write`.
+
+```yaml
+self_score:
+  permissions:
+    security-events: write
+  steps:
+    - run: npx vitest run --coverage
+    - run: npx react-crap --lcov coverage/lcov.info --format sarif --output crap.sarif
+    - uses: github/codeql-action/upload-sarif@v3
+      with:
+        sarif_file: crap.sarif
+        category: react-crap
+```
+
+### PR comment bot
+
+`--format pr-comment` produces a sticky comment that surfaces regressions and new functions in the primary table and tucks improvements / removed functions / above-threshold hot-spots into collapsed `<details>` blocks. A hidden marker (`<!-- react-crap-report -->`) lets the script update an existing comment instead of posting duplicates. The job needs `pull-requests: write`.
+
+```yaml
+self_score:
+  permissions:
+    pull-requests: write
+  steps:
+    # ...generate coverage and download baseline as above...
+
+    - name: Generate PR comment
+      if: github.event_name == 'pull_request'
+      run: |
+        npx react-crap \
+          --lcov coverage/lcov.info \
+          --baseline baseline.json \
+          --format pr-comment \
+          --output crap-comment.md
+
+    - name: Post or update PR comment
+      if: github.event_name == 'pull_request'
+      uses: actions/github-script@v7
+      with:
+        script: |
+          const fs = require('fs');
+          const body = fs.readFileSync('crap-comment.md', 'utf8');
+          const marker = '<!-- react-crap-report -->';
+          const { data: comments } = await github.rest.issues.listComments({
+            owner: context.repo.owner,
+            repo: context.repo.repo,
+            issue_number: context.issue.number,
+          });
+          const existing = comments.find(c => c.body.startsWith(marker));
+          const args = {
+            owner: context.repo.owner,
+            repo: context.repo.repo,
+            body,
+          };
+          if (existing) {
+            await github.rest.issues.updateComment({ ...args, comment_id: existing.id });
+          } else {
+            await github.rest.issues.createComment({ ...args, issue_number: context.issue.number });
+          }
+```
+
+## What this tool is not
+
+- It is not a replacement for engineering judgment.
+- It does not understand your business domain.
+- It does not prove that your tests are good.
+
+Coverage can execute a line without asserting the right behavior. A function can be fully covered and still poorly tested.
+
+So the CRAP score should not be treated as absolute truth. It is a signal — a useful one.
+
+The best use of the tool is to ask better questions:
+
+- Why is this function so complex?
+- Is this complexity essential or accidental?
+- Do the tests cover the important branches?
+- Can we split this into smaller pieces?
+- Should this logic be modeled more explicitly?
+
+Good tools do not replace thinking. They make thinking easier to focus.
+
+## Prior art and references
+
+- [Savoia, A. & Evans, B. (2007). *The CRAP Metric.*](https://www.artima.com/weblogs/viewpost.jsp?thread=210575)
+- [Crap4j](http://www.crap4j.org/) — the original Java implementation.
+- [cargo-crap](https://github.com/minikin/cargo-crap) — Rust implementation of the CRAP metric for Cargo projects by [minikin](https://minikin.me/blog/cargo-crap).
+
+## Contributing
+
+See [CONTRIBUTING.md](./CONTRIBUTING.md) for the commit convention, development setup, and release process.
+
+## License
+
+MIT

package/dist/bin/react-crap.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=react-crap.d.ts.map

package/dist/bin/react-crap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react-crap.d.ts","sourceRoot":"","sources":["../../bin/react-crap.ts"],"names":[],"mappings":""}

package/dist/bin/react-crap.js

@@ -0,0 +1,67 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const index_js_1 = require("../src/index.js");
+function collect(value, previous) {
+    return previous.concat([value]);
+}
+const program = new commander_1.Command();
+program
+    .name("react-crap")
+    .description("Change Risk Anti-Patterns (CRAP) metric for React TypeScript projects")
+    .version("0.1.0");
+program
+    .option("--lcov <file>", "LCOV coverage report file")
+    .option("--path <dir>", "Root directory to analyze", "src")
+    .option("--threshold <n>", "CRAP score threshold", "30")
+    .option("--min <score>", "Hide entries below this CRAP score")
+    .option("--max <score>", "Hide entries above this CRAP score")
+    .option("--top <n>", "Show only the N worst offenders")
+    .option("--only-failures", "Only show functions exceeding the CRAP threshold")
+    .option("--missing <policy>", "Missing coverage policy: pessimistic, optimistic, skip", "pessimistic")
+    .option("--exclude <glob>", "Skip files matching pattern (repeatable)", collect, [])
+    .option("--allow <glob>", "Suppress matching functions (repeatable)", collect, [])
+    .option("--format <fmt>", "Output format: human, json, github, markdown, pr-comment, sarif", "human")
+    .option("--summary", "Print only aggregate stats")
+    .option("--fail-above", "Exit 1 if any function exceeds threshold")
+    .option("--baseline <file>", "JSON baseline for delta comparison")
+    .option("--fail-regression", "Exit 1 if any score increased since baseline")
+    .option("--epsilon <value>", "Regression detector tolerance", "0.01")
+    .option("--jobs <n>", "Cap parallel analysis threads")
+    .option("--workspace", "Analyze all workspace packages")
+    .option("--verbose", "Print detailed progress information")
+    .option("--watch", "Re-run automatically when files change")
+    .option("--no-color", "Disable colored output")
+    .option("--output <file>", "Write output to file instead of stdout");
+program.parse();
+const options = program.opts();
+const noColor = options.noColor || !!process.env.NO_COLOR;
+(0, index_js_1.run)({
+    lcov: options.lcov,
+    path: options.path,
+    threshold: parseFloat(options.threshold),
+    min: options.min ? parseFloat(options.min) : undefined,
+    max: options.max ? parseFloat(options.max) : undefined,
+    top: options.top ? parseInt(options.top, 10) : undefined,
+    onlyFailures: options.onlyFailures ?? false,
+    missing: options.missing,
+    exclude: options.exclude,
+    allow: options.allow,
+    format: options.format,
+    summary: options.summary ?? false,
+    failAbove: options.failAbove ?? false,
+    baseline: options.baseline,
+    failRegression: options.failRegression ?? false,
+    epsilon: parseFloat(options.epsilon),
+    jobs: options.jobs ? parseInt(options.jobs, 10) : undefined,
+    workspace: options.workspace ?? false,
+    verbose: options.verbose ?? false,
+    watch: options.watch ?? false,
+    output: options.output,
+    noColor,
+}).catch((err) => {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+});
+//# sourceMappingURL=react-crap.js.map

package/dist/bin/react-crap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"react-crap.js","sourceRoot":"","sources":["../../bin/react-crap.ts"],"names":[],"mappings":"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"}

package/dist/src/cache.d.ts

@@ -0,0 +1,13 @@
+import type { ComplexityEntry } from "./complexity.js";
+export interface CacheEntry {
+    hash: string;
+    functions: ComplexityEntry[];
+}
+export interface Cache {
+    version: string;
+    files: Record<string, CacheEntry>;
+}
+export declare function loadCache(projectPath: string): Cache;
+export declare function saveCache(projectPath: string, cache: Cache): void;
+export declare function hashFile(content: string): string;
+//# sourceMappingURL=cache.d.ts.map

package/dist/src/cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.d.ts","sourceRoot":"","sources":["../../src/cache.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAEvD,MAAM,WAAW,UAAU;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,eAAe,EAAE,CAAC;CAC7B;AAED,MAAM,WAAW,KAAK;IACrB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;CAClC;AAKD,wBAAgB,SAAS,CAAC,WAAW,EAAE,MAAM,GAAG,KAAK,CAYpD;AAED,wBAAgB,SAAS,CAAC,WAAW,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,GAAG,IAAI,CAGjE;AAED,wBAAgB,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEhD"}

package/dist/src/cache.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadCache = loadCache;
+exports.saveCache = saveCache;
+exports.hashFile = hashFile;
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const CACHE_FILE = ".react-crap-cache.json";
+const CACHE_VERSION = "1";
+function loadCache(projectPath) {
+    const path = (0, node_path_1.resolve)(projectPath, CACHE_FILE);
+    if ((0, node_fs_1.existsSync)(path)) {
+        try {
+            const raw = (0, node_fs_1.readFileSync)(path, "utf-8");
+            const parsed = JSON.parse(raw);
+            if (parsed.version === CACHE_VERSION)
+                return parsed;
+        }
+        catch {
+            // invalid cache, ignore
+        }
+    }
+    return { version: CACHE_VERSION, files: {} };
+}
+function saveCache(projectPath, cache) {
+    const path = (0, node_path_1.resolve)(projectPath, CACHE_FILE);
+    (0, node_fs_1.writeFileSync)(path, JSON.stringify(cache, null, 2), "utf-8");
+}
+function hashFile(content) {
+    return (0, node_crypto_1.createHash)("sha256").update(content).digest("hex").slice(0, 16);
+}
+//# sourceMappingURL=cache.js.map

package/dist/src/cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache.js","sourceRoot":"","sources":["../../src/cache.ts"],"names":[],"mappings":";;AAkBA,8BAYC;AAED,8BAGC;AAED,4BAEC;AAvCD,6CAAyC;AACzC,qCAAkE;AAClE,yCAAoC;AAapC,MAAM,UAAU,GAAG,wBAAwB,CAAC;AAC5C,MAAM,aAAa,GAAG,GAAG,CAAC;AAE1B,SAAgB,SAAS,CAAC,WAAmB;IAC5C,MAAM,IAAI,GAAG,IAAA,mBAAO,EAAC,WAAW,EAAE,UAAU,CAAC,CAAC;IAC9C,IAAI,IAAA,oBAAU,EAAC,IAAI,CAAC,EAAE,CAAC;QACtB,IAAI,CAAC;YACJ,MAAM,GAAG,GAAG,IAAA,sBAAY,EAAC,IAAI,EAAE,OAAO,CAAC,CAAC;YACxC,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAU,CAAC;YACxC,IAAI,MAAM,CAAC,OAAO,KAAK,aAAa;gBAAE,OAAO,MAAM,CAAC;QACrD,CAAC;QAAC,MAAM,CAAC;YACR,wBAAwB;QACzB,CAAC;IACF,CAAC;IACD,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC;AAC9C,CAAC;AAED,SAAgB,SAAS,CAAC,WAAmB,EAAE,KAAY;IAC1D,MAAM,IAAI,GAAG,IAAA,mBAAO,EAAC,WAAW,EAAE,UAAU,CAAC,CAAC;IAC9C,IAAA,uBAAa,EAAC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC;AAC9D,CAAC;AAED,SAAgB,QAAQ,CAAC,OAAe;IACvC,OAAO,IAAA,wBAAU,EAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;AACxE,CAAC"}

package/dist/src/complexity.d.ts

@@ -0,0 +1,11 @@
+export interface ComplexityEntry {
+    file: string;
+    function: string;
+    line: number;
+    endLine: number;
+    cyclomatic: number;
+    bodyHash: string;
+    threshold?: number;
+}
+export declare function analyzeComplexity(files: string[], tsPath?: string, jobs?: number, onProgress?: (current: number, total: number, file: string) => void): Promise<ComplexityEntry[]>;
+//# sourceMappingURL=complexity.d.ts.map

package/dist/src/complexity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"complexity.d.ts","sourceRoot":"","sources":["../../src/complexity.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,eAAe;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,wBAAsB,iBAAiB,CACtC,KAAK,EAAE,MAAM,EAAE,EACf,MAAM,CAAC,EAAE,MAAM,EACf,IAAI,CAAC,EAAE,MAAM,EACb,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,GACjE,OAAO,CAAC,eAAe,EAAE,CAAC,CAqB5B"}