chore: commit remaining changes

Author: itpropro

.eslintrc.cjs

@@ -18,20 +18,14 @@ jobs:
           fetch-depth: 0
           token: ${{ secrets.TREE_STRUCTURE_TS_PAT }}
 
-      - uses: pnpm/action-setup@v2
+      - uses: oven-sh/setup-bun@v2
         with:
-          version: 7
+          bun-version: "1.3.8"
 
-      - uses: actions/setup-node@v3
-        with:
-          node-version: "16"
-          registry-url: "https://registry.npmjs.org"
-          cache: "pnpm"
-
-      - run: pnpm install
+      - run: bun install --frozen-lockfile
 
       - name: Build
-        run: pnpm run build
+        run: bun run build
 
       - name: Generate new tag version
         uses: mathieudutour/github-tag-action@v6.1

.github/workflows/ci.yml

@@ -14,30 +14,29 @@ jobs:
         with:
           fetch-depth: 0
 
-      - uses: pnpm/action-setup@v2
+      - uses: oven-sh/setup-bun@v2
         with:
-          version: 7
+          bun-version: "1.3.8"
 
       - uses: actions/setup-node@v3
         with:
           node-version: "16"
           registry-url: "https://registry.npmjs.org"
-          cache: "pnpm"
 
-      - run: pnpm install
+      - run: bun install --frozen-lockfile
 
       - name: Build
-        run: pnpm run build
+        run: bun run build
 
       - name: Bump version
         run: |
           git config --global user.email "jdamaschke@visorian.com"
           git config --global user.name "Jan-Henrik Damaschke"
-          pnpm dlx changelogithub
+          bunx changelogithub
         env:
           GITHUB_TOKEN: ${{secrets.GITHUB_TOKEN}}
 
       - name: Publish package
-        run: pnpm publish --no-git-checks
+        run: bun publish
         env:
           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

.github/workflows/release.yml

@@ -11,22 +11,16 @@ jobs:
     steps:
       - uses: actions/checkout@v3
 
-      - name: Setup pnpm
-        uses: pnpm/action-setup@v2
+      - name: Setup Bun
+        uses: oven-sh/setup-bun@v2
         with:
-          version: 7
+          bun-version: "1.3.8"
 
-      - name: Set node version to 16
-        uses: actions/setup-node@v3
-        with:
-          node-version: 16
-          cache: pnpm
-
-      - run: pnpm install
+      - run: bun install --frozen-lockfile
 
       - name: Run typecheck
-        run: pnpm run typecheck
+        run: bun run typecheck
 
       - name: Run tests
-        run: pnpm run test
-        
+        run: bun run test
+        

.github/workflows/test-build.yml

