path-treeify 1.4.0 → 1.4.1

package/README.md

@@ -27,7 +27,7 @@
     <img alt="GitHub Created At" src="https://img.shields.io/github/created-at/isaaxite/path-treeify">
   </a>
   <a href="https://github.com/isaaxite/path-treeify">
-    <img alt="GitHub code size in bytes" src="https://img.shields.io/github/languages/code-size/isaaxite/path-treeify">
+    <img alt="NPM Unpacked Size" src="https://img.shields.io/npm/unpacked-size/path-treeify">
   </a>
   <a href="https://github.com/isaaxite/path-treeify/commits/main/">
     <img alt="GitHub commit activity" src="https://img.shields.io/github/commit-activity/m/isaaxite/path-treeify">
@@ -215,9 +215,14 @@ An enum classifying each node's filesystem type.
 
 ```ts
 enum PathTreeNodeKind {
-  Dir     = 'dir',
-  File    = 'file',
-  Unknown = 'unknown', // assigned before the type is resolved
+  Dir               = 'dir',
+  File              = 'file',
+  Unknown           = 'unknown',            // assigned before the type is resolved
+  BrokenSymlink     = 'broken_symlink',
+  Other             = 'other',              // FIFO/socket etc.
+  NotFound          = 'not_found',
+  PermissionDenied  = 'permission_denied',
+  Error             = 'error',
 }
 ```
 

package/dist/index.cjs

