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

package/dist/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.54.0"
+      "packageVersion": "7.57.6"
     }
   ]
 }

package/lib/packlets/converters/converters.d.ts

@@ -16,7 +16,7 @@ export declare const jsonPrimitive: Converter<JsonPrimitive, IJsonConverterConte
  * An copying converter which converts a supplied `unknown` value into
  * a valid {@link JsonObject | JsonObject}. Fails by default if any properties or array elements
  * are `undefined` - this default behavior can be overridden by supplying an appropriate
- * {@link Converters.IJsonConverterContext | context} at runtime.
+ * `IJsonConverterContext` at runtime.
  *
  * Guaranteed to return a new object.
  * @public
@@ -26,7 +26,7 @@ export declare const jsonObject: Converter<JsonObject, IJsonConverterContext>;
  * An copying converter which converts a supplied `unknown` value to
  * a valid {@link JsonArray | JsonArray}. Fails by default if any properties or array elements
  * are `undefined` - this default behavior can be overridden by supplying an appropriate
- * {@link Converters.IJsonConverterContext | context} at runtime.
+ * `IJsonConverterContext` at runtime.
  *
  * Guaranteed to return a new array.
  * @public
@@ -36,50 +36,57 @@ export declare const jsonArray: Converter<JsonArray, IJsonConverterContext>;
  * An copying converter which converts a supplied `unknown` value to a
  * valid {@link JsonValue | JsonValue}. Fails by default if any properties or array elements
  * are `undefined` - this default behavior can be overridden by supplying an appropriate
- * {@link Converters.IJsonConverterContext | context} at runtime.
+ * `IJsonConverterContext` at runtime.
  * @public
  */
 export declare const jsonValue: Converter<JsonValue, IJsonConverterContext>;
 /**
- * A {@link Converter | Converter} which converts `unknown` to a `string`.
- * Accepts {@link Converters.IJsonConverterContext | IJsonConverterContext} but ignores it.
+ * A `StringConverter` which converts `unknown` to a `string`.
+ * Accepts `IJsonConverterContext` but ignores it.
  * @public
  */
 export declare const string: StringConverter<string, IJsonConverterContext>;
 /**
- * A {@link Converter | Converter} which converts `unknown` to a `number`.
- * Accepts {@link Converters.IJsonConverterContext | IJsonConverterContext} but ignores it.
+ * A `Converter` which converts `unknown` to a `number`.
+ * Accepts `IJsonConverterContext` but ignores it.
  * Mirrors the behavior of `@fgv/ts-utils`.
  * @public
  */
 export declare const number: Converter<number, IJsonConverterContext>;
 /**
- * A {@link Converter | Converter} which converts `unknown` to a `boolean`.
- * Accepts {@link Converters.IJsonConverterContext | IJsonConverterContext} but ignores it.
+ * A `Converter` which converts `unknown` to a `boolean`.
+ * Accepts `IJsonConverterContext` but ignores it.
  * Mirrors the behavior of `@fgv/ts-utils`.
  * @public
  */
 export declare const boolean: Converter<boolean, IJsonConverterContext>;
 /**
  * Helper to create a converter for a literal value.
- * Accepts {@link Converters.IJsonConverterContext | IJsonConverterContext} but ignores it.
+ * Accepts `IJsonConverterContext` but ignores it.
  * Mirrors the behavior of `@fgv/ts-utils`.
  * @public
  */
 export declare function literal<T>(value: T): Converter<T, IJsonConverterContext>;
 /**
- * Helper function to create a {@link Converter | Converter} which converts `unknown` to one of a set of
+ * Helper function to create a `Converter` which converts `unknown` to one of a set of
  * supplied enumerated values. Anything else fails.
  *
  * @remarks
- * This JSON variant accepts an {@link Converters.IJsonConverterContext | IJsonConverterContext} OR
+ * This JSON variant accepts an `IJsonConverterContext` OR
  * a `ReadonlyArray<T>` as its conversion context. If the context is an array, it is used to override the
  * allowed values for that conversion; otherwise, the original `values` supplied at creation time are used.
  *
  * @param values - Array of allowed values.
  * @param message - Optional custom failure message.
- * @returns A new {@link Converter | Converter} returning `<T>`.
+ * @returns A new `Converter` returning `<T>`.
  * @public
  */
 export declare function enumeratedValue<T>(values: ReadonlyArray<T>, message?: string): Converter<T, IJsonConverterContext | ReadonlyArray<T>>;
