path-treeify 1.1.0 → 1.2.0-beta.67126e2

package/README.md

@@ -8,8 +8,8 @@
 </div>
 
 <div align="left">
-  <a href="https://github.com/isaaxite/path-treeify">
-    <img alt="GitHub package.json dynamic" src="https://img.shields.io/github/package-json/version/isaaxite/path-treeify?logo=github">
+  <a href="https://www.npmjs.com/package/path-treeify">
+    <img alt="NPM Version" src="https://img.shields.io/npm/v/path-treeify">
   </a>
   <a href="https://nodejs.org">
     <img alt="node" src="https://img.shields.io/node/v/path-treeify">
@@ -38,8 +38,9 @@
 - 🌲 Builds a recursive tree from one or more directory paths
 - 🔗 Each node carries a `parent` circular reference for upward traversal
 - 📍 Each node exposes a `getPath()` method to retrieve its own paths directly
-- 🔍 Optional `filter` callback to include/exclude directories during scanning
-- ⚡ `build()` method scans the entire `base` directory with zero configuration
+- 🔍 Optional `filter` callback applied at **every depth**, including top-level directories
+- ⚡ `build()` scans the entire `base` directory with zero configuration
+- 🎛️ `buildBy()` accepts either a directory name array or a top-level filter function
 - 📦 Ships as both ESM (`index.mjs`) and CJS (`index.cjs`) with full TypeScript types
 - 🚫 Zero runtime dependencies
 
@@ -70,8 +71,11 @@ import { PathTreeify } from 'path-treeify';
 
 const treeify = new PathTreeify({ base: '/your/project/root' });
 
-// Scan specific directories
-const tree = treeify.buildByDirNames(['src', 'tests']);
+// Scan specific directories by name
+const tree = treeify.buildBy(['src', 'tests']);
+
+// Scan with a top-level filter function
+const filtered = treeify.buildBy(name => name !== 'node_modules' && !name.startsWith('.'));
 
 // Or scan everything under base at once
 const fullTree = treeify.build();
@@ -85,10 +89,10 @@ const fullTree = treeify.build();
 
 Creates a new instance.
 
-| Option   | Type                          | Required | Description                                        |
-|----------|-------------------------------|----------|----------------------------------------------------|
-| `base`   | `string`                      | ✅        | Absolute path to the root directory to scan from  |
-| `filter` | `FilterFunction` (see below)  | ❌        | Called for every directory found during traversal  |
+| Option   | Type                          | Required | Description                                                                 |
+|----------|-------------------------------|----------|-----------------------------------------------------------------------------|
+| `base`   | `string`                      | ✅        | Absolute path to the root directory to scan from                           |
+| `filter` | `FilterFunction` (see below)  | ❌        | Applied at **every depth** — top-level directories included                |
 
 `base` must exist and be a directory, otherwise the constructor throws.
 
@@ -96,6 +100,8 @@ Creates a new instance.
 
 ### `FilterFunction`
 
+Used as the `filter` option in the constructor. Applied at every level of the tree, including the immediate children of `base`.
+
 ```ts
 type FilterFunction = (params: {
   name: string;    // directory name (leaf segment)
@@ -103,14 +109,14 @@ type FilterFunction = (params: {
 }) => boolean;
 ```
 
-Return `true` to **include** the directory and recurse into it; `false` to **skip** it.
+Return `true` to **include** the directory and recurse into it; `false` to **skip** it entirely.
 
-**Example — skip hidden directories and `node_modules`:**
+**Example — exclude `node_modules` and hidden directories at every depth:**
 
 ```ts
 const treeify = new PathTreeify({
   base: '/your/project',
-  filter: ({ name }) => !name.startsWith('.') && name !== 'node_modules',
+  filter: ({ name }) => name !== 'node_modules' && !name.startsWith('.'),
 });
 ```
 