@@ -1 +1 @@
-"use strict";var e,t=require("fs"),i=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}}static isFile(e){try{return t.statSync(e).isFile()}catch{return!1}}}exports.PathTreeNodeKind=void 0,(e=exports.PathTreeNodeKind||(exports.PathTreeNodeKind={})).Dir="dir",e.File="file",e.Unknown="unknown";class s{constructor(e){this.usePathCache=!1,this.base=e.base,"boolean"==typeof e.usePathCache&&(this.usePathCache=e.usePathCache)}getPath(){let e=this;const t=()=>{let t="",r=this;for(;r.parent;)t=t?`${r.value}${i.sep}${t}`:r.value,r=r.parent;return{relative:t,absolute:i.resolve(e.base,t)}};return e.usePathCache?(e._pathCache||(e._pathCache=t()),e._pathCache):t()}}exports.PathTreeify=class{constructor(e){this.fileVisible=!1;const{filter:t,base:i,fileVisible:n,usePathCache:a}=e;if("boolean"==typeof n&&n&&(this.fileVisible=n),void 0!==t&&(this.validateFilter(t),this.userFilter=t),!i||!r.isValid(i))throw new Error(`${i} is not a valid path!`);if(!r.isDirectory(i))throw new Error(`${i} is not a dirPath!`);this.base=i,this.pathTreeNodeShared=new s({base:i,usePathCache:a})}applyFilter(e,t){return!(!this.fileVisible&&!r.isDirectory(e))&&(!this.userFilter||this.userFilter({name:t,dirPath:i.dirname(e)}))}validateFilter(e){if("function"!=typeof e)throw new TypeError("filter must be a function")}initNode(){const e=Object.create(this.pathTreeNodeShared),t=Object.create(e);return t.parent=null,t.value="",t.children=[],t.type=exports.PathTreeNodeKind.Unknown,t.depth=-1,t}buildChildren(e,s,n){const a=[],o=n||t.readdirSync(e),h=s.depth+1;for(const t of o){const n=i.join(e,t);if(!this.applyFilter(n,t))continue;const o=this.initNode();o.depth=h,o.value=t,o.parent=s,a.push(o),this.fileVisible&&r.isFile(n)?o.type=exports.PathTreeNodeKind.File:(o.type=exports.PathTreeNodeKind.Dir,o.children=this.buildChildren(n,o))}return a}checkRelativePaths(e){for(let t=0;t<e.length;t++){const s=e[t];if("string"!=typeof s)throw new Error(`Item at index ${t} is not a string, got ${typeof s}`);const n=i.resolve(this.base,s);if(!r.isValid(n))throw new Error(`Path does not exist or is not accessible: ${n} (from relative path: ${s})`);if(!(r.isDirectory(n)||this.fileVisible&&r.isFile(n)))throw new Error(`Path is not a directory: ${n} (from relative path: ${s})`)}}formatSegments(e){return e.map(e=>e.split(/[/\\]/).filter(Boolean).join(i.sep)).filter(Boolean)}getAllEntriesUnderBase(){return t.readdirSync(this.base).filter(e=>{const t=i.resolve(this.base,e);return this.applyFilter(t,e)})}buildBySegments(e){const t=this.initNode();return t.depth=0,t.children=this.buildChildren(this.base,t,e),t}buildByFilter(e){const t=this.getAllEntriesUnderBase();return this.buildBySegments(t.filter(e))}buildBy(e){if(Array.isArray(e)){const t=this.formatSegments(e);return this.checkRelativePaths(t),this.buildBySegments(t)}if("function"==typeof e)return this.buildByFilter(e);throw new TypeError("buildBy: expected an array of strings or a filter function, but received "+typeof e)}build(){const e=this.getAllEntriesUnderBase();return this.buildBySegments(e)}};
+"use strict";var e,t=require("fs"),r=require("path");function i(e,t){for(const r in t)Object.defineProperty(e,r,{value:t[r],writable:!1,configurable:!1,enumerable:!1})}function n(e){try{return function(e){try{const r=t.statSync(e);if(r.isDirectory()){try{t.accessSync(e,t.constants.X_OK)}catch{return exports.PathTreeNodeKind.PermissionDenied}return exports.PathTreeNodeKind.Dir}return r.isFile()?exports.PathTreeNodeKind.File:exports.PathTreeNodeKind.Other}catch(e){const t=e.code;if("EACCES"===t)return exports.PathTreeNodeKind.PermissionDenied;if("ENOENT"!==t)throw e}try{return t.lstatSync(e).isSymbolicLink()?exports.PathTreeNodeKind.BrokenSymlink:exports.PathTreeNodeKind.Other}catch(e){const t=e.code;if("EACCES"===t)return exports.PathTreeNodeKind.PermissionDenied;if("ENOENT"!==t)throw e}return exports.PathTreeNodeKind.NotFound}(e)}catch(e){return exports.PathTreeNodeKind.Error}}exports.PathTreeNodeKind=void 0,(e=exports.PathTreeNodeKind||(exports.PathTreeNodeKind={})).Dir="dir",e.File="file",e.Unknown="unknown",e.BrokenSymlink="broken_symlink",e.Other="other",e.NotFound="not_found",e.PermissionDenied="permission_denied",e.Error="error";class s{constructor(e){this.depth=-1,this.parent=null,this.value="",this.children=[],this.type=exports.PathTreeNodeKind.Unknown,i(this,{_usePathCache:e.usePathCache})}getPath(){let e=this,t="";const n=()=>{let e="",i=this;for(;;){if(null===i.parent){t=i.value;break}e=e?`${i.value}${r.sep}${e}`:i.value,i=i.parent}return{relative:e,absolute:r.resolve(t,e)}};return e._usePathCache?(e._pathCache||i(this,{_pathCache:n()}),e._pathCache):n()}}exports.PathTreeify=class{constructor(e){this._base="",this._fileVisible=!1,this._usePathCache=!1;const{filter:t,base:r,fileVisible:s,usePathCache:o}=e,a=n(r||"");if(void 0!==t&&(this.validateFilter(t),i(this,{_userFilter:t})),a!==exports.PathTreeNodeKind.Dir)throw new Error(`${r} not a valid dirPath!`);i(this,{_usePathCache:Boolean(o),_base:r,_fileVisible:!("boolean"!=typeof s||!s)&&s})}applyFilter(e,t){return!(!this._fileVisible&&n(e)!==exports.PathTreeNodeKind.Dir)&&(!this._userFilter||this._userFilter({name:t,dirPath:r.dirname(e)}))}validateFilter(e){if("function"!=typeof e)throw new TypeError("filter must be a function")}initNode(){return new s({usePathCache:this._usePathCache})}buildChildren(e,i,s){const o=[],a=i.depth+1,h=s||t.readdirSync(e);for(const t of h){const s=r.join(e,t);if(!this.applyFilter(s,t))continue;const h=n(s),d=this.initNode();d.depth=a,d.value=t,d.parent=i,o.push(d),this._fileVisible&&h===exports.PathTreeNodeKind.File?d.type=h:h===exports.PathTreeNodeKind.Dir?(d.type=h,d.children=this.buildChildren(s,d)):d.type=h}return o}checkRelativePaths(e){for(let t=0;t<e.length;t++){const i=e[t];if("string"!=typeof i)throw new Error(`Item at index ${t} is not a string, got ${typeof i}`);const s=r.resolve(this._base,i),o=n(s);if([exports.PathTreeNodeKind.NotFound,exports.PathTreeNodeKind.PermissionDenied,exports.PathTreeNodeKind.Other,exports.PathTreeNodeKind.Error,exports.PathTreeNodeKind.BrokenSymlink].includes(o))throw new Error(`Path does not exist or is not accessible: ${s} (from relative path: ${i})`);if(o!==exports.PathTreeNodeKind.Dir&&(!this._fileVisible||o!==exports.PathTreeNodeKind.File))throw new Error(`Path is not a directory: ${s} (from relative path: ${i})`)}}formatSegments(e){return e.map(e=>e.split(/[/\\]/).filter(Boolean).join(r.sep)).filter(Boolean)}getAllEntriesUnderBase(){return t.readdirSync(this._base).filter(e=>{const t=r.resolve(this._base,e);return this.applyFilter(t,e)})}buildBySegments(e){const t=this.initNode();return t.depth=0,t.value=this._base,t.type=exports.PathTreeNodeKind.Dir,t.children=this.buildChildren(this._base,t,e),t}buildByFilter(e){const t=this.getAllEntriesUnderBase();return this.buildBySegments(t.filter(e))}buildBy(e){if(Array.isArray(e)){const t=this.formatSegments(e);return this.checkRelativePaths(t),this.buildBySegments(t)}if("function"==typeof e)return this.buildByFilter(e);throw new TypeError("buildBy: expected an array of strings or a filter function, but received "+typeof e)}build(){const e=this.getAllEntriesUnderBase();return this.buildBySegments(e)}};