+/**
+ * Creates a converter that parses JSON string content and then applies the supplied converter.
+ * @param converter - Converter to apply to the parsed JSON
+ * @returns Converter that parses JSON then validates
+ * @public
+ */
+export declare function jsonConverter<T>(converter: Converter<T>): Converter<T>;
 //# sourceMappingURL=converters.d.ts.map

package/lib/packlets/converters/converters.js

@@ -24,6 +24,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.boolean = exports.number = exports.string = exports.jsonValue = exports.jsonArray = exports.jsonObject = exports.jsonPrimitive = void 0;
 exports.literal = literal;
 exports.enumeratedValue = enumeratedValue;
+exports.jsonConverter = jsonConverter;
 const ts_utils_1 = require("@fgv/ts-utils");
 const json_1 = require("../json");
 /**
@@ -50,7 +51,7 @@ exports.jsonPrimitive = new ts_utils_1.Conversion.BaseConverter((from, __self, c
  * An copying converter which converts a supplied `unknown` value into
  * a valid {@link JsonObject | JsonObject}. Fails by default if any properties or array elements
  * are `undefined` - this default behavior can be overridden by supplying an appropriate
- * {@link Converters.IJsonConverterContext | context} at runtime.
+ * `IJsonConverterContext` at runtime.
  *
  * Guaranteed to return a new object.
  * @public
@@ -86,7 +87,7 @@ exports.jsonObject = new ts_utils_1.Conversion.BaseConverter((from, __self, ctx)
  * An copying converter which converts a supplied `unknown` value to
  * a valid {@link JsonArray | JsonArray}. Fails by default if any properties or array elements
  * are `undefined` - this default behavior can be overridden by supplying an appropriate
- * {@link Converters.IJsonConverterContext | context} at runtime.
+ * `IJsonConverterContext` at runtime.
  *
  * Guaranteed to return a new array.
  * @public
@@ -124,7 +125,7 @@ exports.jsonArray = new ts_utils_1.Conversion.BaseConverter((from, __self, ctx)
  * An copying converter which converts a supplied `unknown` value to a
  * valid {@link JsonValue | JsonValue}. Fails by default if any properties or array elements
  * are `undefined` - this default behavior can be overridden by supplying an appropriate
- * {@link Converters.IJsonConverterContext | context} at runtime.
+ * `IJsonConverterContext` at runtime.
  * @public
  */
 exports.jsonValue = new ts_utils_1.Conversion.BaseConverter((from, __self, ctx) => {
@@ -137,28 +138,28 @@ exports.jsonValue = new ts_utils_1.Conversion.BaseConverter((from, __self, ctx)
     return exports.jsonPrimitive.convert(from, ctx);
 });
 /**
- * A {@link Converter | Converter} which converts `unknown` to a `string`.
- * Accepts {@link Converters.IJsonConverterContext | IJsonConverterContext} but ignores it.
+ * A `StringConverter` which converts `unknown` to a `string`.
+ * Accepts `IJsonConverterContext` but ignores it.
  * @public
  */
 exports.string = new ts_utils_1.StringConverter();
 /**
- * A {@link Converter | Converter} which converts `unknown` to a `number`.
- * Accepts {@link Converters.IJsonConverterContext | IJsonConverterContext} but ignores it.
+ * A `Converter` which converts `unknown` to a `number`.
+ * Accepts `IJsonConverterContext` but ignores it.
  * Mirrors the behavior of `@fgv/ts-utils`.
  * @public
  */
 exports.number = new ts_utils_1.Conversion.BaseConverter((from) => ts_utils_1.Converters.number.convert(from));
 /**
- * A {@link Converter | Converter} which converts `unknown` to a `boolean`.
- * Accepts {@link Converters.IJsonConverterContext | IJsonConverterContext} but ignores it.
+ * A `Converter` which converts `unknown` to a `boolean`.
+ * Accepts `IJsonConverterContext` but ignores it.
  * Mirrors the behavior of `@fgv/ts-utils`.
  * @public
  */
 exports.boolean = new ts_utils_1.Conversion.BaseConverter((from) => ts_utils_1.Converters.boolean.convert(from));
 /**
  * Helper to create a converter for a literal value.
- * Accepts {@link Converters.IJsonConverterContext | IJsonConverterContext} but ignores it.
+ * Accepts `IJsonConverterContext` but ignores it.
  * Mirrors the behavior of `@fgv/ts-utils`.
  * @public
  */
@@ -166,17 +167,17 @@ function literal(value) {
     return ts_utils_1.Converters.literal(value);
 }
 /**
- * Helper function to create a {@link Converter | Converter} which converts `unknown` to one of a set of
+ * Helper function to create a `Converter` which converts `unknown` to one of a set of
  * supplied enumerated values. Anything else fails.
  *
  * @remarks
- * This JSON variant accepts an {@link Converters.IJsonConverterContext | IJsonConverterContext} OR
+ * This JSON variant accepts an `IJsonConverterContext` OR
  * a `ReadonlyArray<T>` as its conversion context. If the context is an array, it is used to override the
  * allowed values for that conversion; otherwise, the original `values` supplied at creation time are used.
  *
  * @param values - Array of allowed values.
  * @param message - Optional custom failure message.
- * @returns A new {@link Converter | Converter} returning `<T>`.
+ * @returns A new `Converter` returning `<T>`.
  * @public
  */
 function enumeratedValue(values, message) {
@@ -189,4 +190,26 @@ function enumeratedValue(values, message) {
         return (0, ts_utils_1.fail)(message !== null && message !== void 0 ? message : `Invalid enumerated value ${JSON.stringify(from)}`);
     });
 }
