@fgv/ts-json-base 5.1.0-0 → 5.1.0-2

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

@@ -20,7 +20,7 @@
  * SOFTWARE.
  */
 import { captureResult, fail, succeed } from '@fgv/ts-utils';
-import { isMutableAccessors } from './fileTreeAccessors';
+import { isMutableAccessors, isMutableFileItem } from './fileTreeAccessors';
 /**
  * Class representing a directory in a file tree.
  * @public
@@ -65,34 +65,98 @@ export class DirectoryItem {
         return this._hal.getChildren(this.absolutePath);
     }
     /**
-     * {@inheritDoc FileTree.IFileTreeDirectoryItem.createChildFile}
+     * {@inheritDoc FileTree.IMutableFileTreeDirectoryItem.createChildFile}
      */
     createChildFile(name, contents) {
-        if (!isMutableAccessors(this._hal)) {
+        const hal = this._hal;
+        if (!isMutableAccessors(hal)) {
+            /* c8 ignore next 2 - defensive: all current accessor implementations support mutation interface */
             return fail(`${this.absolutePath}: mutation not supported`);
         }
-        const filePath = this._hal.joinPaths(this.absolutePath, name);
-        return this._hal.saveFileContents(filePath, contents).onSuccess(() => this._hal.getItem(filePath).onSuccess((item) => {
+        const filePath = hal.joinPaths(this.absolutePath, name);
+        return hal.saveFileContents(filePath, contents).onSuccess(() => hal.getItem(filePath).onSuccess((item) => {
             /* c8 ignore next 3 - defensive: verifies accessor returned correct item type after save */
-            if (item.type !== 'file') {
-                return fail(`${filePath}: expected file but got ${item.type}`);
+            if (!isMutableFileItem(item)) {
+                return fail(`${filePath}: expected mutable file but got ${item.type}`);
             }
             return succeed(item);
         }));
     }
     /**
-     * {@inheritDoc FileTree.IFileTreeDirectoryItem.createChildDirectory}
+     * {@inheritDoc FileTree.IMutableFileTreeDirectoryItem.createChildDirectory}
      */
     createChildDirectory(name) {
-        if (!isMutableAccessors(this._hal)) {
+        const hal = this._hal;
+        if (!isMutableAccessors(hal)) {
+            /* c8 ignore next 2 - defensive: all current accessor implementations support mutation interface */
             return fail(`${this.absolutePath}: mutation not supported`);
         }
-        /* c8 ignore next 3 - defensive: createDirectory should always exist if isMutableAccessors is true */
-        if (this._hal.createDirectory === undefined) {
-            return fail(`${this.absolutePath}: directory creation not supported`);
+        const dirPath = hal.joinPaths(this.absolutePath, name);
+        return hal.createDirectory(dirPath).onSuccess(() => DirectoryItem.create(dirPath, hal));
+    }
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeDirectoryItem.deleteChild}
+     */
+    deleteChild(name, options) {
+        const hal = this._hal;
+        if (!isMutableAccessors(hal)) {
+            /* c8 ignore next 2 - defensive: all current accessor implementations support mutation interface */
+            return fail(`${this.absolutePath}: mutation not supported`);
+        }
+        const childPath = hal.joinPaths(this.absolutePath, name);
+        return hal.getItem(childPath).onSuccess((item) => {
+            if (item.type === 'file') {
+                return hal.deleteFile(childPath);
+            }
+            // Directory child
+            if (options === null || options === void 0 ? void 0 : options.recursive) {
+                return this._deleteRecursive(childPath);
+            }
+            return hal.deleteDirectory(childPath);
+        });
+    }
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeDirectoryItem.delete}
+     */
+    delete() {
+        const hal = this._hal;
+        if (!isMutableAccessors(hal)) {
+            /* c8 ignore next 2 - defensive: all current accessor implementations support mutation interface */
+            return fail(`${this.absolutePath}: mutation not supported`);
+        }
+        return hal.deleteDirectory(this.absolutePath);
+    }
+    /**
+     * Recursively deletes all children of a directory and then the directory itself.
+     * @param dirPath - The absolute path of the directory to delete.
+     * @returns `Success` with `true` if the directory was deleted, or `Failure` with an error message.
+     * @internal
+     */
+    _deleteRecursive(dirPath) {
+        const hal = this._hal;
+        /* c8 ignore next 3 - defensive: caller already verified mutable */
+        if (!isMutableAccessors(hal)) {
+            return fail(`${dirPath}: mutation not supported`);
         }
-        const dirPath = this._hal.joinPaths(this.absolutePath, name);
-        return this._hal.createDirectory(dirPath).onSuccess(() => DirectoryItem.create(dirPath, this._hal));
+        return hal.getChildren(dirPath).onSuccess((children) => {
+            for (const child of children) {
+                if (child.type === 'file') {
+                    const result = hal.deleteFile(child.absolutePath);
+                    /* c8 ignore next 3 - defensive: error propagation during recursive delete */
+                    if (result.isFailure()) {
+                        return result;
+                    }
+                }
+                else {
+                    const result = this._deleteRecursive(child.absolutePath);
+                    /* c8 ignore next 3 - defensive: error propagation during recursive delete */
+                    if (result.isFailure()) {
+                        return result;
+                    }
+                }
+            }
+            return hal.deleteDirectory(dirPath);
+        });
     }
 }
 //# sourceMappingURL=directoryItem.js.map

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

@@ -126,6 +126,16 @@ export class FileItem {
         /* c8 ignore next 2 - defensive: all current accessor implementations support mutation interface */
         return fail(`${this.absolutePath}: mutation not supported`);
     }
+    /**
+     * {@inheritDoc FileTree.IFileTreeFileItem.delete}
+     */
+    delete() {
+        if (!isMutableAccessors(this._hal)) {
+            /* c8 ignore next 2 - defensive: all current accessor implementations support mutation interface */
+            return fail(`${this.absolutePath}: mutation not supported`);
+        }
+        return this._hal.deleteFile(this.absolutePath);
+    }
     /**
      * Default function to infer the content type of a file.
      * @param filePath - The path of the file.

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

@@ -19,6 +19,9 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
+// ============================================================================
+// Type Guards
+// ============================================================================
 /**
  * Type guard to check if accessors support mutation.
  * @param accessors - The accessors to check.
@@ -27,7 +30,11 @@
  */
 export function isMutableAccessors(accessors) {
     const mutable = accessors;
-    return typeof mutable.fileIsMutable === 'function' && typeof mutable.saveFileContents === 'function';
+    return (typeof mutable.fileIsMutable === 'function' &&
+        typeof mutable.saveFileContents === 'function' &&
+        typeof mutable.deleteFile === 'function' &&
+        typeof mutable.createDirectory === 'function' &&
+        typeof mutable.deleteDirectory === 'function');
 }
 /**
  * Type guard to check if accessors support persistence.
@@ -43,4 +50,32 @@ export function isPersistentAccessors(accessors) {
         typeof persistent.isDirty === 'function' &&
         typeof persistent.getDirtyPaths === 'function');
 }
+/**
+ * Type guard to check if a file item supports mutation.
+ * @param item - The file item to check.
+ * @returns `true` if the item implements {@link FileTree.IMutableFileTreeFileItem}.
+ * @public
+ */
+export function isMutableFileItem(item) {
+    const mutable = item;
+    return (mutable.type === 'file' &&
+        typeof mutable.getIsMutable === 'function' &&
+        typeof mutable.setContents === 'function' &&
+        typeof mutable.setRawContents === 'function' &&
+        typeof mutable.delete === 'function');
+}
+/**
+ * Type guard to check if a directory item supports mutation.
+ * @param item - The directory item to check.
+ * @returns `true` if the item implements {@link FileTree.IMutableFileTreeDirectoryItem}.
+ * @public
+ */
+export function isMutableDirectoryItem(item) {
+    const mutable = item;
+    return (mutable.type === 'directory' &&
+        typeof mutable.createChildFile === 'function' &&
+        typeof mutable.createChildDirectory === 'function' &&
+        typeof mutable.deleteChild === 'function' &&
+        typeof mutable.delete === 'function');
+}
 //# sourceMappingURL=fileTreeAccessors.js.map

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

@@ -148,6 +148,7 @@ export class FsFileTreeAccessors {
                 }
             }
             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');
@@ -165,6 +166,22 @@ export class FsFileTreeAccessors {
             });
         });
     }
+    /**
+     * {@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}
      */
@@ -179,5 +196,22 @@ export class FsFileTreeAccessors {
             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

@@ -92,6 +92,9 @@ class MutableInMemoryDirectory {
         }
         return this.addFile(name, contents, contentType);
     }
+    removeChild(name) {
+        return this._children.delete(name);
+    }
 }
 /**
  * Implementation of {@link FileTree.IMutableFileTreeAccessors} that uses an in-memory
@@ -320,6 +323,78 @@ export class InMemoryTreeAccessors {
         }
         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}
      */

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.