@zthun/crumbtrail-fs 2.4.6 → 2.4.9

package/dist/index.cjs

@@ -1,496 +1,373 @@
-'use strict';
-
-Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-
-const helpfulFn = require('@zthun/helpful-fn');
-const helpfulQuery = require('@zthun/helpful-query');
-const lodashEs = require('lodash-es');
-const minimatch = require('minimatch');
-const node_path = require('node:path');
-const glob = require('glob');
-const promises = require('node:fs/promises');
-const node_process = require('node:process');
-const chokidar = require('chokidar');
-const rxjs = require('rxjs');
-const node_url = require('node:url');
-const path = require('path');
-const promises$1 = require('fs/promises');
-
-function _define_property$3(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let node_path = require("node:path");
+let _zthun_helpful_fn = require("@zthun/helpful-fn");
+let _zthun_helpful_query = require("@zthun/helpful-query");
+let lodash_es = require("lodash-es");
+let minimatch = require("minimatch");
+let node_fs_promises = require("node:fs/promises");
+let node_process = require("node:process");
+let glob = require("glob");
+let chokidar = require("chokidar");
+let rxjs = require("rxjs");
+let node_url = require("node:url");
+let path = require("path");
+let fs_promises = require("fs/promises");
+//#region src/file-system/file-system-node.mts
 /**
- * Represents a type of a file system node.
- */ var ZFileSystemNodeType = /*#__PURE__*/ function(ZFileSystemNodeType) {
-    ZFileSystemNodeType["File"] = "file";
-    ZFileSystemNodeType["Folder"] = "folder";
-    return ZFileSystemNodeType;
+* Represents a type of a file system node.
+*/ var ZFileSystemNodeType = /* @__PURE__ */ function(ZFileSystemNodeType) {
+	ZFileSystemNodeType["File"] = "file";
+	ZFileSystemNodeType["Folder"] = "folder";
+	return ZFileSystemNodeType;
 }({});
 /**
- * Represents a builder for a file system node.
- */ class ZFileSystemNodeBuilder {
-    created(at) {
-        this._node.created = at instanceof Date ? at.toJSON() : at;
-        return this;
-    }
-    updated(at) {
-        this._node.updated = at instanceof Date ? at.toJSON() : at;
-        return this;
-    }
-    size(bytes) {
-        this._node.size = typeof bytes == "number" ? BigInt(bytes) : bytes;
-        return this;
-    }
-    path(path) {
-        this._node.path = path;
-        return this.decorate();
-    }
-    type(type) {
-        this._node.type = type;
-        return this.decorate();
-    }
-    stats(s) {
-        const builder = this.size(s.size).created(s.birthtime).updated(s.mtime);
-        return s.isFile() ? builder.file() : builder.folder();
-    }
-    build() {
-        const clone = structuredClone(this._node);
-        return lodashEs.omitBy(clone, lodashEs.isUndefined);
-    }
-    decorate() {
-        const { path, type } = this._node;
-        this._node.name = node_path.basename(path);
-        this._node.extension = "";
-        this._node.title = this._node.name;
-        this._node.parent = node_path.dirname(path);
-        if (type === "file") {
-            const extension = node_path.extname(path);
-            this._node.extension = extension;
-            this._node.title = node_path.basename(path, extension);
-        }
-        if (!path || path === "/" || this._node.parent === ".") {
-            this._node.parent = "";
-        }
-        return this;
-    }
-    constructor(){
-        _define_property$3(this, "_node", {
-            path: "/",
-            type: "folder",
-            extension: "",
-            name: "",
-            parent: "",
-            title: ""
-        });
-        _define_property$3(this, "file", this.type.bind(this, "file"));
-        _define_property$3(this, "folder", this.type.bind(this, "folder"));
-    }
-}
-
+* Represents a builder for a file system node.
+*/ var ZFileSystemNodeBuilder = class {
+	_node = {
+		path: "/",
+		type: "folder",
+		extension: "",
+		name: "",
+		parent: "",
+		title: ""
+	};
+	created(at) {
+		this._node.created = at instanceof Date ? at.toJSON() : at;
+		return this;
+	}
+	updated(at) {
+		this._node.updated = at instanceof Date ? at.toJSON() : at;
+		return this;
+	}
+	size(bytes) {
+		this._node.size = typeof bytes == "number" ? BigInt(bytes) : bytes;
+		return this;
+	}
+	path(path) {
+		this._node.path = path;
+		return this.decorate();
+	}
+	type(type) {
+		this._node.type = type;
+		return this.decorate();
+	}
+	file = this.type.bind(this, "file");
+	folder = this.type.bind(this, "folder");
+	stats(s) {
+		const builder = this.size(s.size).created(s.birthtime).updated(s.mtime);
+		return s.isFile() ? builder.file() : builder.folder();
+	}
+	build() {
+		return (0, lodash_es.omitBy)(structuredClone(this._node), lodash_es.isUndefined);
+	}
+	decorate() {
+		const { path, type } = this._node;
+		this._node.name = (0, node_path.basename)(path);
+		this._node.extension = "";
+		this._node.title = this._node.name;
+		this._node.parent = (0, node_path.dirname)(path);
+		if (type === "file") {
+			const extension = (0, node_path.extname)(path);
+			this._node.extension = extension;
+			this._node.title = (0, node_path.basename)(path, extension);
+		}
+		if (!path || path === "/" || this._node.parent === ".") this._node.parent = "";
+		return this;
+	}
+};
+//#endregion
+//#region src/file-system/file-system-service.mts
 /**
- * Represents a node implementation of a file system service.
- */ class ZFileSystemService {
-    async info(path) {
-        const [file] = await this.search(path);
-        return file;
-    }
-    async search(pattern, options) {
-        const paths = await glob.glob(pattern, {
-            stat: true,
-            ...options,
-            withFileTypes: true
-        });
-        return paths.map((path)=>{
-            let info = new ZFileSystemNodeBuilder().path(path.fullpath()).created(path.birthtime).updated(path.atime).size(path.size);
-            // Note that for folders, node will return the size of the underlying OS metadata,
-            // hence, why we remove the size on the folder here.
-            info = path.isFile() ? info.file() : info.folder().size(undefined);
-            return info.build();
-        });
-    }
-    async walk(search, options) {
-        const start = options?.start || node_process.cwd();
-        const stop = options?.stop || "/";
-        const mode = options?.mode;
-        const _test = async (path)=>{
-            try {
-                await promises.access(path, mode);
-                return true;
-            } catch  {
-                return false;
-            }
-        };
-        if (node_path.isAbsolute(search)) {
-            return await _test(search) ? search : null;
-        }
-        let dir = start;
-        do {
-            const path = node_path.resolve(dir, search);
-            const exists = await _test(path);
-            if (exists) {
-                return path;
-            }
-            dir = dir === stop ? "" : node_path.dirname(dir);
-        }while (dir.length)
-        return null;
-    }
-}
-
-function _define_property$2(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
+* Represents a node implementation of a file system service.
+*/ var ZFileSystemService = class {
+	async info(path) {
+		const [file] = await this.search(path);
+		return file;
+	}
+	async search(pattern, options) {
+		return (await (0, glob.glob)(pattern, {
+			stat: true,
+			...options,
+			withFileTypes: true
+		})).map((path) => {
+			let info = new ZFileSystemNodeBuilder().path(path.fullpath()).created(path.birthtime).updated(path.atime).size(path.size);
+			info = path.isFile() ? info.file() : info.folder().size(void 0);
+			return info.build();
+		});
+	}
+	async walk(search, options) {
+		const start = options?.start || (0, node_process.cwd)();
+		const stop = options?.stop || "/";
+		const mode = options?.mode;
+		const _test = async (path) => {
+			try {
+				await (0, node_fs_promises.access)(path, mode);
+				return true;
+			} catch {
+				return false;
+			}
+		};
+		if ((0, node_path.isAbsolute)(search)) return await _test(search) ? search : null;
+		let dir = start;
+		do {
+			const path = (0, node_path.resolve)(dir, search);
+			if (await _test(path)) return path;
+			dir = dir === stop ? "" : (0, node_path.dirname)(dir);
+		} while (dir.length);
+		return null;
+	}
+};
+//#endregion
+//#region src/file-watch/file-watch.mts
 /**
- * An implementation of the IZFileWatch.
- */ class ZFileWatch {
-    async start() {
-        await this.stop();
-        this._watcher = chokidar.watch(this.path, {
-            usePolling: true,
-            alwaysStat: true,
-            ignoreInitial: true,
-            awaitWriteFinish: {
-                stabilityThreshold: 500,
-                pollInterval: 50
-            }
-        });
-        function next(observable, file, stats) {
-            const node = new ZFileSystemNodeBuilder().path(node_path.resolve(this.path, file));
-            observable.next(stats ? node.stats(stats).build() : node.build());
-        }
-        this._watcher.on("add", next.bind(this, this._add)).on("addDir", next.bind(this, this._add)).on("change", next.bind(this, this._update)).on("unlink", next.bind(this, this._remove)).on("unlinkDir", next.bind(this, this._remove));
-        return new Promise((resolve)=>this._watcher?.on("ready", ()=>resolve()));
-    }
-    async stop() {
-        await this._watcher?.close();
-        delete this._watcher;
-    }
-    add() {
-        return this._add.asObservable();
-    }
-    update() {
-        return this._update.asObservable();
-    }
-    remove() {
-        return this._remove.asObservable();
-    }
-    /**
-   * Initializes a new instance of this object.
-   *
-   * @param path -
-   *        The path to watch.
-   */ constructor(path){
-        _define_property$2(this, "path", void 0);
-        _define_property$2(this, "_add", void 0);
-        _define_property$2(this, "_update", void 0);
-        _define_property$2(this, "_remove", void 0);
-        _define_property$2(this, "_watcher", void 0);
-        this.path = path;
-        this._add = new rxjs.Subject();
-        this._update = new rxjs.Subject();
-        this._remove = new rxjs.Subject();
-    }
-}
-
-function _define_property$1(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
+* An implementation of the IZFileWatch.
+*/ var ZFileWatch = class {
+	path;
+	_add = new rxjs.Subject();
+	_update = new rxjs.Subject();
+	_remove = new rxjs.Subject();
+	_watcher;
+	/**
+	* Initializes a new instance of this object.
+	*
+	* @param path -
+	*        The path to watch.
+	*/ constructor(path) {
+		this.path = path;
+	}
+	async start() {
+		await this.stop();
+		this._watcher = (0, chokidar.watch)(this.path, {
+			usePolling: true,
+			alwaysStat: true,
+			ignoreInitial: true,
+			awaitWriteFinish: {
+				stabilityThreshold: 500,
+				pollInterval: 50
+			}
+		});
+		function next(observable, file, stats) {
+			const node = new ZFileSystemNodeBuilder().path((0, node_path.resolve)(this.path, file));
+			observable.next(stats ? node.stats(stats).build() : node.build());
+		}
+		this._watcher.on("add", next.bind(this, this._add)).on("addDir", next.bind(this, this._add)).on("change", next.bind(this, this._update)).on("unlink", next.bind(this, this._remove)).on("unlinkDir", next.bind(this, this._remove));
+		return new Promise((resolve) => this._watcher?.on("ready", () => resolve()));
+	}
+	async stop() {
+		await this._watcher?.close();
+		delete this._watcher;
+	}
+	add() {
+		return this._add.asObservable();
+	}
+	update() {
+		return this._update.asObservable();
+	}
+	remove() {
+		return this._remove.asObservable();
+	}
+};
+//#endregion
+//#region src/file-repository/file-repository.mts
 /**
- * Represents an implementation of a ZFileRepository that watches
- * a given path scope.
- *
- * This repository is only concerned about files.  Folders
- * will not be retrieved from this repository.
- */ class ZFileRepository {
-    /**
-   * Gets the path that this repository is watching.
-   */ get path() {
-        return this._path;
-    }
-    /**
-   * Gets the globs matchers that this repository is matching against.
-   */ get globs() {
-        return this._globs.slice();
-    }
-    /**
-   * Initializes the repository with the given root and glob filter.
-   *
-   * This will initially scan the file system and setup watches.
-   * If you call this method again, then the repository will be
-   * {@link reset} and a new set of files will be added to the
-   * repository.
-   *
-   * @param path -
-   *        The root path of the repository.
-   * @param globs -
-   *        The optional relative globs of the repository.  If this is falsy,
-   *        then ** is used.  You can achieve the same kind of operation
-   *        using filters, but filtering out unwanted files frees up the internal
-   *        memory being used.
-   */ async initialize(path, globs = [
-        "**"
-    ]) {
-        await this.reset();
-        this._path = path;
-        this._globs = globs;
-        // Note that this all happens in the background and should
-        // only be awaited later.  So the search should not be
-        // required to finish when existing this method.  The only
-        // requirement is that the repository is reset and the path +
-        // glob scope is updated.  Everything beyond here should not
-        // be awaited - it will be awaited later once the caller
-        // tries to retrieve the files using retrieve, get, or
-        // count.
-        const matches = globs.map((g)=>this._service.search(g, {
-                cwd: path,
-                stat: true
-            }));
-        this._nodes = Promise.all(matches).then((nodes)=>{
-            const flat = lodashEs.flatten(nodes);
-            const uniq = lodashEs.uniqBy(flat, (n)=>n.path);
-            return uniq.filter((n)=>n.type === ZFileSystemNodeType.File);
-        }).then((files)=>{
-            return new helpfulQuery.ZDataSourceStatic(files);
-        });
-        this._watcher = new ZFileWatch(path);
-        this._add = this._watcher.add().subscribe(async (node)=>{
-            if (node.type === ZFileSystemNodeType.File && this._globs.some((g)=>minimatch.minimatch(node.path, node_path.resolve(this._path, g)))) {
-                const nodes = await this._nodes;
-                this._nodes = nodes.insert(node);
-            }
-        });
-        this._remove = this._watcher.remove().subscribe(async (node)=>{
-            let nodes = await this._nodes;
-            const path = lodashEs.trimEnd(node.path, node_path.sep);
-            // It's possible that the node given was a folder.  If that happens,
-            // we need to remove all files that start with the given path.
-            // If the node does point to a file, then there is no possibility that
-            // more than 1 item would be removed.
-            const next = async ()=>lodashEs.findIndex(await nodes.items(), (n)=>{
-                    return n.path === path || n.path.startsWith(path) && n.path.substring(path.length).charAt(0) === node_path.sep;
-                });
-            for(let index = await next(); index >= 0; index = await next()){
-                nodes = await nodes.removeAt(index);
-            }
-            this._nodes = Promise.resolve(nodes);
-        });
-        this._update = this._watcher.update().subscribe(async (node)=>{
-            const nodes = await this._nodes;
-            const index = lodashEs.findIndex(await nodes.items(), (n)=>n.path === node.path);
-            // It's possible node was filtered out by the globs, or
-            // it is a directory.  If so, then we won't have it in our
-            // list.
-            if (index >= 0) {
-                const next = await nodes.removeAt(index);
-                this._nodes = next.insert(node, index);
-            }
-        });
-        // Kick off the initial seed operation with an even loop
-        // invocation.
-        await helpfulFn.sleep(100);
-        await this._watcher?.start();
-    }
-    /**
-   * Resets the repository as if it was initially created.
-   */ async reset() {
-        await this._watcher?.stop();
-        this._add?.unsubscribe();
-        this._remove?.unsubscribe();
-        this._update?.unsubscribe();
-        delete this._add;
-        delete this._remove;
-        delete this._update;
-        delete this._watcher;
-        this._path = "";
-        this._globs = [
-            "**"
-        ];
-        this._nodes = Promise.resolve(new helpfulQuery.ZDataSourceStatic([]));
-    }
-    async get(path) {
-        const nodes = await this._nodes;
-        const items = await nodes.items();
-        const node = lodashEs.find(items, (f)=>f.path === path);
-        return helpfulFn.firstDefined(null, node);
-    }
-    async count(request) {
-        const source = await this._nodes;
-        return source.count(request);
-    }
-    async retrieve(request) {
-        const source = await this._nodes;
-        return source.retrieve(request);
-    }
-    constructor(){
-        _define_property$1(this, "_service", new ZFileSystemService());
-        _define_property$1(this, "_watcher", void 0);
-        _define_property$1(this, "_nodes", Promise.resolve(new helpfulQuery.ZDataSourceStatic([])));
-        _define_property$1(this, "_globs", [
-            "**"
-        ]);
-        _define_property$1(this, "_path", "");
-        _define_property$1(this, "_add", void 0);
-        _define_property$1(this, "_remove", void 0);
-        _define_property$1(this, "_update", void 0);
-    }
-}
-
+* Represents an implementation of a ZFileRepository that watches
+* a given path scope.
+*
+* This repository is only concerned about files.  Folders
+* will not be retrieved from this repository.
+*/ var ZFileRepository = class {
+	_service = new ZFileSystemService();
+	_watcher;
+	_nodes = Promise.resolve(new _zthun_helpful_query.ZDataSourceStatic([]));
+	_globs = ["**"];
+	_path = "";
+	_add;
+	_remove;
+	_update;
+	/**
+	* Gets the path that this repository is watching.
+	*/ get path() {
+		return this._path;
+	}
+	/**
+	* Gets the globs matchers that this repository is matching against.
+	*/ get globs() {
+		return this._globs.slice();
+	}
+	/**
+	* Initializes the repository with the given root and glob filter.
+	*
+	* This will initially scan the file system and setup watches.
+	* If you call this method again, then the repository will be
+	* {@link reset} and a new set of files will be added to the
+	* repository.
+	*
+	* @param path -
+	*        The root path of the repository.
+	* @param globs -
+	*        The optional relative globs of the repository.  If this is falsy,
+	*        then ** is used.  You can achieve the same kind of operation
+	*        using filters, but filtering out unwanted files frees up the internal
+	*        memory being used.
+	*/ async initialize(path, globs = ["**"]) {
+		await this.reset();
+		this._path = path;
+		this._globs = globs;
+		const matches = globs.map((g) => this._service.search(g, {
+			cwd: path,
+			stat: true
+		}));
+		this._nodes = Promise.all(matches).then((nodes) => {
+			return (0, lodash_es.uniqBy)((0, lodash_es.flatten)(nodes), (n) => n.path).filter((n) => n.type === ZFileSystemNodeType.File);
+		}).then((files) => {
+			return new _zthun_helpful_query.ZDataSourceStatic(files);
+		});
+		this._watcher = new ZFileWatch(path);
+		this._add = this._watcher.add().subscribe((node) => {
+			(async () => {
+				if (node.type === ZFileSystemNodeType.File && this._globs.some((g) => (0, minimatch.minimatch)(node.path, (0, node_path.resolve)(this._path, g)))) this._nodes = (await this._nodes).insert(node);
+			})();
+		});
+		this._remove = this._watcher.remove().subscribe((node) => {
+			(async () => {
+				let nodes = await this._nodes;
+				const path = (0, lodash_es.trimEnd)(node.path, node_path.sep);
+				const next = async () => (0, lodash_es.findIndex)(await nodes.items(), (n) => {
+					return n.path === path || n.path.startsWith(path) && n.path.substring(path.length).charAt(0) === node_path.sep;
+				});
+				for (let index = await next(); index >= 0; index = await next()) nodes = await nodes.removeAt(index);
+				this._nodes = Promise.resolve(nodes);
+			})();
+		});
+		this._update = this._watcher.update().subscribe((node) => {
+			(async () => {
+				const nodes = await this._nodes;
+				const index = (0, lodash_es.findIndex)(await nodes.items(), (n) => n.path === node.path);
+				if (index >= 0) this._nodes = (await nodes.removeAt(index)).insert(node, index);
+			})();
+		});
+		await (0, _zthun_helpful_fn.sleep)(100);
+		await this._watcher?.start();
+	}
+	/**
+	* Resets the repository as if it was initially created.
+	*/ async reset() {
+		await this._watcher?.stop();
+		this._add?.unsubscribe();
+		this._remove?.unsubscribe();
+		this._update?.unsubscribe();
+		delete this._add;
+		delete this._remove;
+		delete this._update;
+		delete this._watcher;
+		this._path = "";
+		this._globs = ["**"];
+		this._nodes = Promise.resolve(new _zthun_helpful_query.ZDataSourceStatic([]));
+	}
+	async get(path) {
+		return (0, _zthun_helpful_fn.firstDefined)(null, (0, lodash_es.find)(await (await this._nodes).items(), (f) => f.path === path));
+	}
+	async count(request) {
+		return (await this._nodes).count(request);
+	}
+	async retrieve(request) {
+		return (await this._nodes).retrieve(request);
+	}
+};
+//#endregion
+//#region src/resolve-path-like/resolve-path-like.ts
 function resolvePathLike(path) {
-    if (typeof path === "string") {
-        return node_path.resolve(path);
-    }
-    if (path instanceof URL) {
-        return node_url.fileURLToPath(path);
-    }
-    return node_path.resolve(path.toString());
+	if (typeof path === "string") return (0, node_path.resolve)(path);
+	if (path instanceof URL) return (0, node_url.fileURLToPath)(path);
+	return (0, node_path.resolve)(path.toString());
 }
-
+//#endregion
+//#region src/sleep-watch-delay/sleep-watch-delay.mts
 /**
- * The actual delay time that you should wait for a watch
- * operation to pick up your file changes.
- */ const ZWatchDelay = 1500;
+* The actual delay time that you should wait for a watch
+* operation to pick up your file changes.
+*/ var ZWatchDelay = 1500;
 /**
- * Performs a sleep long enough to allow a watch operation
- * to pick up a change.
- *
- * You should never really need this.  Where it is useful
- * is for unit testing with IO operations and you want to
- * wait for your write operations to get picked up by
- * a file watch operation.
- */ function sleepWatchDelay() {
-    return helpfulFn.sleep(ZWatchDelay);
+* Performs a sleep long enough to allow a watch operation
+* to pick up a change.
+*
+* You should never really need this.  Where it is useful
+* is for unit testing with IO operations and you want to
+* wait for your write operations to get picked up by
+* a file watch operation.
+*/ function sleepWatchDelay() {
+	return (0, _zthun_helpful_fn.sleep)(ZWatchDelay);
 }
-
+//#endregion
+//#region src/stream/stream-folder.mts
 /**
- * A stream that writes folders.
- *
- * Writing folders is idempotent.  If the folder you
- * are trying to write already exists, then the write
- * operation still succeeds
- */ class ZStreamFolder {
-    async write(path) {
-        await promises$1.mkdir(path, {
-            recursive: true
-        });
-        return 0;
-    }
-}
-
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
+* A stream that writes folders.
+*
+* Writing folders is idempotent.  If the folder you
+* are trying to write already exists, then the write
+* operation still succeeds
+*/ var ZStreamFolder = class {
+	async write(path) {
+		await (0, fs_promises.mkdir)(path, { recursive: true });
+		return 0;
+	}
+};
+//#endregion
+//#region src/stream/stream-file.mts
 /**
- * A stream that can read and write to files.
- *
- * This is mostly a wrapper to readFile and writeFile from node, but
- * with some optimizations.
- *
- * First, this class supports file content caching so reading in a file
- * that's under a certain size threshold will store it in memory for
- * later retrieval.
- */ class ZStreamFile {
-    async read(path, options) {
-        const _path = resolvePathLike(path);
-        const stats = await promises.stat(_path);
-        const cached = this._cache.get(_path);
-        const buffer = cached && cached.stats.mtimeMs >= stats.mtimeMs ? cached.buffer : promises.readFile(_path, options);
-        return this._addToCache(_path, {
-            stats,
-            buffer
-        });
-    }
-    async write(path$1, { buffer = Buffer.from("") } = {}) {
-        const _path = resolvePathLike(path$1);
-        const directory = path.dirname(_path);
-        await new ZStreamFolder().write(directory);
-        await promises.writeFile(_path, buffer, {
-            flush: true
-        });
-        // If this file specifically was cached earlier,
-        // we can just remove it now so we make room for
-        // another file.  Consumers can just read the
-        // file again to recache it.
-        this._cache.delete(_path);
-        return buffer.length;
-    }
-    _addToCache(path, item) {
-        const { cache = {} } = this.options;
-        const { fileSize = ZStreamFile.FileSizeDefault, maxFiles = ZStreamFile.MaxFilesDefault } = cache;
-        if (item.stats.size > fileSize) {
-            // In this case, the file size is too big to cache in memory,
-            // so we're bowing out here.
-            return item.buffer;
-        }
-        // We will remove this path from the cache first since
-        // we want it to be the most recent file (at the end)
-        // of the key list.  The removal does nothing if the
-        // file was not cached.
-        this._cache.delete(path);
-        this._cache.set(path, item);
-        if (this._cache.size > maxFiles) {
-            // Retrieving the keys from a javascript map is order
-            // by the time in which the keys are created.  So
-            // we are going to remove the first key which is the
-            // oldest.
-            const itr = this._cache.keys();
-            this._cache.delete(itr.next().value);
-        }
-        return item.buffer;
-    }
-    /**
-   * Initializes a new instance of this object.
-   *
-   * @param options -
-   *        The options for file read and writes.
-   */ constructor(options = {}){
-        _define_property(this, "options", void 0);
-        _define_property(this, "_cache", void 0);
-        this.options = options;
-        this._cache = new Map();
-    }
-}
-_define_property(ZStreamFile, "FileSizeDefault", 102400); // One Hundred KibiBytes
-_define_property(ZStreamFile, "MaxFilesDefault", 1000);
-
+* A stream that can read and write to files.
+*
+* This is mostly a wrapper to readFile and writeFile from node, but
+* with some optimizations.
+*
+* First, this class supports file content caching so reading in a file
+* that's under a certain size threshold will store it in memory for
+* later retrieval.
+*/ var ZStreamFile = class ZStreamFile {
+	options;
+	static FileSizeDefault = 102400;
+	static MaxFilesDefault = 1e3;
+	_cache = /* @__PURE__ */ new Map();
+	/**
+	* Initializes a new instance of this object.
+	*
+	* @param options -
+	*        The options for file read and writes.
+	*/ constructor(options = {}) {
+		this.options = options;
+	}
+	async read(path$1, options) {
+		const _path = resolvePathLike(path$1);
+		const stats = await (0, node_fs_promises.stat)(_path);
+		const cached = this._cache.get(_path);
+		const buffer = cached && cached.stats.mtimeMs >= stats.mtimeMs ? cached.buffer : (0, node_fs_promises.readFile)(_path, options);
+		return this._addToCache(_path, {
+			stats,
+			buffer
+		});
+	}
+	async write(path$2, { buffer = Buffer.from("") } = {}) {
+		const _path = resolvePathLike(path$2);
+		const directory = (0, path.dirname)(_path);
+		await new ZStreamFolder().write(directory);
+		await (0, node_fs_promises.writeFile)(_path, buffer, { flush: true });
+		this._cache.delete(_path);
+		return buffer.length;
+	}
+	_addToCache(path$3, item) {
+		const { cache = {} } = this.options;
+		const { fileSize = ZStreamFile.FileSizeDefault, maxFiles = ZStreamFile.MaxFilesDefault } = cache;
+		if (item.stats.size > fileSize) return item.buffer;
+		this._cache.delete(path$3);
+		this._cache.set(path$3, item);
+		if (this._cache.size > maxFiles) {
+			const itr = this._cache.keys();
+			this._cache.delete(itr.next().value);
+		}
+		return item.buffer;
+	}
+};
+//#endregion
 exports.ZFileRepository = ZFileRepository;
 exports.ZFileSystemNodeBuilder = ZFileSystemNodeBuilder;
 exports.ZFileSystemNodeType = ZFileSystemNodeType;
@@ -501,4 +378,5 @@ exports.ZStreamFolder = ZStreamFolder;
 exports.ZWatchDelay = ZWatchDelay;
 exports.resolvePathLike = resolvePathLike;
 exports.sleepWatchDelay = sleepWatchDelay;
-//# sourceMappingURL=index.cjs.map
+
+//# sourceMappingURL=index.cjs.map