@fgv/ts-json-base 5.0.2 → 5.1.0-1

package/dist/packlets/file-tree/fsTree.js

@@ -21,12 +21,13 @@
  */
 import path from 'path';
 import fs from 'fs';
-import { captureResult, succeed } from '@fgv/ts-utils';
+import { captureResult, fail, failWithDetail, succeed, succeedWithDetail } from '@fgv/ts-utils';
 import { DirectoryItem } from './directoryItem';
 import { FileItem } from './fileItem';
+import { isPathMutable } from './filterSpec';
 /**
- * Implementation of {@link FileTree.IFileTreeAccessors} that uses the
- * file system to access files and directories.
+ * Implementation of {@link FileTree.IMutableFileTreeAccessors} that uses the
+ * file system to access and modify files and directories.
  * @public
  */
 export class FsFileTreeAccessors {
@@ -36,12 +37,14 @@ export class FsFileTreeAccessors {
      * @public
      */
     constructor(params) {
-        var _a;
+        var _a, _b;
         this.prefix = params === null || params === void 0 ? void 0 : params.prefix;
         this._inferContentType = (_a = params === null || params === void 0 ? void 0 : params.inferContentType) !== null && _a !== void 0 ? _a : FileItem.defaultInferContentType;
+        /* c8 ignore next 1 - defensive default when params is undefined */
+        this._mutable = (_b = params === null || params === void 0 ? void 0 : params.mutable) !== null && _b !== void 0 ? _b : false;
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.resolveAbsolutePath}
+     * {@inheritDoc FileTree.IFileTreeAccessors.resolveAbsolutePath}
      */
     resolveAbsolutePath(...paths) {
         if (this.prefix && !path.isAbsolute(paths[0])) {
@@ -50,25 +53,25 @@ export class FsFileTreeAccessors {
         return path.resolve(...paths);
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getExtension}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getExtension}
      */
     getExtension(itemPath) {
         return path.extname(itemPath);
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getBaseName}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getBaseName}
      */
     getBaseName(itemPath, suffix) {
         return path.basename(itemPath, suffix);
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.joinPaths}
+     * {@inheritDoc FileTree.IFileTreeAccessors.joinPaths}
      */
     joinPaths(...paths) {
         return path.join(...paths);
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getItem}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getItem}
      */
     getItem(itemPath) {
         return captureResult(() => {
@@ -84,13 +87,13 @@ export class FsFileTreeAccessors {
         });
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getFileContents}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getFileContents}
      */
     getFileContents(filePath) {
         return captureResult(() => fs.readFileSync(this.resolveAbsolutePath(filePath), 'utf8'));
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getFileContentType}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getFileContentType}
      */
     getFileContentType(filePath, provided) {
         if (provided !== undefined) {
@@ -100,7 +103,7 @@ export class FsFileTreeAccessors {
         return this._inferContentType(filePath);
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getChildren}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getChildren}
      */
     getChildren(dirPath) {
         return captureResult(() => {
@@ -118,5 +121,97 @@ export class FsFileTreeAccessors {
             return children;
         });
     }
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeAccessors.fileIsMutable}
+     */
+    fileIsMutable(path) {
+        const absolutePath = this.resolveAbsolutePath(path);
+        // Check if mutability is disabled
+        if (this._mutable === false) {
+            return failWithDetail(`${absolutePath}: mutability is disabled`, 'not-mutable');
+        }
+        // Check if path is excluded by filter
+        if (!isPathMutable(absolutePath, this._mutable)) {
+            return failWithDetail(`${absolutePath}: path is excluded by filter`, 'path-excluded');
+        }
+        // Check file system permissions
+        try {
+            // Check if file exists
+            if (fs.existsSync(absolutePath)) {
+                fs.accessSync(absolutePath, fs.constants.W_OK);
+            }
+            else {
+                // Check if parent directory is writable
+                const parentDir = absolutePath.substring(0, absolutePath.lastIndexOf('/'));
+                if (parentDir && fs.existsSync(parentDir)) {
+                    fs.accessSync(parentDir, fs.constants.W_OK);
+                }
+            }
+            return succeedWithDetail(true, 'persistent');
+            /* c8 ignore next 3 - unreachable when running as root (CI), tested in mutableFsTree.test.ts */
+        }
+        catch (_a) {
+            return failWithDetail(`${absolutePath}: permission denied`, 'permission-denied');
+        }
+    }
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeAccessors.saveFileContents}
+     */
+    saveFileContents(path, contents) {
+        return this.fileIsMutable(path).asResult.onSuccess(() => {
+            const absolutePath = this.resolveAbsolutePath(path);
+            return captureResult(() => {
+                fs.writeFileSync(absolutePath, contents, 'utf8');
+                return contents;
+            });
+        });
+    }
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeAccessors.deleteFile}
+     */
+    deleteFile(path) {
+        return this.fileIsMutable(path).asResult.onSuccess(() => {
+            const absolutePath = this.resolveAbsolutePath(path);
+            return captureResult(() => {
+                const stat = fs.statSync(absolutePath);
+                if (!stat.isFile()) {
+                    throw new Error(`${absolutePath}: not a file`);
+                }
+                fs.unlinkSync(absolutePath);
+                return true;
+            });
+        });
+    }
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeAccessors.createDirectory}
+     */
+    createDirectory(dirPath) {
+        const absolutePath = this.resolveAbsolutePath(dirPath);
+        // Check if mutability is disabled
+        if (this._mutable === false) {
+            return fail(`${absolutePath}: mutability is disabled`);
+        }
+        return captureResult(() => {
+            fs.mkdirSync(absolutePath, { recursive: true });
+            return absolutePath;
+        });
+    }
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeAccessors.deleteDirectory}
+     */
+    deleteDirectory(dirPath) {
+        return this.fileIsMutable(dirPath).asResult.onSuccess(() => {
+            const absolutePath = this.resolveAbsolutePath(dirPath);
+            return captureResult(() => {
+                const stat = fs.statSync(absolutePath);
+                if (!stat.isDirectory()) {
+                    throw new Error(`${absolutePath}: not a directory`);
+                }
+                // fs.rmdirSync fails if directory is non-empty (desired behavior)
+                fs.rmdirSync(absolutePath);
+                return true;
+            });
+        });
+    }
 }
 //# sourceMappingURL=fsTree.js.map