+/**
+ * Creates a converter that parses JSON string content and then applies the supplied converter.
+ * @param converter - Converter to apply to the parsed JSON
+ * @returns Converter that parses JSON then validates
+ * @public
+ */
+function jsonConverter(converter) {
+    return new ts_utils_1.Conversion.BaseConverter((from) => {
+        if (typeof from !== 'string') {
+            return (0, ts_utils_1.fail)('Input must be a string');
+        }
+        const parseResult = (0, ts_utils_1.captureResult)(() => JSON.parse(from));
+        if (parseResult.isFailure()) {
+            return (0, ts_utils_1.fail)(`Failed to parse JSON: ${parseResult.message}`);
+        }
+        const parsed = parseResult.value;
+        if (typeof parsed !== 'object' || parsed === null) {
+            return (0, ts_utils_1.fail)('Failed to parse JSON: JSON content must be an object');
+        }
+        return converter.convert(parsed);
+    });
+}
 //# sourceMappingURL=converters.js.map

package/lib/packlets/file-tree/directoryItem.d.ts

@@ -1,20 +1,20 @@
 import { Result } from '@fgv/ts-utils';
-import { FileTreeItem, IFileTreeAccessors, IFileTreeDirectoryItem } from './fileTreeAccessors';
+import { FileTreeItem, IDeleteChildOptions, IFileTreeAccessors, IMutableFileTreeDirectoryItem, IMutableFileTreeFileItem } from './fileTreeAccessors';
 /**
  * Class representing a directory in a file tree.
  * @public
  */
-export declare class DirectoryItem<TCT extends string = string> implements IFileTreeDirectoryItem<TCT> {
+export declare class DirectoryItem<TCT extends string = string> implements IMutableFileTreeDirectoryItem<TCT> {
     /**
-     * {@inheritdoc FileTree.IFileTreeDirectoryItem."type"}
+     * {@inheritDoc FileTree.IFileTreeDirectoryItem."type"}
      */
     readonly type: 'directory';
     /**
-     * {@inheritdoc FileTree.IFileTreeDirectoryItem.absolutePath}
+     * {@inheritDoc FileTree.IFileTreeDirectoryItem.absolutePath}
      */
     readonly absolutePath: string;
     /**
-     * {@inheritdoc FileTree.IFileTreeDirectoryItem.name}
+     * {@inheritDoc FileTree.IFileTreeDirectoryItem.name}
      */
     get name(): string;
     /**
@@ -40,8 +40,31 @@ export declare class DirectoryItem<TCT extends string = string> implements IFile
      */
     static create<TCT extends string = string>(path: string, hal: IFileTreeAccessors<TCT>): Result<DirectoryItem<TCT>>;
     /**
-     * {@inheritdoc FileTree.IFileTreeDirectoryItem.getChildren}
+     * {@inheritDoc FileTree.IFileTreeDirectoryItem.getChildren}
      */
     getChildren(): Result<ReadonlyArray<FileTreeItem<TCT>>>;
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeDirectoryItem.createChildFile}
+     */
+    createChildFile(name: string, contents: string): Result<IMutableFileTreeFileItem<TCT>>;
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeDirectoryItem.createChildDirectory}
+     */
+    createChildDirectory(name: string): Result<IMutableFileTreeDirectoryItem<TCT>>;
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeDirectoryItem.deleteChild}
+     */
+    deleteChild(name: string, options?: IDeleteChildOptions): Result<boolean>;
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeDirectoryItem.delete}
+     */
+    delete(): Result<boolean>;
+    /**
+     * 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
+     */
+    private _deleteRecursive;
 }
 //# sourceMappingURL=directoryItem.d.ts.map

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