@@ -0,0 +1,67 @@
+{
+  "$schema": "./node_modules/oxlint/configuration_schema.json",
+  "ignorePatterns": [
+    "dist/**"
+  ],
+  "rules": {
+    "typescript/await-thenable": "error",
+    "typescript/consistent-return": "error",
+    "typescript/consistent-type-exports": "error",
+    "typescript/dot-notation": "error",
+    "typescript/no-array-delete": "error",
+    "typescript/no-base-to-string": "error",
+    "typescript/no-confusing-void-expression": "error",
+    "typescript/no-deprecated": "error",
+    "typescript/no-duplicate-type-constituents": "error",
+    "typescript/no-floating-promises": "error",
+    "typescript/no-for-in-array": "error",
+    "typescript/no-implied-eval": "error",
+    "typescript/no-meaningless-void-operator": "error",
+    "typescript/no-misused-promises": "error",
+    "typescript/no-misused-spread": "error",
+    "typescript/no-mixed-enums": "error",
+    "typescript/no-redundant-type-constituents": "error",
+    "typescript/no-unnecessary-boolean-literal-compare": "error",
+    "typescript/no-unnecessary-condition": "error",
+    "typescript/no-unnecessary-qualifier": "error",
+    "typescript/no-unnecessary-template-expression": "error",
+    "typescript/no-unnecessary-type-arguments": "error",
+    "typescript/no-unnecessary-type-assertion": "error",
+    "typescript/no-unnecessary-type-conversion": "error",
+    "typescript/no-unnecessary-type-parameters": "error",
+    "typescript/no-unsafe-argument": "error",
+    "typescript/no-unsafe-assignment": "error",
+    "typescript/no-unsafe-call": "error",
+    "typescript/no-unsafe-enum-comparison": "error",
+    "typescript/no-unsafe-member-access": "error",
+    "typescript/no-unsafe-return": "error",
+    "typescript/no-unsafe-type-assertion": "error",
+    "typescript/no-unsafe-unary-minus": "error",
+    "typescript/no-useless-default-assignment": "error",
+    "typescript/non-nullable-type-assertion-style": "error",
+    "typescript/only-throw-error": "error",
+    "typescript/prefer-find": "error",
+    "typescript/prefer-includes": "error",
+    "typescript/prefer-nullish-coalescing": "error",
+    "typescript/prefer-optional-chain": "error",
+    "typescript/prefer-promise-reject-errors": "error",
+    "typescript/prefer-readonly-parameter-types": "error",
+    "typescript/prefer-readonly": "error",
+    "typescript/prefer-reduce-type-parameter": "error",
+    "typescript/prefer-regexp-exec": "error",
+    "typescript/prefer-return-this-type": "error",
+    "typescript/prefer-string-starts-ends-with": "error",
+    "typescript/promise-function-async": "error",
+    "typescript/related-getter-setter-pairs": "error",
+    "typescript/require-array-sort-compare": "error",
+    "typescript/require-await": "error",
+    "typescript/restrict-plus-operands": "error",
+    "typescript/restrict-template-expressions": "error",
+    "typescript/return-await": "error",
+    "typescript/strict-boolean-expressions": "error",
+    "typescript/strict-void-return": "error",
+    "typescript/switch-exhaustiveness-check": "error",
+    "typescript/unbound-method": "error",
+    "typescript/use-unknown-in-catch-callback-variable": "error"
+  }
+}

.oxlintrc.json

@@ -2,13 +2,10 @@
   "vitest.enable": true,
   "prettier.enable": false,
   "editor.formatOnSave": false,
-  "editor.codeActionsOnSave": {
-    "source.fixAll.eslint": true
-  },
   "typescript.format.semicolons": "remove",
   "typescript.format.enable": true,
   "typescript.format.insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis": false,
   "typescript.format.insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets": false,
   "typescript.format.insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces": true,
-  "typescript.preferences.quoteStyle": "single",
-}
+  "typescript.preferences.quoteStyle": "single"
+}

.vscode/settings.json

@@ -0,0 +1,79 @@
+import { Tree } from "../src/Tree";
+import { TreeNode } from "../src/TreeNode";
+
+export type Traversal = "breadthFirst" | "depthFirst" | "preOrder" | "postOrder";
+
+export type DeepTreeFixture = {
+  tree: Tree<number>;
+  deepest: TreeNode<number>;
+};
+
+export const readPositiveInt = (name: string, fallback: number): number => {
+  const raw = process.env[name];
+  if (raw === undefined) return fallback;
+
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed) || parsed <= 0) {
+    throw new Error(`${name} must be a positive integer`);
+  }
+
+  return parsed;
+};
+
+export const assert = (condition: boolean, message: string): void => {
+  if (!condition) {
+    throw new Error(message);
+  }
+};
+
+export const buildDeepTree = (depth: number): DeepTreeFixture => {
+  const tree = new Tree(0);
+  let current = tree.root!;
+
+  for (let value = 1; value <= depth; value += 1) {
+    current = current.addChild(value);
+  }
+
+  return { tree, deepest: current };
+};
+
+export const expectedWideNodeCount = (branching: number, levels: number): number => {
+  let total = 0;
+  let levelWidth = 1;
+
+  for (let level = 0; level <= levels; level += 1) {
+    total += levelWidth;
+    levelWidth *= branching;
+  }
+
+  return total;
+};
+
+export const buildWideTree = (branching: number, levels: number): Tree<number> => {
+  const tree = new Tree(0);
+  let currentLevel = [tree.root!];
+  let value = 1;
+
+  for (let level = 0; level < levels; level += 1) {
+    const nextLevel: TreeNode<number>[] = [];
+
+    for (const node of currentLevel) {
+      for (let index = 0; index < branching; index += 1) {
+        nextLevel.push(node.addChild(value));
+        value += 1;
+      }
+    }
+
+    currentLevel = nextLevel;
+  }
+
+  return tree;
+};
+
+export const countTraversal = (tree: Tree<number>, mode: Traversal): number => {
+  let visited = 0;
+  tree.traverse(() => {
+    visited += 1;
+  }, mode);
+  return visited;
+};