package/dist/packlets/file-tree/in-memory/inMemoryTree.js

@@ -19,13 +19,86 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
-import { captureResult, fail, succeed } from '@fgv/ts-utils';
+import { captureResult, fail, failWithDetail, succeed, succeedWithDetail } from '@fgv/ts-utils';
 import { DirectoryItem } from '../directoryItem';
 import { FileItem } from '../fileItem';
 import { InMemoryDirectory, InMemoryFile, TreeBuilder } from './treeBuilder';
+import { isPathMutable } from '../filterSpec';
 /**
- * Implementation of {@link FileTree.IFileTreeAccessors} that uses an in-memory
- * tree to access files and directories.
+ * A mutable in-memory file that allows updating contents.
+ * @internal
+ */
+class MutableInMemoryFile {
+    constructor(absolutePath, contents, contentType) {
+        this.absolutePath = absolutePath;
+        this._contents = contents;
+        this.contentType = contentType;
+    }
+    get contents() {
+        return this._contents;
+    }
+    setContents(contents) {
+        this._contents = contents;
+    }
+}
+/**
+ * A mutable in-memory directory that creates mutable files.
+ * @internal
+ */
+class MutableInMemoryDirectory {
+    /* c8 ignore next 3 - internal getter used by tree traversal */
+    get children() {
+        return this._children;
+    }
+    constructor(absolutePath) {
+        this.absolutePath = absolutePath;
+        this._children = new Map();
+    }
+    getChildPath(name) {
+        if (this.absolutePath === '/') {
+            return `/${name}`;
+        }
+        return [this.absolutePath, name].join('/');
+    }
+    addFile(name, contents, contentType) {
+        /* c8 ignore next 3 - defensive: duplicate detection during construction */
+        if (this._children.has(name)) {
+            return fail(`${name}: already exists`);
+        }
+        const child = new MutableInMemoryFile(this.getChildPath(name), contents, contentType);
+        this._children.set(name, child);
+        return succeed(child);
+    }
+    getOrAddDirectory(name) {
+        const existing = this._children.get(name);
+        if (existing) {
+            if (existing instanceof MutableInMemoryDirectory) {
+                return succeed(existing);
+            }
+            return fail(`${name}: not a directory`);
+        }
+        const child = new MutableInMemoryDirectory(this.getChildPath(name));
+        this._children.set(name, child);
+        return succeed(child);
+    }
+    updateOrAddFile(name, contents, contentType) {
+        const existing = this._children.get(name);
+        if (existing) {
+            if (existing instanceof MutableInMemoryFile) {
+                existing.setContents(contents);
+                return succeed(existing);
+            }
+            return fail(`${name}: not a file`);
+        }
+        return this.addFile(name, contents, contentType);
+    }
+    removeChild(name) {
+        return this._children.delete(name);
+    }
+}
+/**
+ * Implementation of {@link FileTree.IMutableFileTreeAccessors} that uses an in-memory
+ * tree to access and modify files and directories.
  * @public
  */
 export class InMemoryTreeAccessors {
@@ -36,12 +109,18 @@ export class InMemoryTreeAccessors {
      * @public
      */
     constructor(files, params) {
-        var _a, _b;
+        var _a, _b, _c, _d;
         this._tree = TreeBuilder.create(params === null || params === void 0 ? void 0 : params.prefix).orThrow();
         this._inferContentType = (_a = params === null || params === void 0 ? void 0 : params.inferContentType) !== null && _a !== void 0 ? _a : FileItem.defaultInferContentType;
+        this._mutable = (_b = params === null || params === void 0 ? void 0 : params.mutable) !== null && _b !== void 0 ? _b : false;
+        this._mutableByPath = new Map();
+        const prefix = (_c = params === null || params === void 0 ? void 0 : params.prefix) !== null && _c !== void 0 ? _c : '/';
+        this._mutableRoot = new MutableInMemoryDirectory(prefix.endsWith('/') ? prefix.slice(0, -1) || '/' : prefix);
+        this._mutableByPath.set(this._mutableRoot.absolutePath, this._mutableRoot);
         for (const file of files) {
-            const contentType = (_b = file.contentType) !== null && _b !== void 0 ? _b : this._inferContentType(file.path).orDefault();
+            const contentType = (_d = file.contentType) !== null && _d !== void 0 ? _d : this._inferContentType(file.path).orDefault();
             this._tree.addFile(file.path, file.contents, contentType).orThrow();
+            this._addMutableFile(file.path, file.contents, contentType);
         }
     }
     /**
@@ -56,7 +135,7 @@ export class InMemoryTreeAccessors {
         return captureResult(() => new InMemoryTreeAccessors(files, params));
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.resolveAbsolutePath}
+     * {@inheritDoc FileTree.IFileTreeAccessors.resolveAbsolutePath}
      */
     resolveAbsolutePath(...paths) {
         const parts = paths[0].startsWith('/') ? paths : [this._tree.prefix, ...paths];
@@ -64,7 +143,7 @@ export class InMemoryTreeAccessors {
         return `/${joined}`;
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getExtension}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getExtension}
      */
     getExtension(path) {
         const parts = path.split('.');
@@ -74,7 +153,7 @@ export class InMemoryTreeAccessors {
         return `.${parts.pop()}`;
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getBaseName}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getBaseName}
      */
     getBaseName(path, suffix) {
         var _a;
@@ -86,13 +165,15 @@ export class InMemoryTreeAccessors {
         return base;
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.joinPaths}
+     * {@inheritDoc FileTree.IFileTreeAccessors.joinPaths}
      */
     joinPaths(...paths) {
-        return paths.join('/');
+        var _a;
+        const joined = paths.flatMap((p) => p.split('/').filter((s) => s.length > 0)).join('/');
+        return ((_a = paths[0]) === null || _a === void 0 ? void 0 : _a.startsWith('/')) ? `/${joined}` : joined;
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getItem}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getItem}
      */
     getItem(itemPath) {
         const existing = this._tree.byAbsolutePath.get(itemPath);
@@ -107,26 +188,24 @@ export class InMemoryTreeAccessors {
         return fail(`${itemPath}: not found`);
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getFileContents}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getFileContents}
      */
     getFileContents(path) {
-        const item = this._tree.byAbsolutePath.get(path);
+        const absolutePath = this.resolveAbsolutePath(path);
+        const item = this._mutableByPath.get(absolutePath);
         if (item === undefined) {
-            return fail(`${path}: not found`);
+            return fail(`${absolutePath}: not found`);
         }
-        /* c8 ignore next 3 - local coverage is 100% but build coverage has intermittent issues */
-        if (!(item instanceof InMemoryFile)) {
-            return fail(`${path}: not a file`);
+        if (!(item instanceof MutableInMemoryFile)) {
+            return fail(`${absolutePath}: not a file`);
         }
-        // if the body is a string we don't want to add quotes
         if (typeof item.contents === 'string') {
             return succeed(item.contents);
         }
-        /* c8 ignore next 2 - local coverage is 100% but build coverage has intermittent issues */
         return captureResult(() => JSON.stringify(item.contents));
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getFileContentType}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getFileContentType}
      */
     getFileContentType(path, provided) {
         // If provided contentType is given, use it directly (highest priority)
@@ -149,7 +228,7 @@ export class InMemoryTreeAccessors {
         return this._inferContentType(path);
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getChildren}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getChildren}
      */
     getChildren(path) {
         const item = this._tree.byAbsolutePath.get(path);
@@ -173,5 +252,184 @@ export class InMemoryTreeAccessors {
             return children;
         });
     }
+    _addMutableFile(path, contents, contentType) {
+        const absolutePath = this.resolveAbsolutePath(path);
+        const parts = absolutePath.split('/').filter((p) => p.length > 0);
+        /* c8 ignore next 3 - defensive: invalid path detection */
+        if (parts.length === 0) {
+            return fail(`${absolutePath}: invalid file path`);
+        }
+        let dir = this._mutableRoot;
+        while (parts.length > 1) {
+            const part = parts.shift();
+            const result = dir.getOrAddDirectory(part);
+            /* c8 ignore next 3 - defensive: directory conflict during construction */
+            if (result.isFailure()) {
+                return fail(result.message);
+            }
+            dir = result.value;
+            if (!this._mutableByPath.has(dir.absolutePath)) {
+                this._mutableByPath.set(dir.absolutePath, dir);
+            }
+        }
+        return dir.addFile(parts[0], contents, contentType).onSuccess((file) => {
+            this._mutableByPath.set(file.absolutePath, file);
+            return succeed(file);
+        });
+    }
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeAccessors.createDirectory}
+     */
+    createDirectory(dirPath) {
+        const absolutePath = this.resolveAbsolutePath(dirPath);
+        // Check if mutability is disabled
+        if (this._mutable === false) {
+            return fail(`${absolutePath}: mutability is disabled`);
+        }
+        // Add to the TreeBuilder (read layer)
+        const treeResult = this._tree.addDirectory(absolutePath);
+        /* c8 ignore next 3 - defensive: read layer failure would indicate internal inconsistency */
+        if (treeResult.isFailure()) {
+            return fail(treeResult.message);
+        }
+        // Add to the mutable layer
+        const parts = absolutePath.split('/').filter((p) => p.length > 0);
+        let dir = this._mutableRoot;
+        for (const part of parts) {
+            const result = dir.getOrAddDirectory(part);
+            /* c8 ignore next 3 - defensive: mutable layer should match read layer state */
+            if (result.isFailure()) {
+                return fail(result.message);
+            }
+            dir = result.value;
+            if (!this._mutableByPath.has(dir.absolutePath)) {
+                this._mutableByPath.set(dir.absolutePath, dir);
+            }
+        }
+        return succeed(absolutePath);
+    }
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeAccessors.fileIsMutable}
+     */
+    fileIsMutable(path) {
+        const absolutePath = this.resolveAbsolutePath(path);
+        // Check if mutability is disabled
+        if (this._mutable === false) {
+            return failWithDetail(`${absolutePath}: mutability is disabled`, 'not-mutable');
+        }
+        // Check if path is excluded by filter
+        if (!isPathMutable(absolutePath, this._mutable)) {
+            return failWithDetail(`${absolutePath}: path is excluded by filter`, 'path-excluded');
+        }
+        return succeedWithDetail(true, 'transient');
+    }
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeAccessors.deleteFile}
+     */
+    deleteFile(path) {
+        const absolutePath = this.resolveAbsolutePath(path);
+        const parts = absolutePath.split('/').filter((p) => p.length > 0);
+        if (parts.length === 0) {
+            return fail(`${absolutePath}: invalid file path`);
+        }
+        const fileName = parts.pop();
+        // Navigate to parent directory
+        let dir = this._mutableRoot;
+        for (const part of parts) {
+            const child = dir.children.get(part);
+            if (!child || !(child instanceof MutableInMemoryDirectory)) {
+                return fail(`${absolutePath}: parent directory not found`);
+            }
+            dir = child;
+        }
+        if (!dir.removeChild(fileName)) {
+            return fail(`${absolutePath}: file not found`);
+        }
+        // Also remove from the read layer's directory children and path index
+        const parentPath = parts.length === 0 ? '/' : '/' + parts.join('/');
+        const readParent = this._tree.byAbsolutePath.get(parentPath);
+        if (readParent instanceof InMemoryDirectory) {
+            readParent.removeChild(fileName);
+        }
+        this._tree.byAbsolutePath.delete(absolutePath);
+        this._mutableByPath.delete(absolutePath);
+        return succeed(true);
+    }
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeAccessors.deleteDirectory}
+     */
+    deleteDirectory(path) {
+        const absolutePath = this.resolveAbsolutePath(path);
+        const parts = absolutePath.split('/').filter((p) => p.length > 0);
+        if (parts.length === 0) {
+            return fail(`${absolutePath}: invalid directory path`);
+        }
+        const dirName = parts.pop();
+        // Navigate to parent directory
+        let parentDir = this._mutableRoot;
+        for (const part of parts) {
+            const child = parentDir.children.get(part);
+            if (!child || !(child instanceof MutableInMemoryDirectory)) {
+                return fail(`${absolutePath}: parent directory not found`);
+            }
+            parentDir = child;
+        }
+        // Verify target is a directory
+        const target = parentDir.children.get(dirName);
+        if (!target || !(target instanceof MutableInMemoryDirectory)) {
+            return fail(`${absolutePath}: not a directory`);
+        }
+        // Check non-empty
+        if (target.children.size > 0) {
+            return fail(`${absolutePath}: directory is not empty`);
+        }
+        parentDir.removeChild(dirName);
+        // Also remove from the read layer
+        /* c8 ignore next 1 - defensive: branch for top-level directory deletion */
+        const readParentPath = parts.length === 0 ? '/' : '/' + parts.join('/');
+        const readParent = this._tree.byAbsolutePath.get(readParentPath);
+        if (readParent instanceof InMemoryDirectory) {
+            readParent.removeChild(dirName);
+        }
+        this._tree.byAbsolutePath.delete(absolutePath);
+        this._mutableByPath.delete(absolutePath);
+        return succeed(true);
+    }
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeAccessors.saveFileContents}
+     */
+    saveFileContents(path, contents) {
+        const isMutable = this.fileIsMutable(path);
+        if (isMutable.isFailure()) {
+            return fail(isMutable.message);
+        }
+        const absolutePath = this.resolveAbsolutePath(path);
+        const parts = absolutePath.split('/').filter((p) => p.length > 0);
+        if (parts.length === 0) {
+            return fail(`${absolutePath}: invalid file path`);
+        }
+        // Navigate to parent directory, creating directories as needed
+        let dir = this._mutableRoot;
+        while (parts.length > 1) {
+            const part = parts.shift();
+            const result = dir.getOrAddDirectory(part);
+            if (result.isFailure()) {
+                return fail(result.message);
+            }
+            dir = result.value;
+            if (!this._mutableByPath.has(dir.absolutePath)) {
+                this._mutableByPath.set(dir.absolutePath, dir);
+            }
+        }
+        // Update or add the file in the mutable layer
+        return dir.updateOrAddFile(parts[0], contents).onSuccess((file) => {
+            this._mutableByPath.set(file.absolutePath, file);
+            // Also register in the read layer so getItem/getChildren can find it
+            if (!this._tree.byAbsolutePath.has(file.absolutePath)) {
+                this._tree.addFile(file.absolutePath, contents);
+            }
+            return succeed(contents);
+        });
+    }
 }
 //# sourceMappingURL=inMemoryTree.js.map