package/dist/index.mjs

@@ -1 +1 @@
-import{readdirSync as t,accessSync as e,constants as i,statSync as r}from"fs";import{dirname as s,join as n,resolve as a,sep as h}from"path";class l{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}}static isFile(t){try{return r(t).isFile()}catch{return!1}}}var o;!function(t){t.Dir="dir",t.File="file",t.Unknown="unknown"}(o||(o={}));class c{constructor(t){this.usePathCache=!1,this.base=t.base,"boolean"==typeof t.usePathCache&&(this.usePathCache=t.usePathCache)}getPath(){let t=this;const e=()=>{let e="",i=this;for(;i.parent;)e=e?`${i.value}${h}${e}`:i.value,i=i.parent;return{relative:e,absolute:a(t.base,e)}};return t.usePathCache?(t._pathCache||(t._pathCache=e()),t._pathCache):e()}}class u{constructor(t){this.fileVisible=!1;const{filter:e,base:i,fileVisible:r,usePathCache:s}=t;if("boolean"==typeof r&&r&&(this.fileVisible=r),void 0!==e&&(this.validateFilter(e),this.userFilter=e),!i||!l.isValid(i))throw new Error(`${i} is not a valid path!`);if(!l.isDirectory(i))throw new Error(`${i} is not a dirPath!`);this.base=i,this.pathTreeNodeShared=new c({base:i,usePathCache:s})}applyFilter(t,e){return!(!this.fileVisible&&!l.isDirectory(t))&&(!this.userFilter||this.userFilter({name:e,dirPath:s(t)}))}validateFilter(t){if("function"!=typeof t)throw new TypeError("filter must be a function")}initNode(){const t=Object.create(this.pathTreeNodeShared),e=Object.create(t);return e.parent=null,e.value="",e.children=[],e.type=o.Unknown,e.depth=-1,e}buildChildren(e,i,r){const s=[],a=r||t(e),h=i.depth+1;for(const t of a){const r=n(e,t);if(!this.applyFilter(r,t))continue;const a=this.initNode();a.depth=h,a.value=t,a.parent=i,s.push(a),this.fileVisible&&l.isFile(r)?a.type=o.File:(a.type=o.Dir,a.children=this.buildChildren(r,a))}return s}checkRelativePaths(t){for(let e=0;e<t.length;e++){const i=t[e];if("string"!=typeof i)throw new Error(`Item at index ${e} is not a string, got ${typeof i}`);const r=a(this.base,i);if(!l.isValid(r))throw new Error(`Path does not exist or is not accessible: ${r} (from relative path: ${i})`);if(!(l.isDirectory(r)||this.fileVisible&&l.isFile(r)))throw new Error(`Path is not a directory: ${r} (from relative path: ${i})`)}}formatSegments(t){return t.map(t=>t.split(/[/\\]/).filter(Boolean).join(h)).filter(Boolean)}getAllEntriesUnderBase(){return t(this.base).filter(t=>{const e=a(this.base,t);return this.applyFilter(e,t)})}buildBySegments(t){const e=this.initNode();return e.depth=0,e.children=this.buildChildren(this.base,e,t),e}buildByFilter(t){const e=this.getAllEntriesUnderBase();return this.buildBySegments(e.filter(t))}buildBy(t){if(Array.isArray(t)){const e=this.formatSegments(t);return this.checkRelativePaths(e),this.buildBySegments(e)}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.getAllEntriesUnderBase();return this.buildBySegments(t)}}export{o as PathTreeNodeKind,u as PathTreeify};
+import{statSync as e,accessSync as t,constants as i,lstatSync as r,readdirSync as n}from"fs";import{sep as s,resolve as o,dirname as h,join as l}from"path";var a;function u(e,t){for(const i in t)Object.defineProperty(e,i,{value:t[i],writable:!1,configurable:!1,enumerable:!1})}function c(n){try{return function(n){try{const r=e(n);if(r.isDirectory()){try{t(n,i.X_OK)}catch{return a.PermissionDenied}return a.Dir}return r.isFile()?a.File:a.Other}catch(e){const t=e.code;if("EACCES"===t)return a.PermissionDenied;if("ENOENT"!==t)throw e}try{return r(n).isSymbolicLink()?a.BrokenSymlink:a.Other}catch(e){const t=e.code;if("EACCES"===t)return a.PermissionDenied;if("ENOENT"!==t)throw e}return a.NotFound}(n)}catch(e){return a.Error}}!function(e){e.Dir="dir",e.File="file",e.Unknown="unknown",e.BrokenSymlink="broken_symlink",e.Other="other",e.NotFound="not_found",e.PermissionDenied="permission_denied",e.Error="error"}(a||(a={}));class f{constructor(e){this.depth=-1,this.parent=null,this.value="",this.children=[],this.type=a.Unknown,u(this,{_usePathCache:e.usePathCache})}getPath(){let e=this,t="";const i=()=>{let e="",i=this;for(;;){if(null===i.parent){t=i.value;break}e=e?`${i.value}${s}${e}`:i.value,i=i.parent}return{relative:e,absolute:o(t,e)}};return e._usePathCache?(e._pathCache||u(this,{_pathCache:i()}),e._pathCache):i()}}class d{constructor(e){this._base="",this._fileVisible=!1,this._usePathCache=!1;const{filter:t,base:i,fileVisible:r,usePathCache:n}=e,s=c(i||"");if(void 0!==t&&(this.validateFilter(t),u(this,{_userFilter:t})),s!==a.Dir)throw new Error(`${i} not a valid dirPath!`);u(this,{_usePathCache:Boolean(n),_base:i,_fileVisible:!("boolean"!=typeof r||!r)&&r})}applyFilter(e,t){return!(!this._fileVisible&&c(e)!==a.Dir)&&(!this._userFilter||this._userFilter({name:t,dirPath:h(e)}))}validateFilter(e){if("function"!=typeof e)throw new TypeError("filter must be a function")}initNode(){return new f({usePathCache:this._usePathCache})}buildChildren(e,t,i){const r=[],s=t.depth+1,o=i||n(e);for(const i of o){const n=l(e,i);if(!this.applyFilter(n,i))continue;const o=c(n),h=this.initNode();h.depth=s,h.value=i,h.parent=t,r.push(h),this._fileVisible&&o===a.File?h.type=o:o===a.Dir?(h.type=o,h.children=this.buildChildren(n,h)):h.type=o}return r}checkRelativePaths(e){for(let t=0;t<e.length;t++){const i=e[t];if("string"!=typeof i)throw new Error(`Item at index ${t} is not a string, got ${typeof i}`);const r=o(this._base,i),n=c(r);if([a.NotFound,a.PermissionDenied,a.Other,a.Error,a.BrokenSymlink].includes(n))throw new Error(`Path does not exist or is not accessible: ${r} (from relative path: ${i})`);if(n!==a.Dir&&(!this._fileVisible||n!==a.File))throw new Error(`Path is not a directory: ${r} (from relative path: ${i})`)}}formatSegments(e){return e.map(e=>e.split(/[/\\]/).filter(Boolean).join(s)).filter(Boolean)}getAllEntriesUnderBase(){return n(this._base).filter(e=>{const t=o(this._base,e);return this.applyFilter(t,e)})}buildBySegments(e){const t=this.initNode();return t.depth=0,t.value=this._base,t.type=a.Dir,t.children=this.buildChildren(this._base,t,e),t}buildByFilter(e){const t=this.getAllEntriesUnderBase();return this.buildBySegments(t.filter(e))}buildBy(e){if(Array.isArray(e)){const t=this.formatSegments(e);return this.checkRelativePaths(t),this.buildBySegments(t)}if("function"==typeof e)return this.buildByFilter(e);throw new TypeError("buildBy: expected an array of strings or a filter function, but received "+typeof e)}build(){const e=this.getAllEntriesUnderBase();return this.buildBySegments(e)}}export{a as PathTreeNodeKind,d as PathTreeify};