@@ -118,7 +124,7 @@ const treeify = new PathTreeify({
 
 ### `build(): PathTreeNode`
 
-Scans **all** subdirectories directly under `base` and returns a synthetic root `PathTreeNode`. This is the zero-configuration alternative to `buildByDirNames`.
+Scans all subdirectories directly under `base` (applying the instance-level `filter` if set) and returns a synthetic root `PathTreeNode`.
 
 ```ts
 const tree = treeify.build();
@@ -126,17 +132,26 @@ const tree = treeify.build();
 
 ---
 
-### `buildByDirNames(dirNames: string[]): PathTreeNode`
+### `buildBy(dirNames: string[]): PathTreeNode`
 
-Scans the given relative directory names (resolved against `base`) and returns a synthetic root `PathTreeNode` whose `children` are the top-level nodes you requested.
+Builds a tree from the given list of directory names (relative to `base`).
 
 ```ts
-const root = treeify.buildByDirNames(['src', 'docs']);
+const tree = treeify.buildBy(['src', 'docs', 'tests']);
 ```
 
-- Each element must be a valid, accessible directory relative to `base`.
 - Leading and trailing slashes are stripped automatically.
-- Throws if any path does not exist or is not a directory.
+- Throws if any name does not resolve to a valid directory under `base`.
+
+### `buildBy(filter: (dirName: string) => boolean): PathTreeNode`
+
+Collects all top-level subdirectories under `base`, applies the given predicate to select which ones to include, then builds a tree from the matching names. The instance-level `filter` still applies during deep traversal.
+
+```ts
+const tree = treeify.buildBy(name => name !== 'node_modules' && !name.startsWith('.'));
+```
+
+> **Note:** the predicate passed to `buildBy(fn)` only selects which **top-level** directories to include. To filter directories at every depth, pass a `filter` to the constructor.
 
 ---
 
@@ -145,17 +160,16 @@ const root = treeify.buildByDirNames(['src', 'docs']);
 Walks a node's `parent` chain to reconstruct its full path. Equivalent to calling `node.getPath()` directly.
 
 ```ts
-const srcNode = root.children[0];
-const { relative, absolute } = treeify.getPathBy(srcNode);
-// relative → 'src'
-// absolute → '/your/project/src'
+const { relative, absolute } = treeify.getPathBy(node);
+// relative → e.g. 'src/components'
+// absolute → e.g. '/your/project/src/components'
 ```
 
 ---
 
 ### `PathTreeNode`
 
-`PathTreeNode` is now a **class** with its own `getPath()` method, so you can retrieve a node's path without passing it back to the `PathTreeify` instance.
+`PathTreeNode` is a **class** with its own `getPath()` method, so you can retrieve a node's path without passing it back to the `PathTreeify` instance.
 
 ```ts
 class PathTreeNode {
@@ -167,7 +181,7 @@ class PathTreeNode {
 }
 ```
 
-**`node.getPath()`** returns the same result as `treeify.getPathBy(node)` — both are available for convenience.
+`node.getPath()` returns the same result as `treeify.getPathBy(node)` — both are available for convenience.
 
 > ⚠️ **Circular references** — `parent` points back up the tree. Use `JSON.stringify` replacers or a library like `flatted` if you need to serialize the result.
 
@@ -180,18 +194,30 @@ class PathTreeNode {
 ```ts
 import { PathTreeify } from 'path-treeify';
 
+const treeify = new PathTreeify({ base: '/your/project' });
+const tree = treeify.build();
+```
+
+### Exclude directories at every depth via constructor filter
+
+```ts
 const treeify = new PathTreeify({
   base: '/your/project',
   filter: ({ name }) => name !== 'node_modules' && !name.startsWith('.'),
 });
-
 const tree = treeify.build();
 ```
 
 ### Scan specific directories
 
 ```ts
-const tree = treeify.buildByDirNames(['src', 'tests', 'docs']);
+const tree = treeify.buildBy(['src', 'tests', 'docs']);
+```
+
+### Select top-level directories with a predicate
+
+```ts
+const tree = treeify.buildBy(name => name !== 'node_modules' && !name.startsWith('.'));
 ```
 
 ### Retrieve paths via `node.getPath()`
@@ -221,4 +247,4 @@ const tree = treeify.build();
 
 ## License
 
-[MIT](https://github.com/isaaxite/path-treeify/blob/main/LICENSE) © [isaaxite](https://github.com/isaaxite)
+[MIT](https://github.com/isaaxite/path-treeify/blob/main/LICENSE) © [isaaxite](https://github.com/isaaxite)

package/dist/index.cjs

@@ -1,159 +1 @@
-'use strict';
-
-var fs = require('fs');
-var path = require('path');
-
-class PathValidator {
-    static isValid(path) {
-        try {
-            fs.accessSync(path, fs.constants.F_OK);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    static isDirectory(path) {
-        try {
-            return fs.statSync(path).isDirectory();
-        }
-        catch {
-            return false;
-        }
-    }
-}
-class PathTreeNode {
-    constructor(base) {
-        this.parent = null;
-        this.value = '';
-        this.children = [];
-        this.base = base;
-    }
-    getPath() {
-        let relative = '';
-        let current = this;
-        while (current.parent) {
-            relative = relative
-                ? `${current.value}${path.sep}${relative}`
-                : current.value;
-            current = current.parent;
-        }
-        return { relative, absolute: path.resolve(this.base, relative) };
-    }
-}
-class PathTreeify {
-    constructor({ filter, base }) {
-        if (typeof filter !== 'undefined') {
-            this.validateFilter(filter);
-            this.filter = filter;
-        }
-        if (!base || !PathValidator.isValid(base)) {
-            throw new Error(`${base} is not a valid path!`);
-        }
-        if (!PathValidator.isDirectory(base)) {
-            throw new Error(`${base} is not a dirPath!`);
-        }
-        this.base = base;
-    }
-    validateFilter(filter) {
-        if (typeof filter !== 'function') {
-            throw new TypeError('filter must be a function');
-        }
-        if (filter.length !== 1) {
-            throw new TypeError('filter must accept exactly one parameter');
-        }
-        try {
-            const testResult = filter({ name: 'test', postPath: '/test' });
-            if (typeof testResult !== 'boolean') {
-                throw new TypeError('filter must return a boolean');
-            }
-        }
-        catch (error) {
-            throw new TypeError('filter function threw an error during test: ' + error);
-        }
-    }
-    initNode(parent = null) {
-        const node = new PathTreeNode(this.base);
-        if (parent) {
-            node.parent = parent;
-        }
-        return node;
-    }
-    buildChildren(dirPath, parent) {
-        const names = fs.readdirSync(dirPath);
-        const children = [];
-        for (const name of names) {
-            const subPath = path.join(dirPath, name);
-            if (!fs.statSync(subPath).isDirectory()) {
-                continue;
-            }
-            if (this.filter && !this.filter({ dirPath, name })) {
-                continue;
-            }
-            const node = this.initNode();
-            node.value = name;
-            node.parent = parent;
-            node.children = this.buildChildren(subPath, node);
-            children.push(node);
-        }
-        return children;
-    }
-    checkRelativePaths(relativeDirNames) {
-        if (!Array.isArray(relativeDirNames)) {
-            throw new Error(`Expected array, got ${typeof relativeDirNames}`);
-        }
-        for (let i = 0; i < relativeDirNames.length; i++) {
-            const it = relativeDirNames[i];
-            if (typeof it !== 'string') {
-                throw new Error(`Item at index ${i} is not a string, got ${typeof it}`);
-            }
-            const absPath = path.resolve(this.base, it);
-            if (!PathValidator.isValid(absPath)) {
-                throw new Error(`Path does not exist or is not accessible: ${absPath} (from relative path: ${it})`);
-            }
-            if (!PathValidator.isDirectory(absPath)) {
-                throw new Error(`Path is not a directory: ${absPath} (from relative path: ${it})`);
-            }
-        }
-    }
-    formatDirnames(dirNames) {
-        return dirNames.map(dir => {
-            // Remove leading and trailing slashes
-            return dir.replace(/^\/+|\/+$/g, '');
-        }).filter(dir => dir !== ''); // Optional: filter empty strings
-    }
-    getPathBy(node) {
-        let relative = '';
-        let current = node;
-        while (current.parent) {
-            relative = relative
-                ? `${current.value}${path.sep}${relative}`
-                : current.value;
-            current = current.parent;
-        }
-        return { relative, absolute: path.resolve(this.base, relative) };
-    }
-    buildByDirNames(dirNames) {
-        const root = this.initNode();
-        this.checkRelativePaths(dirNames);
-        const dirNameArr = this.formatDirnames(dirNames);
-        for (const dirName of dirNameArr) {
-            const node = this.initNode();
-            node.value = dirName;
-            node.parent = root;
-            node.children = this.buildChildren(path.resolve(this.base, dirName), node);
-            root.children.push(node);
-        }
-        return root;
-    }
-    build() {
-        const dirNameArr = fs.readdirSync(this.base).filter(name => {
-            const abs = path.resolve(this.base, name);
-            return PathValidator.isDirectory(abs);
-        });
-        return this.buildByDirNames(dirNameArr);
-    }
-}
-
-exports.PathTreeify = PathTreeify;
-//# sourceMappingURL=index.cjs.map
+"use strict";var t=require("fs"),e=require("path");class r{static isValid(e){try{return t.accessSync(e,t.constants.F_OK),!0}catch{return!1}}static isDirectory(e){try{return t.statSync(e).isDirectory()}catch{return!1}}}class i{constructor(t){this.parent=null,this.value="",this.children=[],this.base=t}getPath(){let t="",r=this;for(;r.parent;)t=t?`${r.value}${e.sep}${t}`:r.value,r=r.parent;return{relative:t,absolute:e.resolve(this.base,t)}}}exports.PathTreeify=class{constructor({filter:t,base:e}){if(void 0!==t&&(this.validateFilter(t),this.filter=t),!e||!r.isValid(e))throw new Error(`${e} is not a valid path!`);if(!r.isDirectory(e))throw new Error(`${e} is not a dirPath!`);this.base=e}validateFilter(t){if("function"!=typeof t)throw new TypeError("filter must be a function");if(1!==t.length)throw new TypeError("filter must accept exactly one parameter");try{if("boolean"!=typeof t({name:"test",postPath:"/test"}))throw new TypeError("filter must return a boolean")}catch(t){throw new TypeError("filter function threw an error during test: "+t)}}initNode(t=null){const e=new i(this.base);return t&&(e.parent=t),e}buildChildren(r,i){const s=t.readdirSync(r),a=[];for(const n of s){const s=e.join(r,n);if(!t.statSync(s).isDirectory())continue;if(this.filter&&!this.filter({dirPath:r,name:n}))continue;const o=this.initNode();o.value=n,o.parent=i,o.children=this.buildChildren(s,o),a.push(o)}return a}checkRelativePaths(t){if(!Array.isArray(t))throw new Error("Expected array, got "+typeof t);for(let i=0;i<t.length;i++){const s=t[i];if("string"!=typeof s)throw new Error(`Item at index ${i} is not a string, got ${typeof s}`);const a=e.resolve(this.base,s);if(!r.isValid(a))throw new Error(`Path does not exist or is not accessible: ${a} (from relative path: ${s})`);if(!r.isDirectory(a))throw new Error(`Path is not a directory: ${a} (from relative path: ${s})`)}}formatDirnames(t){return t.map(t=>t.replace(/^\/+|\/+$/g,"")).filter(t=>""!==t)}getAllDirNamesUnderBase(){return t.readdirSync(this.base).filter(t=>{const i=e.resolve(this.base,t);return!!r.isDirectory(i)&&!(this.filter&&!this.filter({name:t,dirPath:this.base}))})}buildByDirNames(t){const r=this.initNode(),i=this.formatDirnames(t);this.checkRelativePaths(i);for(const t of i){const i=this.initNode();i.value=t,i.parent=r,i.children=this.buildChildren(e.resolve(this.base,t),i),r.children.push(i)}return r}buildByFilter(t){const e=this.getAllDirNamesUnderBase();return this.buildByDirNames(e.filter(t))}getPathBy(t){let r="",i=t;for(;i.parent;)r=r?`${i.value}${e.sep}${r}`:i.value,i=i.parent;return{relative:r,absolute:e.resolve(this.base,r)}}buildBy(t){if(Array.isArray(t))return this.buildByDirNames(t);if("function"==typeof t)return this.buildByFilter(t);throw new TypeError("buildBy: expected an array of strings or a filter function, but received "+typeof t)}build(){const t=this.getAllDirNamesUnderBase();return this.buildByDirNames(t)}};

package/dist/index.mjs

@@ -1,157 +1 @@
-import { readdirSync, statSync, accessSync, constants } from 'fs';
-import { join, resolve, sep } from 'path';
-
-class PathValidator {
-    static isValid(path) {
-        try {
-            accessSync(path, constants.F_OK);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    static isDirectory(path) {
-        try {
-            return statSync(path).isDirectory();
-        }
-        catch {
-            return false;
-        }
-    }
-}
-class PathTreeNode {
-    constructor(base) {
-        this.parent = null;
-        this.value = '';
-        this.children = [];
-        this.base = base;
-    }
-    getPath() {
-        let relative = '';
-        let current = this;
-        while (current.parent) {
-            relative = relative
-                ? `${current.value}${sep}${relative}`
-                : current.value;
-            current = current.parent;
-        }
-        return { relative, absolute: resolve(this.base, relative) };
-    }
-}
-class PathTreeify {
-    constructor({ filter, base }) {
-        if (typeof filter !== 'undefined') {
-            this.validateFilter(filter);
-            this.filter = filter;
-        }
-        if (!base || !PathValidator.isValid(base)) {
-            throw new Error(`${base} is not a valid path!`);
-        }
-        if (!PathValidator.isDirectory(base)) {
-            throw new Error(`${base} is not a dirPath!`);
-        }
-        this.base = base;
-    }
-    validateFilter(filter) {
-        if (typeof filter !== 'function') {
-            throw new TypeError('filter must be a function');
-        }
-        if (filter.length !== 1) {
-            throw new TypeError('filter must accept exactly one parameter');
-        }
-        try {
-            const testResult = filter({ name: 'test', postPath: '/test' });
-            if (typeof testResult !== 'boolean') {
-                throw new TypeError('filter must return a boolean');
-            }
-        }
-        catch (error) {
-            throw new TypeError('filter function threw an error during test: ' + error);
-        }
-    }
-    initNode(parent = null) {
-        const node = new PathTreeNode(this.base);
-        if (parent) {
-            node.parent = parent;
-        }
-        return node;
-    }
-    buildChildren(dirPath, parent) {
-        const names = readdirSync(dirPath);
-        const children = [];
-        for (const name of names) {
-            const subPath = join(dirPath, name);
-            if (!statSync(subPath).isDirectory()) {
-                continue;
-            }
-            if (this.filter && !this.filter({ dirPath, name })) {
-                continue;
-            }
-            const node = this.initNode();
-            node.value = name;
-            node.parent = parent;
-            node.children = this.buildChildren(subPath, node);
-            children.push(node);
-        }
-        return children;
-    }
-    checkRelativePaths(relativeDirNames) {
-        if (!Array.isArray(relativeDirNames)) {
-            throw new Error(`Expected array, got ${typeof relativeDirNames}`);
-        }
-        for (let i = 0; i < relativeDirNames.length; i++) {
-            const it = relativeDirNames[i];
-            if (typeof it !== 'string') {
-                throw new Error(`Item at index ${i} is not a string, got ${typeof it}`);
-            }
-            const absPath = resolve(this.base, it);
-            if (!PathValidator.isValid(absPath)) {
-                throw new Error(`Path does not exist or is not accessible: ${absPath} (from relative path: ${it})`);
-            }
-            if (!PathValidator.isDirectory(absPath)) {
-                throw new Error(`Path is not a directory: ${absPath} (from relative path: ${it})`);
-            }
-        }
-    }
-    formatDirnames(dirNames) {
-        return dirNames.map(dir => {
-            // Remove leading and trailing slashes
-            return dir.replace(/^\/+|\/+$/g, '');
-        }).filter(dir => dir !== ''); // Optional: filter empty strings
-    }
-    getPathBy(node) {
-        let relative = '';
-        let current = node;
-        while (current.parent) {
-            relative = relative
-                ? `${current.value}${sep}${relative}`
-                : current.value;
-            current = current.parent;
-        }
-        return { relative, absolute: resolve(this.base, relative) };
-    }
-    buildByDirNames(dirNames) {
-        const root = this.initNode();
-        this.checkRelativePaths(dirNames);
-        const dirNameArr = this.formatDirnames(dirNames);
-        for (const dirName of dirNameArr) {
-            const node = this.initNode();
-            node.value = dirName;
-            node.parent = root;
-            node.children = this.buildChildren(resolve(this.base, dirName), node);
-            root.children.push(node);
-        }
-        return root;
-    }
-    build() {
-        const dirNameArr = readdirSync(this.base).filter(name => {
-            const abs = resolve(this.base, name);
-            return PathValidator.isDirectory(abs);
-        });
-        return this.buildByDirNames(dirNameArr);
-    }
-}
-
-export { PathTreeify };
-//# sourceMappingURL=index.mjs.map
+import{readdirSync as t,statSync as r,accessSync as e,constants as i}from"fs";import{join as s,resolve as a,sep as n}from"path";class o{static isValid(t){try{return e(t,i.F_OK),!0}catch{return!1}}static isDirectory(t){try{return r(t).isDirectory()}catch{return!1}}}class l{constructor(t){this.parent=null,this.value="",this.children=[],this.base=t}getPath(){let t="",r=this;for(;r.parent;)t=t?`${r.value}${n}${t}`:r.value,r=r.parent;return{relative:t,absolute:a(this.base,t)}}}class h{constructor({filter:t,base:r}){if(void 0!==t&&(this.validateFilter(t),this.filter=t),!r||!o.isValid(r))throw new Error(`${r} is not a valid path!`);if(!o.isDirectory(r))throw new Error(`${r} is not a dirPath!`);this.base=r}validateFilter(t){if("function"!=typeof t)throw new TypeError("filter must be a function");if(1!==t.length)throw new TypeError("filter must accept exactly one parameter");try{if("boolean"!=typeof t({name:"test",postPath:"/test"}))throw new TypeError("filter must return a boolean")}catch(t){throw new TypeError("filter function threw an error during test: "+t)}}initNode(t=null){const r=new l(this.base);return t&&(r.parent=t),r}buildChildren(e,i){const a=t(e),n=[];for(const t of a){const a=s(e,t);if(!r(a).isDirectory())continue;if(this.filter&&!this.filter({dirPath:e,name:t}))continue;const o=this.initNode();o.value=t,o.parent=i,o.children=this.buildChildren(a,o),n.push(o)}return n}checkRelativePaths(t){if(!Array.isArray(t))throw new Error("Expected array, got "+typeof t);for(let r=0;r<t.length;r++){const e=t[r];if("string"!=typeof e)throw new Error(`Item at index ${r} is not a string, got ${typeof e}`);const i=a(this.base,e);if(!o.isValid(i))throw new Error(`Path does not exist or is not accessible: ${i} (from relative path: ${e})`);if(!o.isDirectory(i))throw new Error(`Path is not a directory: ${i} (from relative path: ${e})`)}}formatDirnames(t){return t.map(t=>t.replace(/^\/+|\/+$/g,"")).filter(t=>""!==t)}getAllDirNamesUnderBase(){return t(this.base).filter(t=>{const r=a(this.base,t);return!!o.isDirectory(r)&&!(this.filter&&!this.filter({name:t,dirPath:this.base}))})}buildByDirNames(t){const r=this.initNode(),e=this.formatDirnames(t);this.checkRelativePaths(e);for(const t of e){const e=this.initNode();e.value=t,e.parent=r,e.children=this.buildChildren(a(this.base,t),e),r.children.push(e)}return r}buildByFilter(t){const r=this.getAllDirNamesUnderBase();return this.buildByDirNames(r.filter(t))}getPathBy(t){let r="",e=t;for(;e.parent;)r=r?`${e.value}${n}${r}`:e.value,e=e.parent;return{relative:r,absolute:a(this.base,r)}}buildBy(t){if(Array.isArray(t))return this.buildByDirNames(t);if("function"==typeof t)return this.buildByFilter(t);throw new TypeError("buildBy: expected an array of strings or a filter function, but received "+typeof t)}build(){const t=this.getAllDirNamesUnderBase();return this.buildByDirNames(t)}}export{h as PathTreeify};

package/dist/types/index.d.ts

@@ -1,36 +1,93 @@
+/** A filter function that determines whether a directory should be included in the tree */
 type FilterFunction = (params: {
     name: string;
     dirPath: string;
 }) => boolean;
+/** Constructor options for PathTreeify */
 interface PathTreeifyProps {
     base: string;
     filter?: FilterFunction;
 }
+/** Represents a single node (directory) in the path tree */
 declare class PathTreeNode {
+    /** The root base path used to resolve absolute paths */
     private base;
+    /** Reference to the parent node; null for the root node */
     parent: PathTreeNode | null;
+    /** The directory name of this node (not a full path) */
     value: string;
+    /** Child nodes representing subdirectories */
     children: PathTreeNode[];
     constructor(base: string);
+    /**
+     * Walks up the parent chain to compute this node's relative and absolute paths.
+     * @returns An object containing the relative path from base and the absolute path
+     */
     getPath(): {
         relative: string;
         absolute: string;
     };
 }
+/** Builds a tree of directory nodes rooted at a given base path */
 export declare class PathTreeify {
+    /** The root directory to scan */
     private base;
+    /** Optional filter applied to each directory during traversal */
     private filter?;
     constructor({ filter, base }: Partial<PathTreeifyProps>);
+    /**
+     * Validates that the provided filter is a function, accepts one parameter,
+     * and returns a boolean. Throws a TypeError if any condition is violated.
+     */
     private validateFilter;
+    /**
+     * Creates and optionally attaches a new PathTreeNode to a parent.
+     * @param parent - The parent node to attach to, or null for the root
+     */
     private initNode;
+    /**
+     * Recursively reads a directory and builds child nodes for each subdirectory.
+     * Applies the instance-level filter if one is set.
+     * @param dirPath - Absolute path of the directory to read
+     * @param parent - The parent node to attach children to
+     */
     private buildChildren;
+    /**
+     * Validates that each entry in the array is a string pointing to
+     * an accessible directory relative to the base path.
+     * @param relativeDirNames - Array of relative directory path strings to validate
+     */
     private checkRelativePaths;
+    /**
+     * Strips leading and trailing slashes from each directory name
+     * and removes any resulting empty strings.
+     */
     private formatDirnames;
+    /** Returns the names of all immediate subdirectories under the base path */
+    private getAllDirNamesUnderBase;
+    /**
+     * Builds a tree rooted at base, containing only the specified subdirectories.
+     * @param dirNames - Relative directory names to include as top-level nodes
+     */
+    private buildByDirNames;
+    /**
+     * Builds a tree using only the subdirectories under base that pass the given filter.
+     * @param filter - A predicate applied to each top-level directory name
+     */
+    private buildByFilter;
+    /**
+     * Computes the relative and absolute paths for a given node
+     * by walking up the parent chain.
+     */
     getPathBy(node: PathTreeNode): {
         relative: string;
         absolute: string;
     };
-    buildByDirNames(dirNames: string[]): PathTreeNode;
+    /** Overload: build the tree from an explicit list of relative directory names */
+    buildBy(dirNames: string[]): PathTreeNode;
+    /** Overload: build the tree from a predicate applied to top-level directory names */
+    buildBy(filter: (dirName: string) => boolean): PathTreeNode;
+    /** Builds a full tree from all immediate subdirectories under the base path */
     build(): PathTreeNode;
 }
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "path-treeify",
-  "version": "1.1.0",
+  "version": "1.2.0-beta.67126e2",
   "description": "Convert a path or an array of paths into a tree-structured JavaScript object, where each node has a `parent` property that holds a circular reference to its parent node.",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
@@ -24,7 +24,8 @@
     "dist/**/*.d.ts"
   ],
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "ava",
+    "test:watch": "ava --watch",
     "clean": "rimraf ./dist",
     "build": "npm run clean && rollup -c",
     "build:dev": "NODE_ENV=development npm run build",
@@ -34,6 +35,14 @@
     "publish:beta": "npm publish --tag beta --access public",
     "publish:latest": "npm publish --tag latest --access public"
   },
+  "ava": {
+    "files": [
+      "tests/**/*.mjs"
+    ],
+    "nodeArguments": [
+      "--experimental-vm-modules"
+    ]
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/isaaxite/path-treeify.git"
@@ -62,6 +71,7 @@
     "@rollup/plugin-terser": "^1.0.0",
     "@rollup/plugin-typescript": "^12.3.0",
     "@types/node": "^25.5.0",
+    "ava": "^7.0.0",
     "nodemon": "^3.1.14",
     "rimraf": "^6.1.3",
     "rollup": "^4.59.0",