chore: bump to node@23 + remove ts-specific instructions

Author: simonrenoult

.nvmrc

@@ -1 +1 @@
-v18
+v23

package.json

@@ -6,6 +6,9 @@
     "name": "Simon Renoult",
     "email": "contact@simonrenoult.me"
   },
+  "engines": {
+    "node": "23"
+  },
   "main": "dist/src/lib",
   "types": "dist/src/lib/types.d.ts",
   "bin": {
@@ -55,7 +58,6 @@
     "@types/debug": "^4.1.7",
     "@types/micromatch": "^4.0.2",
     "@types/mocha": "^10.0.0",
-    "@types/node": "^18.11.9",
     "@typescript-eslint/eslint-plugin": "^5.42.1",
     "@typescript-eslint/parser": "^5.42.1",
     "chai": "^4.3.7",

src/io/index.ts

@@ -3,7 +3,7 @@ import { existsSync } from "node:fs";
 
 import Cli from "./cli";
 import { Options } from "../lib/types";
-import Output from "./output";
+import * as Output from "./output";
 import Statistics from "../lib";
 
 export default async function main(): Promise<void> {

src/io/output.ts

@@ -2,15 +2,7 @@ import * as Table from "cli-table3";
 import { IStatistic } from "../lib/statistics/statistic";
 import { Options } from "../lib/types";
 
-import { buildDebugger, withDuration } from "../utils";
-
-const internal = { debug: buildDebugger("output") };
-
-export default {
-  render: (...args: any[]): void => withDuration(render, args, internal.debug),
-};
-
-function render(statistics: IStatistic[], options: Options): void {
+export function render(statistics: IStatistic[], options: Options): void {
   let stdout;
   switch (options.format) {
     case "table":

src/lib/churn/churn.ts

@@ -1,20 +1,16 @@
-import { Path } from "../types";
-
 export default class Churn {
-  private path: Path;
-  private changes: number;
+  #changes: number;
 
-  constructor(path: Path) {
-    this.path = path;
-    this.changes = 0;
+  constructor() {
+    this.#changes = 0;
   }
 
-  public increment(): this {
-    this.changes += 1;
+  increment(): this {
+    this.#changes += 1;
     return this;
   }
 
-  public getValue(): number {
-    return this.changes;
+  getValue(): number {
+    return this.#changes;
   }
 }

src/lib/churn/churns.ts

@@ -1,36 +1,28 @@
 import { History } from "../githistory/githistory";
 
-import { Options, Path } from "../types";
+import { Path } from "../types";
 import Churn from "./churn";
 
-// FIXME: add commits
-
 export default class Churns {
-  private readonly churnByPath: Map<Path, Churn>;
-  private readonly options: Options;
-
-  public static from(history: History, options: Options) {
-    return new Churns(history, options);
-  }
+  #churnByPath: Map<Path, Churn>;
 
-  private constructor(history: History, options: Options) {
-    this.options = options;
-    this.churnByPath = this.computeChurnsPerFiles(history);
+  static from(history: History) {
+    return new Churns(history);
   }
 
-  public get files(): Path[] {
-    return [...this.churnByPath.keys()];
+  constructor(history: History) {
+    this.#churnByPath = this.#computeChurnsPerFiles(history);
   }
 
-  public getByPath(path: Path): Churn {
-    const churn = this.churnByPath.get(path);
+  getByPath(path: Path): Churn {
+    const churn = this.#churnByPath.get(path);
     if (!churn) {
       throw new Error("churn not found for path: " + path);
     }
     return churn;
   }
 
-  private computeChurnsPerFiles(history: History): Map<Path, Churn> {
+  #computeChurnsPerFiles(history: History): Map<Path, Churn> {
     return history.reduce((map: Map<Path, Churn>, path) => {
       if (map.has(path)) {
         const actualChurn = map.get(path);
@@ -40,7 +32,7 @@ export default class Churns {
           throw new Error("A churn should have existed for path: " + path);
         }
       } else {
-        const churn = new Churn(path).increment();
+        const churn = new Churn().increment();
         map.set(path, churn);
       }
       return map;

src/lib/complexity/complexities.ts

@@ -5,9 +5,9 @@ import Complexity from "./complexity";
 const internal = { debug: buildDebugger("complexity") };
 
 export default class Complexities {
-  private readonly complexityByPath: Map<Path, Complexity>;
+  #complexityByPath: Map<Path, Complexity>;
 
-  public static async computeFor(
+  static async computeFor(
     paths: Path[],
     options: Options
   ): Promise<Complexities> {
@@ -19,17 +19,17 @@ export default class Complexities {
     return new Complexities(complexities);
   }
 
-  public getByPath(path: Path): Complexity {
-    const complexity = this.complexityByPath.get(path);
-    if (!complexity) throw new Error("Complexity not found for path: " + path);
-    return complexity;
+  constructor(complexities: Complexity[]) {
+    this.#complexityByPath = this.#computeComplexitiesPerPath(complexities);
   }
 
-  private constructor(complexities: Complexity[]) {
-    this.complexityByPath = this.computeComplexitiesPerPath(complexities);
+  getByPath(path: Path): Complexity {
+    const complexity = this.#complexityByPath.get(path);
+    if (!complexity) throw new Error("Complexity not found for #path: " + path);
+    return complexity;
   }
 
-  private computeComplexitiesPerPath(complexities: Complexity[]) {
+  #computeComplexitiesPerPath(complexities: Complexity[]) {
     return complexities.reduce((map, complexity) => {
       map.set(complexity.path, complexity);
       return map;

src/lib/complexity/complexity.ts

@@ -1,24 +1,25 @@
+import { resolve } from "node:path";
 import { Options, Path } from "../types";
 import computeSloc from "./strategies/sloc";
 import { calculate as calculateCyclomatic } from "./strategies/cyclomatic";
 import { calculate as calculateHalstead } from "./strategies/halstead";
-import { resolve } from "node:path";
 import { UnsupportedExtension } from "../../utils";
 
-// FIXME: add modules
-
 export default class Complexity {
-  public static async compute(path: Path, options: Options) {
-    const complexity = await Complexity.computeComplexity(path, options);
+  path: Path;
+  complexity: number;
+
+  static async compute(path: Path, options: Options) {
+    const complexity = await Complexity.#computeComplexity(path, options);
     return new Complexity(path, complexity);
   }
 
-  private constructor(
-    public readonly path: Path,
-    public readonly complexity: number
-  ) {}
+  constructor(path: Path, complexity: number) {
+    this.complexity = complexity;
+    this.path = path;
+  }
 
-  private static async computeComplexity(
+  static async #computeComplexity(
     path: Path,
     options: Options
   ): Promise<number> {

src/lib/githistory/githistory.ts

@@ -1,44 +1,39 @@
-import * as micromatch from "micromatch";
 import { execSync } from "node:child_process";
 import { existsSync } from "node:fs";
 import { resolve } from "node:path";
+import * as micromatch from "micromatch";
 
 import { Options, Path } from "../types";
 
 export type History = Path[];
 
 export default class GitHistory {
-  private options: Options;
-
-  public readonly history: History;
-  public readonly files: Path[];
-
-  public static build(options: Options) {
-    return new GitHistory(options);
-  }
+  #options: Options;
+  history: History;
+  files: Path[];
 
-  private constructor(options: Options) {
-    this.options = options;
+  constructor(options: Options) {
+    this.#options = options;
 
-    this.history = this.buildHistory();
-    this.files = this.listFiles();
+    this.history = this.#buildHistory();
+    this.files = this.#listFiles();
   }
 
-  private buildGitLogCommand(): string {
+  #buildGitLogCommand(): string {
     const isWindows = process.platform === "win32";
 
     return [
       "git",
-      `-C ${this.options.directory}`,
+      `-C ${this.#options.directory}`,
       `log`,
       `--follow`,
 
       // Windows CMD handle quotes differently than linux, this is why we should put empty string as said in:
       // https://github.com/git-for-windows/git/issues/3131
       `--format=${isWindows ? "" : "''"}`,
       `--name-only`,
-      this.options.since ? `--since="${this.options.since}"` : "",
-      this.options.until ? `--until="${this.options.until}"` : "",
+      this.#options.since ? `--since="${this.#options.since}"` : "",
+      this.#options.until ? `--until="${this.#options.until}"` : "",
 
       // Windows CMD handle quotes differently
       isWindows ? "*" : "'*'",
@@ -47,42 +42,42 @@ export default class GitHistory {
       .join(" ");
   }
 
-  private buildHistory(): Path[] {
-    const gitLogCommand = this.buildGitLogCommand();
-    const stdout = this.executeGitLogCommand(gitLogCommand);
+  #buildHistory(): Path[] {
+    const gitLogCommand = this.#buildGitLogCommand();
+    const stdout = this.#executeGitLogCommand(gitLogCommand);
     return stdout
       .split("\n")
       .filter((line) => {
         if (line.trim().length === 0) {
           return false;
         }
-        if (!this.pathStillExists(line)) {
+        if (!this.#pathStillExists(line)) {
           return false;
         }
-        if (!this.filterMatches(line)) {
+        if (!this.#filterMatches(line)) {
           return false;
         }
         return true;
       })
       .sort();
   }
 
-  private executeGitLogCommand(gitLogCommand: string): string {
-    const maxBuffer = this.options.maxBuffer ?? 32_000_000;
+  #executeGitLogCommand(gitLogCommand: string): string {
+    const maxBuffer = this.#options.maxBuffer ?? 32_000_000;
     return execSync(gitLogCommand, { encoding: "utf8", maxBuffer });
   }
 
-  private listFiles(): string[] {
+  #listFiles(): string[] {
     return [...new Set(this.history)];
   }
 
-  private pathStillExists(fileName: string) {
-    return existsSync(resolve(this.options.directory, fileName));
+  #pathStillExists(fileName: string) {
+    return existsSync(resolve(this.#options.directory, fileName));
   }
 
-  private filterMatches(file: string) {
-    if (this.options.filter && this.options.filter.length) {
-      return this.options.filter.every((f) => micromatch.isMatch(file, f));
+  #filterMatches(file: string) {
+    if (this.#options.filter && this.#options.filter.length) {
+      return this.#options.filter.every((f) => micromatch.isMatch(file, f));
     }
     return true;
   }

src/lib/statistics/statistic.ts

@@ -10,26 +10,21 @@ export interface IStatistic {
 }
 
 export default class Statistic {
-  public readonly path: Path;
-  public readonly churn: number;
-  public readonly complexity: number;
-  public readonly score: number;
-
-  readonly directories: string[];
-
-  static build(path: Path, churn: number, complexity: number): Statistic {
-    return new Statistic(path, churn, complexity);
-  }
+  path: Path;
+  churn: number;
+  complexity: number;
+  score: number;
+  directories: string[];
 
-  private constructor(path: Path, churn: number, complexity: number) {
+  constructor(path: Path, churn: number, complexity: number) {
     this.path = path;
     this.churn = churn;
     this.complexity = complexity;
-    this.directories = this.findDirectoriesForFile(path);
+    this.directories = this.#findDirectoriesForFile(path);
     this.score = this.churn * this.complexity;
   }
 
-  private findDirectoriesForFile(path: string): string[] {
+  #findDirectoriesForFile(path: string): string[] {
     const directories: string[] = [];
     const pathChunks = NodePath.parse(path).dir.split(NodePath.sep);
     pathChunks.forEach((chunk) => {
@@ -42,7 +37,7 @@ export default class Statistic {
     return directories.filter((d) => d.length > 0);
   }
 
-  public toState(): IStatistic {
+  toState(): IStatistic {
     return {
       path: this.path,
       churn: this.churn,