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

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

@@ -26,9 +26,79 @@ const ts_utils_1 = require("@fgv/ts-utils");
 const directoryItem_1 = require("../directoryItem");
 const fileItem_1 = require("../fileItem");
 const treeBuilder_1 = require("./treeBuilder");
+const filterSpec_1 = require("../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 (0, ts_utils_1.fail)(`${name}: already exists`);
+        }
+        const child = new MutableInMemoryFile(this.getChildPath(name), contents, contentType);
+        this._children.set(name, child);
+        return (0, ts_utils_1.succeed)(child);
+    }
+    getOrAddDirectory(name) {
+        const existing = this._children.get(name);
+        if (existing) {
+            if (existing instanceof MutableInMemoryDirectory) {
+                return (0, ts_utils_1.succeed)(existing);
+            }
+            return (0, ts_utils_1.fail)(`${name}: not a directory`);
+        }
+        const child = new MutableInMemoryDirectory(this.getChildPath(name));
+        this._children.set(name, child);
+        return (0, ts_utils_1.succeed)(child);
+    }
+    updateOrAddFile(name, contents, contentType) {
+        const existing = this._children.get(name);
+        if (existing) {
+            if (existing instanceof MutableInMemoryFile) {
+                existing.setContents(contents);
+                return (0, ts_utils_1.succeed)(existing);
+            }
+            return (0, ts_utils_1.fail)(`${name}: not a file`);
+        }
+        return this.addFile(name, contents, contentType);
+    }
+}
+/**
+ * Implementation of {@link FileTree.IMutableFileTreeAccessors} that uses an in-memory
+ * tree to access and modify files and directories.
  * @public
  */
 class InMemoryTreeAccessors {
@@ -39,12 +109,18 @@ class InMemoryTreeAccessors {
      * @public
      */
     constructor(files, params) {
-        var _a, _b;
+        var _a, _b, _c, _d;
         this._tree = treeBuilder_1.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_1.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);
         }
     }
     /**
@@ -59,7 +135,7 @@ class InMemoryTreeAccessors {
         return (0, ts_utils_1.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];
@@ -67,7 +143,7 @@ class InMemoryTreeAccessors {
         return `/${joined}`;
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getExtension}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getExtension}
      */
     getExtension(path) {
         const parts = path.split('.');
@@ -77,7 +153,7 @@ class InMemoryTreeAccessors {
         return `.${parts.pop()}`;
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getBaseName}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getBaseName}
      */
     getBaseName(path, suffix) {
         var _a;
@@ -89,13 +165,15 @@ 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);
@@ -110,26 +188,24 @@ class InMemoryTreeAccessors {
         return (0, ts_utils_1.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 (0, ts_utils_1.fail)(`${path}: not found`);
+            return (0, ts_utils_1.fail)(`${absolutePath}: not found`);
         }
-        /* c8 ignore next 3 - local coverage is 100% but build coverage has intermittent issues */
-        if (!(item instanceof treeBuilder_1.InMemoryFile)) {
-            return (0, ts_utils_1.fail)(`${path}: not a file`);
+        if (!(item instanceof MutableInMemoryFile)) {
+            return (0, ts_utils_1.fail)(`${absolutePath}: not a file`);
         }
-        // if the body is a string we don't want to add quotes
         if (typeof item.contents === 'string') {
             return (0, ts_utils_1.succeed)(item.contents);
         }
-        /* c8 ignore next 2 - local coverage is 100% but build coverage has intermittent issues */
         return (0, ts_utils_1.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)
@@ -152,7 +228,7 @@ class InMemoryTreeAccessors {
         return this._inferContentType(path);
     }
     /**
-     * {@inheritdoc FileTree.IFileTreeAccessors.getChildren}
+     * {@inheritDoc FileTree.IFileTreeAccessors.getChildren}
      */
     getChildren(path) {
         const item = this._tree.byAbsolutePath.get(path);
@@ -176,6 +252,113 @@ 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 (0, ts_utils_1.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 (0, ts_utils_1.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 (0, ts_utils_1.succeed)(file);
+        });
+    }
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeAccessors.createDirectory}
+     */
+    createDirectory(dirPath) {
+        const absolutePath = this.resolveAbsolutePath(dirPath);
+        // Check if mutability is disabled
+        if (this._mutable === false) {
+            return (0, ts_utils_1.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 (0, ts_utils_1.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 (0, ts_utils_1.fail)(result.message);
+            }
+            dir = result.value;
+            if (!this._mutableByPath.has(dir.absolutePath)) {
+                this._mutableByPath.set(dir.absolutePath, dir);
+            }
+        }
+        return (0, ts_utils_1.succeed)(absolutePath);
+    }
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeAccessors.fileIsMutable}
+     */
+    fileIsMutable(path) {
+        const absolutePath = this.resolveAbsolutePath(path);
+        // Check if mutability is disabled
+        if (this._mutable === false) {
+            return (0, ts_utils_1.failWithDetail)(`${absolutePath}: mutability is disabled`, 'not-mutable');
+        }
+        // Check if path is excluded by filter
+        if (!(0, filterSpec_1.isPathMutable)(absolutePath, this._mutable)) {
+            return (0, ts_utils_1.failWithDetail)(`${absolutePath}: path is excluded by filter`, 'path-excluded');
+        }
+        return (0, ts_utils_1.succeedWithDetail)(true, 'transient');
+    }
+    /**
+     * {@inheritDoc FileTree.IMutableFileTreeAccessors.saveFileContents}
+     */
+    saveFileContents(path, contents) {
+        const isMutable = this.fileIsMutable(path);
+        if (isMutable.isFailure()) {
+            return (0, ts_utils_1.fail)(isMutable.message);
+        }
+        const absolutePath = this.resolveAbsolutePath(path);
+        const parts = absolutePath.split('/').filter((p) => p.length > 0);
+        if (parts.length === 0) {
+            return (0, ts_utils_1.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 (0, ts_utils_1.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 (0, ts_utils_1.succeed)(contents);
+        });
+    }
 }
 exports.InMemoryTreeAccessors = InMemoryTreeAccessors;
 //# sourceMappingURL=inMemoryTree.js.map

package/lib/packlets/file-tree/in-memory/treeBuilder.d.ts

@@ -109,5 +109,14 @@ export declare class TreeBuilder<TCT extends string = string> {
      * @public
      */
     addFile(absolutePath: string, contents: unknown, contentType?: TCT): Result<InMemoryFile<TCT>>;
+    /**
+     * 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: string): Result<InMemoryDirectory<TCT>>;
 }
 //# sourceMappingURL=treeBuilder.d.ts.map

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

@@ -174,6 +174,29 @@ class TreeBuilder {
             return (0, ts_utils_1.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 (0, ts_utils_1.fail)(result.message);
+            }
+            dir = result.value;
+            if (!this.byAbsolutePath.has(dir.absolutePath)) {
+                this.byAbsolutePath.set(dir.absolutePath, dir);
+            }
+        }
+        return (0, ts_utils_1.succeed)(dir);
+    }
 }
 exports.TreeBuilder = TreeBuilder;
 //# sourceMappingURL=treeBuilder.js.map

package/lib/packlets/file-tree/index.browser.d.ts

@@ -2,6 +2,7 @@ export * from './fileTreeAccessors';
 export * from './fileTree';
 export * from './directoryItem';
 export * from './fileItem';
+export * from './filterSpec';
 export * from './in-memory';
 export { inMemory } from './fileTreeHelpers.inMemory';
 //# sourceMappingURL=index.browser.d.ts.map

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

@@ -42,6 +42,7 @@ __exportStar(require("./fileTreeAccessors"), exports);
 __exportStar(require("./fileTree"), exports);
 __exportStar(require("./directoryItem"), exports);
 __exportStar(require("./fileItem"), exports);
+__exportStar(require("./filterSpec"), exports);
 // Export in-memory implementations for web compatibility
 __exportStar(require("./in-memory"), exports);
 var fileTreeHelpers_inMemory_1 = require("./fileTreeHelpers.inMemory");

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

@@ -2,6 +2,7 @@ export * from './fileTreeAccessors';
 export * from './fileTree';
 export * from './directoryItem';
 export * from './fileItem';
+export * from './filterSpec';
 export * from './fileTreeHelpers';
 export { inMemory } from './fileTreeHelpers.inMemory';
 export * from './in-memory';

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

@@ -41,6 +41,7 @@ __exportStar(require("./fileTreeAccessors"), exports);
 __exportStar(require("./fileTree"), exports);
 __exportStar(require("./directoryItem"), exports);
 __exportStar(require("./fileItem"), exports);
+__exportStar(require("./filterSpec"), exports);
 // Export tree-shakeable helpers (filesystem ones will be shaken out if not used)
 __exportStar(require("./fileTreeHelpers"), exports);
 var fileTreeHelpers_inMemory_1 = require("./fileTreeHelpers.inMemory");

package/lib/packlets/json-file/file.d.ts

@@ -2,7 +2,7 @@ import { Converter, Result } from '@fgv/ts-utils';
 import { JsonValue } from '../json';
 import { IJsonFsDirectoryOptions, IJsonFsDirectoryToMapOptions, IReadDirectoryItem } from './jsonFsHelper';
 /**
- * {@inheritdoc JsonFile.JsonFsHelper.readJsonFileSync}
+ * {@inheritDoc JsonFile.JsonFsHelper.readJsonFileSync}
  * @public
  */
 export declare function readJsonFileSync(srcPath: string): Result<JsonValue>;

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

@@ -29,7 +29,7 @@ exports.writeJsonFileSync = writeJsonFileSync;
 const jsonFsHelper_1 = require("./jsonFsHelper");
 const jsonLike_1 = require("./jsonLike");
 /**
- * {@inheritdoc JsonFile.JsonFsHelper.readJsonFileSync}
+ * {@inheritDoc JsonFile.JsonFsHelper.readJsonFileSync}
  * @public
  */
 function readJsonFileSync(srcPath) {

package/lib/packlets/json-file/jsonFsHelper.d.ts

@@ -74,7 +74,7 @@ export declare class JsonFsHelper {
     readonly config: IJsonFsHelperConfig;
     /**
      * 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?: JsonFsHelperInitOptions);

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

@@ -54,7 +54,7 @@ exports.DefaultJsonFsHelperConfig = {
 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) {

package/lib/packlets/validators/validators.d.ts

@@ -38,42 +38,42 @@ export declare const jsonArray: Validator<JsonArray, IJsonValidatorContext>;
  */
 export declare const jsonValue: Validator<JsonValue, IJsonValidatorContext>;
 /**
- * A {@link Validation.Classes.StringValidator | StringValidator} which validates a string in place.
+ * A `StringValidator` which validates a string in place.
  * Accepts {@link Validators.IJsonValidatorContext | IJsonValidatorContext} but ignores it.
  * @public
  */
 export declare const string: Validation.Classes.StringValidator<string, IJsonValidatorContext>;
 /**
- * A {@link Validation.Classes.NumberValidator | NumberValidator} which validates a number in place.
+ * A `NumberValidator` which validates a number in place.
  * Accepts {@link Validators.IJsonValidatorContext | IJsonValidatorContext} but ignores it.
  * @public
  */
-export declare const number: Validator<number, IJsonValidatorContext>;
+export declare const number: Validation.Classes.NumberValidator<number, IJsonValidatorContext>;
 /**
- * A {@link Validation.Classes.BooleanValidator | BooleanValidator} which validates a boolean in place.
- * Accepts {@link Validators.IJsonValidatorContext | IJsonValidatorContext} but ignores it.
+ * A `BooleanValidator` which validates a boolean in place.
+ * Accepts `IJsonValidatorContext` but ignores it.
  * @public
  */
 export declare const boolean: Validator<boolean, IJsonValidatorContext>;
 /**
  * Helper to create a validator for a literal value.
- * Accepts {@link Validators.IJsonValidatorContext | IJsonValidatorContext} but ignores it.
+ * Accepts `IJsonValidatorContext` but ignores it.
  * Mirrors the behavior of `@fgv/ts-utils`.
  * @public
  */
 export declare function literal<T>(value: T): Validator<T, IJsonValidatorContext>;
 /**
- * Helper function to create a {@link Validator | Validator} which validates `unknown` to one of a set of
+ * Helper function to create a `Validator` which validates `unknown` to one of a set of
  * supplied enumerated values. Anything else fails.
  *
  * @remarks
- * This JSON variant accepts an {@link Validators.IJsonValidatorContext | IJsonValidatorContext} OR
+ * This JSON variant accepts an `IJsonValidatorContext` OR
  * a `ReadonlyArray<T>` as its validation context. If the context is an array, it is used to override the
  * allowed values for that validation; 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 Validator | Validator} returning `<T>`.
+ * @returns A new `Validator` returning `<T>`.
  * @public
  */
 export declare function enumeratedValue<T>(values: ReadonlyArray<T>, message?: string): Validator<T, IJsonValidatorContext | ReadonlyArray<T>>;

package/lib/packlets/validators/validators.js

@@ -125,26 +125,26 @@ exports.jsonValue = new ts_utils_1.Validation.Base.GenericValidator({
     }
 });
 /**
- * A {@link Validation.Classes.StringValidator | StringValidator} which validates a string in place.
+ * A `StringValidator` which validates a string in place.
  * Accepts {@link Validators.IJsonValidatorContext | IJsonValidatorContext} but ignores it.
  * @public
  */
 exports.string = new ts_utils_1.Validation.Classes.StringValidator();
 /**
- * A {@link Validation.Classes.NumberValidator | NumberValidator} which validates a number in place.
+ * A `NumberValidator` which validates a number in place.
  * Accepts {@link Validators.IJsonValidatorContext | IJsonValidatorContext} but ignores it.
  * @public
  */
 exports.number = new ts_utils_1.Validation.Classes.NumberValidator();
 /**
- * A {@link Validation.Classes.BooleanValidator | BooleanValidator} which validates a boolean in place.
- * Accepts {@link Validators.IJsonValidatorContext | IJsonValidatorContext} but ignores it.
+ * A `BooleanValidator` which validates a boolean in place.
+ * Accepts `IJsonValidatorContext` but ignores it.
  * @public
  */
 exports.boolean = new ts_utils_1.Validation.Classes.BooleanValidator();
 /**
  * Helper to create a validator for a literal value.
- * Accepts {@link Validators.IJsonValidatorContext | IJsonValidatorContext} but ignores it.
+ * Accepts `IJsonValidatorContext` but ignores it.
  * Mirrors the behavior of `@fgv/ts-utils`.
  * @public
  */
@@ -156,17 +156,17 @@ function literal(value) {
     });
 }
 /**
- * Helper function to create a {@link Validator | Validator} which validates `unknown` to one of a set of
+ * Helper function to create a `Validator` which validates `unknown` to one of a set of
  * supplied enumerated values. Anything else fails.
  *
  * @remarks
- * This JSON variant accepts an {@link Validators.IJsonValidatorContext | IJsonValidatorContext} OR
+ * This JSON variant accepts an `IJsonValidatorContext` OR
  * a `ReadonlyArray<T>` as its validation context. If the context is an array, it is used to override the
  * allowed values for that validation; 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 Validator | Validator} returning `<T>`.
+ * @returns A new `Validator` returning `<T>`.
  * @public
  */
 function enumeratedValue(values, message) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fgv/ts-json-base",
-  "version": "5.0.2",
+  "version": "5.1.0-0",
   "description": "Typescript types and basic functions for working with json",
   "main": "lib/index.js",
   "types": "dist/ts-json-base.d.ts",
@@ -31,35 +31,35 @@
   "devDependencies": {
     "@types/jest": "^29.5.14",
     "@types/node": "^20.14.9",
-    "@typescript-eslint/eslint-plugin": "^8.46.2",
-    "@typescript-eslint/parser": "^8.46.2",
-    "eslint": "^9.39.0",
+    "@typescript-eslint/eslint-plugin": "^8.52.0",
+    "@typescript-eslint/parser": "^8.52.0",
+    "eslint": "^9.39.2",
     "eslint-plugin-import": "^2.32.0",
     "eslint-plugin-node": "^11.1.0",
     "eslint-plugin-promise": "^7.2.1",
     "jest": "^29.7.0",
     "jest-extended": "^4.0.2",
-    "rimraf": "^6.1.0",
-    "ts-jest": "^29.4.5",
+    "rimraf": "^6.1.2",
+    "ts-jest": "^29.4.6",
     "ts-node": "^10.9.2",
     "typescript": "5.9.3",
     "eslint-plugin-n": "^17.23.1",
-    "@rushstack/heft": "1.1.3",
-    "@rushstack/heft-jest-plugin": "1.1.3",
+    "@rushstack/heft": "1.2.6",
+    "@rushstack/heft-jest-plugin": "1.2.6",
     "@types/heft-jest": "1.0.6",
-    "@microsoft/api-documenter": "^7.27.3",
+    "@microsoft/api-documenter": "^7.28.2",
     "@rushstack/eslint-patch": "1.14.1",
-    "@rushstack/eslint-config": "4.5.3",
-    "eslint-plugin-tsdoc": "~0.4.0",
+    "@rushstack/eslint-config": "4.6.4",
+    "eslint-plugin-tsdoc": "~0.5.2",
     "@types/luxon": "^3.7.1",
-    "@rushstack/heft-node-rig": "2.11.4",
-    "@microsoft/api-extractor": "^7.53.3",
-    "@fgv/ts-utils": "5.0.2",
-    "@fgv/heft-dual-rig": "0.1.0",
-    "@fgv/ts-utils-jest": "5.0.2"
+    "@rushstack/heft-node-rig": "2.11.26",
+    "@microsoft/api-extractor": "^7.55.2",
+    "@fgv/ts-utils": "5.1.0-0",
+    "@fgv/ts-utils-jest": "5.1.0-0",
+    "@fgv/heft-dual-rig": "0.1.0"
   },
   "peerDependencies": {
-    "@fgv/ts-utils": "5.0.2"
+    "@fgv/ts-utils": "5.1.0-0"
   },
   "dependencies": {
     "luxon": "^3.7.2"
@@ -72,7 +72,7 @@
     "build": "heft build --clean",
     "clean": "heft clean",
     "test": "heft test --clean",
-    "build-docs": "api-documenter markdown --input-folder ./temp --output-folder docs",
+    "build-docs": "typedoc --options ./config/typedoc.json",
     "build-all": "rushx build; rushx build-docs",
     "test-handles": "jest --runInBand --detectOpenHandles",
     "clean-jest": "jest --clear-cache",