package/dist/types/index.d.ts

@@ -1,75 +1,18 @@
-/** A filter function that determines whether an entry should be included in the tree */
-type FilterFunction = (params: {
-    name: string;
-    dirPath: string;
-}) => boolean;
-/** Constructor options for PathTreeify */
-interface PathTreeifyProps {
-    /** The root directory to scan */
-    base: string;
-    /** Optional filter applied to every entry during recursive traversal */
-    filter?: FilterFunction;
-    /** When true, files are included as leaf nodes alongside directories. Defaults to false */
-    fileVisible?: boolean;
-    /**
-     * When true, the result of {@link PathTreeNode.getPath} is memoised on each node
-     * after the first call. Subsequent calls return the same object reference without
-     * re-walking the parent chain. Useful when nodes are accessed repeatedly.
-     * Defaults to false.
-     */
-    usePathCache?: boolean;
-}
-/** Classification of a node in the path tree */
-export declare enum PathTreeNodeKind {
-    Dir = "dir",
-    File = "file",
-    /** Assigned before the node's type has been resolved */
-    Unknown = "unknown"
-}
-/**
- * Public interface for a node in the path tree.
- * Consumers receive this type; the internal implementation class is not exported.
- */
-export interface PathTreeNode {
-    /** Distance from the root node; root itself is 0, its direct children are 1, and so on */
-    depth: number;
-    /** Reference to the parent node; null for the root node */
-    parent: PathTreeNode | null;
-    /** The entry name of this node (not a full path) */
-    value: string;
-    /** Child nodes; non-empty only for directory nodes */
-    children: PathTreeNode[];
-    /** Whether this node is a directory, a file, or not yet resolved */
-    type: PathTreeNodeKind;
-    /**
-     * Walks up the parent chain to compute this node's relative and absolute paths.
-     * When the owning {@link PathTreeify} instance was created with `usePathCache: true`,
-     * the result is memoised after the first call and the same object is returned on
-     * every subsequent call.
-     * @returns `relative` — path from the tree root; `absolute` — fully resolved path on disk
-     */
-    getPath(): {
-        relative: string;
-        absolute: string;
-    };
-}
+import { PathTreeifyProps, PathTreeNode } from './src/types';
+export { PathTreeifyProps, PathTreeNodeKind, PathTreeNode } from './src/types';
 /** Builds a tree of {@link PathTreeNode} entries rooted at a given base path */
 export declare class PathTreeify {
     /** The root directory to scan */
-    private base;
-    /**
-     * Shared prototype instance for nodes produced by this builder.
-     * All nodes created via {@link initNode} inherit `base` and `getPath` from this object,
-     * avoiding per-node storage of the base path string.
-     */
-    private pathTreeNodeShared;
+    private _base;
+    /** When true, files are included as leaf nodes during traversal. Defaults to false */
+    private _fileVisible;
+    /** When true, absolute paths are cached on each node after the first retrieval to speed up subsequent `getPath` calls at the cost of higher memory usage. Defaults to false */
+    private _usePathCache;
     /**
      * Optional user-supplied filter. When set, every entry must pass this predicate
      * in addition to the built-in visibility check.
      */
-    private userFilter?;
-    /** When true, files are included as leaf nodes during traversal. Defaults to false */
-    private fileVisible;
+    private _userFilter?;
     constructor(props: Partial<PathTreeifyProps>);
     /**
      * Determines whether a given entry should be included in the tree.
@@ -148,4 +91,3 @@ export declare class PathTreeify {
     /** Builds a full tree from all immediate entries under the base path */
     build(): PathTreeNode;
 }