package/dist/packlets/file-tree/in-memory/treeBuilder.js

@@ -90,6 +90,14 @@ export class InMemoryDirectory {
         this._children.set(name, child);
         return succeed(child);
     }
+    /**
+     * Removes a child from the directory.
+     * @param name - The name of the child to remove.
+     * @returns `true` if the child was found and removed, `false` otherwise.
+     */
+    removeChild(name) {
+        return this._children.delete(name);
+    }
     /**
      * Gets the absolute path for a child of this directory with the supplied
      * name.
@@ -169,5 +177,28 @@ export class TreeBuilder {
             return succeed(file);
         });
     }
+    /**
+     * Ensures a directory exists at the given absolute path, creating
+     * intermediate directories as needed.
+     * @param absolutePath - The absolute path of the directory.
+     * @returns `Success` with the directory if successful, or
+     * `Failure` with an error message otherwise.
+     * @public
+     */
+    addDirectory(absolutePath) {
+        const parts = absolutePath.split('/').filter((p) => p.length > 0);
+        let dir = this.root;
+        for (const part of parts) {
+            const result = dir.getOrAddDirectory(part);
+            if (result.isFailure()) {
+                return fail(result.message);
+            }
+            dir = result.value;
+            if (!this.byAbsolutePath.has(dir.absolutePath)) {
+                this.byAbsolutePath.set(dir.absolutePath, dir);
+            }
+        }
+        return succeed(dir);
+    }
 }
 //# sourceMappingURL=treeBuilder.js.map