@@ -23,13 +23,14 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DirectoryItem = void 0;
 const ts_utils_1 = require("@fgv/ts-utils");
+const fileTreeAccessors_1 = require("./fileTreeAccessors");
 /**
  * Class representing a directory in a file tree.
  * @public
  */
 class DirectoryItem {
     /**
-     * {@inheritdoc FileTree.IFileTreeDirectoryItem.name}
+     * {@inheritDoc FileTree.IFileTreeDirectoryItem.name}
      */
     get name() {
         return this._hal.getBaseName(this.absolutePath);
@@ -43,7 +44,7 @@ class DirectoryItem {
      */
     constructor(path, hal) {
         /**
-         * {@inheritdoc FileTree.IFileTreeDirectoryItem."type"}
+         * {@inheritDoc FileTree.IFileTreeDirectoryItem."type"}
          */
         this.type = 'directory';
         this._hal = hal;
@@ -61,11 +62,105 @@ class DirectoryItem {
         return (0, ts_utils_1.captureResult)(() => new DirectoryItem(path, hal));
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeDirectoryItem.getChildren}
+     * {@inheritDoc FileTree.IFileTreeDirectoryItem.getChildren}
      */
     getChildren() {
         return this._hal.getChildren(this.absolutePath);
     }
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeDirectoryItem.createChildFile}
+     */
+    createChildFile(name, contents) {
+        const hal = this._hal;
+        if (!(0, fileTreeAccessors_1.isMutableAccessors)(hal)) {
+            /* c8 ignore next 2 - defensive: all current accessor implementations support mutation interface */
+            return (0, ts_utils_1.fail)(`${this.absolutePath}: mutation not supported`);
+        }
+        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 (!(0, fileTreeAccessors_1.isMutableFileItem)(item)) {
+                return (0, ts_utils_1.fail)(`${filePath}: expected mutable file but got ${item.type}`);
+            }
+            return (0, ts_utils_1.succeed)(item);
+        }));
+    }
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeDirectoryItem.createChildDirectory}
+     */
+    createChildDirectory(name) {
+        const hal = this._hal;
+        if (!(0, fileTreeAccessors_1.isMutableAccessors)(hal)) {
+            /* c8 ignore next 2 - defensive: all current accessor implementations support mutation interface */
+            return (0, ts_utils_1.fail)(`${this.absolutePath}: mutation 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 (!(0, fileTreeAccessors_1.isMutableAccessors)(hal)) {
+            /* c8 ignore next 2 - defensive: all current accessor implementations support mutation interface */
+            return (0, ts_utils_1.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 (!(0, fileTreeAccessors_1.isMutableAccessors)(hal)) {
+            /* c8 ignore next 2 - defensive: all current accessor implementations support mutation interface */
+            return (0, ts_utils_1.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 (!(0, fileTreeAccessors_1.isMutableAccessors)(hal)) {
+            return (0, ts_utils_1.fail)(`${dirPath}: mutation not supported`);
+        }
+        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);
+        });
+    }
 }
 exports.DirectoryItem = DirectoryItem;
 //# sourceMappingURL=directoryItem.js.map

package/lib/packlets/file-tree/fileItem.d.ts

@@ -1,34 +1,34 @@
-import { Result } from '@fgv/ts-utils';
+import { DetailedResult, Result } from '@fgv/ts-utils';
 import { Converter, Validator } from '@fgv/ts-utils';
 import { JsonValue } from '../json';
-import { IFileTreeAccessors, IFileTreeFileItem } from './fileTreeAccessors';
+import { IFileTreeAccessors, IMutableFileTreeFileItem, SaveDetail } from './fileTreeAccessors';
 /**
  * Class representing a file in a file tree.
  * @public
  */
-export declare class FileItem<TCT extends string = string> implements IFileTreeFileItem<TCT> {
+export declare class FileItem<TCT extends string = string> implements IMutableFileTreeFileItem<TCT> {
     /**
-     * {@inheritdoc FileTree.IFileTreeFileItem."type"}
+     * {@inheritDoc FileTree.IFileTreeFileItem."type"}
      */
     readonly type: 'file';
     /**
-     * {@inheritdoc FileTree.IFileTreeFileItem.absolutePath}
+     * {@inheritDoc FileTree.IFileTreeFileItem.absolutePath}
      */
     readonly absolutePath: string;
     /**
-     * {@inheritdoc FileTree.IFileTreeFileItem.name}
+     * {@inheritDoc FileTree.IFileTreeFileItem.name}
      */
     get name(): string;
     /**
-     * {@inheritdoc FileTree.IFileTreeFileItem.baseName}
+     * {@inheritDoc FileTree.IFileTreeFileItem.baseName}
      */
     get baseName(): string;
     /**
-     * {@inheritdoc FileTree.IFileTreeFileItem.extension}
+     * {@inheritDoc FileTree.IFileTreeFileItem.extension}
      */
     get extension(): string;
     /**
-     * {@inheritdoc FileTree.IFileTreeFileItem.contentType}
+     * {@inheritDoc FileTree.IFileTreeFileItem.contentType}
      */
     get contentType(): TCT | undefined;
     /**
@@ -58,15 +58,19 @@ export declare class FileItem<TCT extends string = string> implements IFileTreeF
      */
     static create<TCT extends string = string>(path: string, hal: IFileTreeAccessors<TCT>): Result<FileItem<TCT>>;
     /**
-     * {@inheritdoc FileTree.IFileTreeFileItem.(getContents:1)}
+     * {@inheritDoc FileTree.IFileTreeFileItem.getIsMutable}
+     */
+    getIsMutable(): DetailedResult<boolean, SaveDetail>;
+    /**
+     * {@inheritDoc FileTree.IFileTreeFileItem.getContents}
      */
     getContents(): Result<JsonValue>;
     /**
-     * {@inheritdoc FileTree.IFileTreeFileItem.(getContents:2)}
+     * {@inheritDoc FileTree.IFileTreeFileItem.getContents}
      */
     getContents<T>(converter: Validator<T> | Converter<T>): Result<T>;
     /**
-     * {@inheritdoc FileTree.IFileTreeFileItem.getRawContents}
+     * {@inheritDoc FileTree.IFileTreeFileItem.getRawContents}
      */
     getRawContents(): Result<string>;
     /**
@@ -74,15 +78,28 @@ export declare class FileItem<TCT extends string = string> implements IFileTreeF
      * @param contentType - The content type of the file.
      */
     setContentType(contentType: TCT | undefined): void;
+    /**
+     * {@inheritDoc FileTree.IFileTreeFileItem.setContents}
+     */
+    setContents(json: JsonValue): Result<JsonValue>;
+    /**
+     * {@inheritDoc FileTree.IFileTreeFileItem.setRawContents}
+     */
+    setRawContents(contents: string): Result<string>;
+    /**
+     * {@inheritDoc FileTree.IFileTreeFileItem.delete}
+     */
+    delete(): Result<boolean>;
     /**
      * Default function to infer the content type of a file.
      * @param filePath - The path of the file.
+     * @param provided - Optional supplied content type.
      * @returns `Success` with the content type of the file if successful, or
      * `Failure` with an error message otherwise.
      * @remarks This default implementation always returns `Success` with `undefined`.
      * @public
      */
-    static defaultInferContentType<TCT extends string = string>(__filePath: string, __provided?: string): Result<TCT | undefined>;
+    static defaultInferContentType<TCT extends string = string>(filePath: string, provided?: string): Result<TCT | undefined>;
     /**
      * Default function to accept the content type of a file.
      * @param filePath - The path of the file.
@@ -92,6 +109,6 @@ export declare class FileItem<TCT extends string = string> implements IFileTreeF
      * @remarks This default implementation always returns `Success` with `undefined`.
      * @public
      */
-    static defaultAcceptContentType<TCT extends string = string>(__filePath: string, provided?: TCT): Result<TCT | undefined>;
+    static defaultAcceptContentType<TCT extends string = string>(filePath: string, provided?: TCT): Result<TCT | undefined>;
 }
 //# sourceMappingURL=fileItem.d.ts.map

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

@@ -23,31 +23,32 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FileItem = void 0;
 const ts_utils_1 = require("@fgv/ts-utils");
+const fileTreeAccessors_1 = require("./fileTreeAccessors");
 /**
  * Class representing a file in a file tree.
  * @public
  */
 class FileItem {
     /**
-     * {@inheritdoc FileTree.IFileTreeFileItem.name}
+     * {@inheritDoc FileTree.IFileTreeFileItem.name}
      */
     get name() {
         return this._hal.getBaseName(this.absolutePath);
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeFileItem.baseName}
+     * {@inheritDoc FileTree.IFileTreeFileItem.baseName}
      */
     get baseName() {
         return this._hal.getBaseName(this.absolutePath, this.extension);
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeFileItem.extension}
+     * {@inheritDoc FileTree.IFileTreeFileItem.extension}
      */
     get extension() {
         return this._hal.getExtension(this.absolutePath);
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeFileItem.contentType}
+     * {@inheritDoc FileTree.IFileTreeFileItem.contentType}
      */
     get contentType() {
         return this._contentType;
@@ -61,7 +62,7 @@ class FileItem {
      */
     constructor(path, hal) {
         /**
-         * {@inheritdoc FileTree.IFileTreeFileItem."type"}
+         * {@inheritDoc FileTree.IFileTreeFileItem."type"}
          */
         this.type = 'file';
         this._hal = hal;
@@ -78,6 +79,16 @@ class FileItem {
     static create(path, hal) {
         return (0, ts_utils_1.captureResult)(() => new FileItem(path, hal));
     }
+    /**
+     * {@inheritDoc FileTree.IFileTreeFileItem.getIsMutable}
+     */
+    getIsMutable() {
+        if ((0, fileTreeAccessors_1.isMutableAccessors)(this._hal)) {
+            return this._hal.fileIsMutable(this.absolutePath);
+        }
+        /* c8 ignore next 2 - defensive: all current accessor implementations support mutation interface */
+        return (0, ts_utils_1.failWithDetail)(`${this.absolutePath}: mutation not supported`, 'not-supported');
+    }
     getContents(converter) {
         return this._hal
             .getFileContents(this.absolutePath)
@@ -90,7 +101,7 @@ class FileItem {
         });
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeFileItem.getRawContents}
+     * {@inheritDoc FileTree.IFileTreeFileItem.getRawContents}
      */
     getRawContents() {
         return this._hal.getFileContents(this.absolutePath);
@@ -102,15 +113,42 @@ class FileItem {
     setContentType(contentType) {
         this._contentType = contentType;
     }
+    /**
+     * {@inheritDoc FileTree.IFileTreeFileItem.setContents}
+     */
+    setContents(json) {
+        return (0, ts_utils_1.captureResult)(() => JSON.stringify(json, null, 2)).onSuccess((contents) => this.setRawContents(contents).onSuccess(() => ts_utils_1.Success.with(json)));
+    }
+    /**
+     * {@inheritDoc FileTree.IFileTreeFileItem.setRawContents}
+     */
+    setRawContents(contents) {
+        if ((0, fileTreeAccessors_1.isMutableAccessors)(this._hal)) {
+            return this._hal.saveFileContents(this.absolutePath, contents);
+        }
+        /* c8 ignore next 2 - defensive: all current accessor implementations support mutation interface */
+        return (0, ts_utils_1.fail)(`${this.absolutePath}: mutation not supported`);
+    }
+    /**
+     * {@inheritDoc FileTree.IFileTreeFileItem.delete}
+     */
+    delete() {
+        if (!(0, fileTreeAccessors_1.isMutableAccessors)(this._hal)) {
+            /* c8 ignore next 2 - defensive: all current accessor implementations support mutation interface */
+            return (0, ts_utils_1.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.
+     * @param provided - Optional supplied content type.
      * @returns `Success` with the content type of the file if successful, or
      * `Failure` with an error message otherwise.
      * @remarks This default implementation always returns `Success` with `undefined`.
      * @public
      */
-    static defaultInferContentType(__filePath, __provided) {
+    static defaultInferContentType(filePath, provided) {
         return (0, ts_utils_1.succeed)(undefined);
     }
     /**
@@ -122,7 +160,7 @@ class FileItem {
      * @remarks This default implementation always returns `Success` with `undefined`.
      * @public
      */
-    static defaultAcceptContentType(__filePath, provided) {
+    static defaultAcceptContentType(filePath, provided) {
         return (0, ts_utils_1.succeed)(provided);
     }
 }