-export {};

package/dist/types/src/types.d.ts

@@ -0,0 +1,60 @@
+/** A filter function that determines whether an entry should be included in the tree */
+export type FilterFunction = (params: {
+    name: string;
+    dirPath: string;
+}) => boolean;
+/** Constructor options for PathTreeify */
+export interface PathTreeifyProps {
+    /** The root directory to scan */
+    base: string;
+    /** Optional filter applied to every entry during recursive traversal */
+    filter?: FilterFunction;
+    /** When true, files are included as leaf nodes alongside directories. Defaults to false */
+    fileVisible?: boolean;
+    /**
+     * When true, the result of {@link PathTreeNode.getPath} is memoised on each node
+     * after the first call. Subsequent calls return the same object reference without
+     * re-walking the parent chain. Useful when nodes are accessed repeatedly.
+     * Defaults to false.
+     */
+    usePathCache?: boolean;
+}
+/** Classification of a node in the path tree */
+export declare enum PathTreeNodeKind {
+    Dir = "dir",
+    File = "file",
+    /** Assigned before the node's type has been resolved */
+    Unknown = "unknown",
+    BrokenSymlink = "broken_symlink",
+    Other = "other",
+    NotFound = "not_found",
+    PermissionDenied = "permission_denied",
+    Error = "error"
+}
+/**
+ * Public interface for a node in the path tree.
+ * Consumers receive this type; the internal implementation class is not exported.
+ */
+export interface PathTreeNode {
+    /** Distance from the root node; root itself is 0, its direct children are 1, and so on */
+    depth: number;
+    /** Reference to the parent node; null for the root node */
+    parent: PathTreeNode | null;
+    /** The entry name of this node (not a full path) */
+    value: string;
+    /** Child nodes; non-empty only for directory nodes */
+    children: PathTreeNode[];
+    /** Whether this node is a directory, a file, or not yet resolved */
+    type: PathTreeNodeKind;
+    /**
+     * Walks up the parent chain to compute this node's relative and absolute paths.
+     * When the owning {@link PathTreeify} instance was created with `usePathCache: true`,
+     * the result is memoised after the first call and the same object is returned on
+     * every subsequent call.
+     * @returns `relative` — path from the tree root; `absolute` — fully resolved path on disk
+     */
+    getPath(): {
+        relative: string;
+        absolute: string;
+    };
+}