package/dist/packlets/file-tree/index.browser.js

@@ -25,6 +25,7 @@ export * from './fileTreeAccessors';
 export * from './fileTree';
 export * from './directoryItem';
 export * from './fileItem';
+export * from './filterSpec';
 // Export in-memory implementations for web compatibility
 export * from './in-memory';
 export { inMemory } from './fileTreeHelpers.inMemory';

package/dist/packlets/file-tree/index.js

@@ -24,6 +24,7 @@ export * from './fileTreeAccessors';
 export * from './fileTree';
 export * from './directoryItem';
 export * from './fileItem';
+export * from './filterSpec';
 // Export tree-shakeable helpers (filesystem ones will be shaken out if not used)
 export * from './fileTreeHelpers';
 export { inMemory } from './fileTreeHelpers.inMemory';

package/dist/packlets/json-file/file.js

@@ -22,7 +22,7 @@
 import { DefaultJsonFsHelper, JsonFsHelper } from './jsonFsHelper';
 import { DefaultJsonLike } from './jsonLike';
 /**
- * {@inheritdoc JsonFile.JsonFsHelper.readJsonFileSync}
+ * {@inheritDoc JsonFile.JsonFsHelper.readJsonFileSync}
  * @public
  */
 export function readJsonFileSync(srcPath) {

package/dist/packlets/json-file/jsonFsHelper.js

@@ -48,7 +48,7 @@ export const DefaultJsonFsHelperConfig = {
 export class JsonFsHelper {
     /**
      * Construct a new {@link JsonFile.JsonFsHelper | JsonFsHelper}.
-     * @param json - Optional {@link JsonFile.IJsonLike | IJsonLike} used to process strings
+     * @param init - Optional {@link JsonFile.JsonFsHelperInitOptions | init options} to construct
      * and JSON values.
      */
     constructor(init) {