benchmark/helpers.ts

@@ -0,0 +1,83 @@
+import { Tree } from "../src/Tree";
+import { TreeNode } from "../src/TreeNode";
+import {
+  assert,
+  buildDeepTree,
+  buildWideTree,
+  countTraversal,
+  expectedWideNodeCount,
+  readPositiveInt,
+} from "./helpers";
+
+const DEEP_DEPTH = readPositiveInt("DEEP_DEPTH", 250_000);
+const WIDE_BRANCHING = readPositiveInt("WIDE_BRANCHING", 12);
+const WIDE_LEVELS = readPositiveInt("WIDE_LEVELS", 5);
+
+const formatMs = (durationMs: number): string => durationMs.toFixed(2).padStart(10);
+
+const benchmark = <T>(name: string, fn: () => T): T => {
+  const start = performance.now();
+  const result = fn();
+  const end = performance.now();
+  const durationMs = end - start;
+  console.log(`${name.padEnd(36)} ${formatMs(durationMs)} ms`);
+  return result;
+};
+
+console.log("Huge Tree Benchmark");
+console.log(`DEEP_DEPTH=${DEEP_DEPTH}`);
+console.log(`WIDE_BRANCHING=${WIDE_BRANCHING}`);
+console.log(`WIDE_LEVELS=${WIDE_LEVELS}`);
+console.log("");
+
+let deepTree: Tree<number>;
+let deepLeaf: TreeNode<number>;
+
+benchmark("build deep tree", () => {
+  const built = buildDeepTree(DEEP_DEPTH);
+  deepTree = built.tree;
+  deepLeaf = built.deepest;
+});
+
+const deepNodeCount = DEEP_DEPTH + 1;
+
+const deepPath = benchmark("deep getPath", () => deepLeaf!.getPath());
+assert(deepPath.length === deepNodeCount, "deep getPath length mismatch");
+
+const deepAll = benchmark("deep all", () => deepTree!.all());
+assert(deepAll.length === DEEP_DEPTH, "deep all length mismatch");
+
+const deepBreadthFirstCount = benchmark("deep traverse breadthFirst", () => countTraversal(deepTree!, "breadthFirst"));
+assert(deepBreadthFirstCount === deepNodeCount, "deep breadthFirst count mismatch");
+
+const deepDepthFirstCount = benchmark("deep traverse depthFirst", () => countTraversal(deepTree!, "depthFirst"));
+assert(deepDepthFirstCount === deepNodeCount, "deep depthFirst count mismatch");
+
+const deepPreOrderCount = benchmark("deep traverse preOrder", () => countTraversal(deepTree!, "preOrder"));
+assert(deepPreOrderCount === deepNodeCount, "deep preOrder count mismatch");
+
+const deepPostOrderCount = benchmark("deep traverse postOrder", () => countTraversal(deepTree!, "postOrder"));
+assert(deepPostOrderCount === deepNodeCount, "deep postOrder count mismatch");
+
+let wideTree: Tree<number>;
+
+benchmark("build wide tree", () => {
+  wideTree = buildWideTree(WIDE_BRANCHING, WIDE_LEVELS);
+});
+
+const expectedWideNodes = expectedWideNodeCount(WIDE_BRANCHING, WIDE_LEVELS);
+
+console.log(`deepNodeCount=${deepNodeCount}`);
+console.log(`wideNodeCount=${expectedWideNodes}`);
+console.log("");
+
+const wideAll = benchmark("wide all", () => wideTree!.all());
+assert(wideAll.length === expectedWideNodes - 1, "wide all length mismatch");
+
+const wideBreadthFirstCount = benchmark("wide traverse breadthFirst", () => countTraversal(wideTree!, "breadthFirst"));
+assert(wideBreadthFirstCount === expectedWideNodes, "wide breadthFirst count mismatch");
+
+const widePostOrderCount = benchmark("wide traverse postOrder", () => countTraversal(wideTree!, "postOrder"));
+assert(widePostOrderCount === expectedWideNodes, "wide postOrder count mismatch");
+
+console.log("\nBenchmark completed successfully.");