package/dist/types/src/utils.d.ts

@@ -0,0 +1,31 @@
+import { PathTreeNode, PathTreeNodeKind } from "./types";
+/** Defines read-only properties on an object. Each property is set to the corresponding value in the props object, and is non-writable, non-configurable, and non-enumerable.
+ * @param obj - The target object on which to define the properties
+ * @param props - An object where keys are property names and values are the corresponding property values to set
+ */
+export declare function defineReadOnlyProps(obj: any, props: {
+    [key: string]: any;
+}): void;
+/** Determines the type of a given path, classifying it as a directory, file, symbolic link, or other. If the path does not exist, it is classified as NotFound. If any unexpected error occurs during the stat/lstat operations, it will be thrown to the caller.
+ * @param p - The path to classify
+ * @returns A PathTreeNodeKind value indicating the type of the path
+ */
+export declare function getPathType(p: string): PathTreeNodeKind;
+/** A safer wrapper around getPathType that catches any unexpected errors and returns PathTreeNodeKind.Error instead. This is useful for scenarios where we want to classify inaccessible paths without crashing the entire process. */
+export declare function getSafePathType(p: string): PathTreeNodeKind;
+/** Implementation of the PathTreeNode interface. This class is not exported; consumers receive nodes through the PathTreeify API as the PathTreeNode interface type. */
+export declare class PathTreeNodeImp implements PathTreeNode {
+    depth: number;
+    parent: PathTreeNode | null;
+    value: string;
+    children: PathTreeNode[];
+    type: PathTreeNodeKind;
+    constructor(props: {
+        usePathCache: boolean;
+    });
+    /** Retrieves the absolute and relative path represented by this node. If path caching is enabled, the result will be cached after the first retrieval to optimize subsequent calls. */
+    getPath(): {
+        relative: string;
+        absolute: string;
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "path-treeify",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "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",
@@ -26,13 +26,13 @@
   "scripts": {
     "test": "ava",
     "test:coverage": "c8 ava",
-    "test:junit": "mkdir -p reports && ava --tap | tap-xunit --package=path-treeify > reports/junit.xml",
-    "test:report": "rimraf reports && npm run test:coverage && npm run test:junit",
+    "test:md": "mkdir -p reports && ava --tap | tap-json | node ./.github/scripts/generate-report.js --title \"${npm_config_title:-AVA Test Results}\" > reports/ava-test.md",
+    "test:report": "rimraf reports && npm run test:coverage && npm run test:md",
     "clean": "rimraf dist",
     "build": "npm run clean && rollup -c",
     "build:dev": "NODE_ENV=development npm run build",
     "build:prod": "NODE_ENV=production npm run build",
-    "build:watch": "nodemon --watch index.ts -e ts --exec \"npm run build:dev\"",
+    "dev": "nodemon --watch index.ts -e ts --exec \"npm run build:dev\"",
     "check-publish": "npm pack --dry-run",
     "publish:beta": "npm publish --tag beta --access public",
     "publish:latest": "npm publish --tag latest --access public"
@@ -93,7 +93,7 @@
     "nodemon": "^3.1.14",
     "rimraf": "^6.1.3",
     "rollup": "^4.59.0",
-    "tap-xunit": "^2.4.1",
+    "tap-json": "^1.0.0",
     "tslib": "^2.8.1",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3"

package/dist/types/dev/index.d.ts

@@ -1 +0,0 @@
-export {};