@fgv/ts-json-base 5.0.0-30 → 5.0.0-31

package/dist/ts-json-base.d.ts

@@ -12,6 +12,12 @@ import { Validator } from '@fgv/ts-utils';
  */
 export declare function classifyJsonValue(from: unknown): Result<JsonValueType>;
 
+/**
+ * Type of function to infer the content type of a file.
+ * @public
+ */
+declare type ContentTypeFactory<TCT extends string = string> = (filePath: string, provided?: string) => Result<TCT | undefined>;
+
 declare namespace Converters {
     export {
         IJsonConverterContext,
@@ -68,6 +74,466 @@ declare const DefaultJsonFsHelperConfig: IJsonFsHelperConfig;
  */
 declare const DefaultJsonLike: IJsonLike;
 
+/**
+ * @public
+ */
+declare const DefaultJsonTreeHelper: JsonTreeHelper;
+
+/**
+ * Class representing a directory in a file tree.
+ * @public
+ */
+declare class DirectoryItem<TCT extends string = string> implements IFileTreeDirectoryItem<TCT> {
+    /**
+     * {@inheritdoc FileTree.IFileTreeDirectoryItem."type"}
+     */
+    readonly type: 'directory';
+    /**
+     * {@inheritdoc FileTree.IFileTreeDirectoryItem.absolutePath}
+     */
+    readonly absolutePath: string;
+    /**
+     * {@inheritdoc FileTree.IFileTreeDirectoryItem.name}
+     */
+    get name(): string;
+    /**
+     * The {@link FileTree.IFileTreeAccessors | accessors} to use for file system operations.
+     * @public
+     */
+    protected readonly _hal: IFileTreeAccessors<TCT>;
+    /**
+     * Protected constructor for derived classes.
+     * @param path - Relative path of the directory.
+     * @param hal - The {@link FileTree.IFileTreeAccessors | accessors} to use for
+     * file system operations.
+     * @public
+     */
+    protected constructor(path: string, hal: IFileTreeAccessors<TCT>);
+    /**
+     * Creates a new DirectoryItem instance.
+     * @param path - Relative path of the directory.
+     * @param hal - The {@link FileTree.IFileTreeAccessors | accessors} to use for
+     * file system operations.
+     * @returns `Success` with the new {@link FileTree.DirectoryItem | DirectoryItem} instance if successful,
+     * or `Failure` with an error message otherwise.
+     */
+    static create<TCT extends string = string>(path: string, hal: IFileTreeAccessors<TCT>): Result<DirectoryItem<TCT>>;
+    /**
+     * {@inheritdoc FileTree.IFileTreeDirectoryItem.getChildren}
+     */
+    getChildren(): Result<ReadonlyArray<FileTreeItem<TCT>>>;
+}
+
+/**
+ * Class representing a file in a file tree.
+ * @public
+ */
+declare class FileItem<TCT extends string = string> implements IFileTreeFileItem<TCT> {
+    /**
+     * {@inheritdoc FileTree.IFileTreeFileItem."type"}
+     */
+    readonly type: 'file';
+    /**
+     * {@inheritdoc FileTree.IFileTreeFileItem.absolutePath}
+     */
+    readonly absolutePath: string;
+    /**
+     * {@inheritdoc FileTree.IFileTreeFileItem.name}
+     */
+    get name(): string;
+    /**
+     * {@inheritdoc FileTree.IFileTreeFileItem.baseName}
+     */
+    get baseName(): string;
+    /**
+     * {@inheritdoc FileTree.IFileTreeFileItem.extension}
+     */
+    get extension(): string;
+    /**
+     * {@inheritdoc FileTree.IFileTreeFileItem.contentType}
+     */
+    get contentType(): TCT | undefined;
+    /**
+     * Mutable content type of the file.
+     * @public
+     */
+    private _contentType;
+    /**
+     * The {@link FileTree.IFileTreeAccessors | accessors} to use for file system operations.
+     * @public
+     */
+    protected readonly _hal: IFileTreeAccessors<TCT>;
+    /**
+     * Protected constructor for derived classes.
+     * @param path - Relative path of the file.
+     * @param hal - The {@link FileTree.IFileTreeAccessors | accessors} to use for
+     * file system operations.
+     * @public
+     */
+    protected constructor(path: string, hal: IFileTreeAccessors<TCT>);
+    /**
+     * Creates a new {@link FileTree.FileItem} instance.
+     * @param path - Relative path of the file.
+     * @param hal - The {@link FileTree.IFileTreeAccessors | accessors} to use for
+     * file system operations.
+     * @public
+     */
+    static create<TCT extends string = string>(path: string, hal: IFileTreeAccessors<TCT>): Result<FileItem<TCT>>;
+    /**
+     * {@inheritdoc FileTree.IFileTreeFileItem.(getContents:1)}
+     */
+    getContents(): Result<JsonValue>;
+    /**
+     * {@inheritdoc FileTree.IFileTreeFileItem.(getContents:2)}
+     */
+    getContents<T>(converter: Validator<T> | Converter<T>): Result<T>;
+    /**
+     * {@inheritdoc FileTree.IFileTreeFileItem.getRawContents}
+     */
+    getRawContents(): Result<string>;
+    /**
+     * Sets the content type of the file.
+     * @param contentType - The content type of the file.
+     */
+    setContentType(contentType: TCT | undefined): void;
+    /**
+     * Default function to infer the content type of a file.
+     * @param filePath - The path of the file.
+     * @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>;
+    /**
+     * Default function to accept 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 defaultAcceptContentType<TCT extends string = string>(__filePath: string, provided?: TCT): Result<TCT | undefined>;
+}
+
+declare namespace FileTree {
+    export {
+        FileTreeItemType,
+        ContentTypeFactory,
+        IFileTreeInitParams,
+        IFileTreeFileItem,
+        IFileTreeDirectoryItem,
+        FileTreeItem,
+        IFileTreeAccessors,
+        FileTree_2 as FileTree,
+        DirectoryItem,
+        FileItem,
+        forFilesystem,
+        inMemory,
+        IInMemoryFile,
+        InMemoryTreeAccessors,
+        FsFileTreeAccessors
+    }
+}
+export { FileTree }
+
+/**
+ * Represents a file tree.
+ * @public
+ */
+declare class FileTree_2<TCT extends string = string> {
+    /**
+     * The {@link FileTree.IFileTreeAccessors | accessors} to use for file system operations.
+     * @public
+     */
+    hal: IFileTreeAccessors<TCT>;
+    /**
+     * Protected constructor for derived classes.
+     * @param hal - The {@link FileTree.IFileTreeAccessors | accessors} to use for
+     * file system operations.
+     * @public
+     */
+    protected constructor(hal: IFileTreeAccessors<TCT>);
+    /**
+     * Creates a new {@link FileTree} instance with the supplied
+     * accessors.
+     * @param hal - The {@link FileTree.IFileTreeAccessors | accessors} to use for
+     * file system operations.
+     */
+    static create<TCT extends string = string>(hal: IFileTreeAccessors<TCT>): Result<FileTree_2<TCT>>;
+    /**
+     * Gets an item from the tree.
+     * @param itemPath - The path to the item.
+     * @returns `Success` with the item if successful,
+     * or `Failure` with an error message otherwise.
+     */
+    getItem(itemPath: string): Result<FileTreeItem<TCT>>;
+    /**
+     * Gets a file item from the tree.
+     * @param filePath - The path to the file.
+     * @returns `Success` with the {@link FileTree.IFileTreeFileItem | file item}
+     * if successful, or `Failure` with an error message otherwise.
+     */
+    getFile(filePath: string): Result<IFileTreeFileItem<TCT>>;
+    /**
+     * Gets a directory item from the tree.
+     * @param directoryPath - The path to the directory.
+     * @returns `Success` with the {@link FileTree.IFileTreeDirectoryItem | directory item}
+     * if successful, or `Failure` with an error message otherwise.
+     */
+    getDirectory(directoryPath: string): Result<IFileTreeDirectoryItem<TCT>>;
+}
+
+/**
+ * Type for an item in a file tree.
+ * @public
+ */
+declare type FileTreeItem<TCT extends string = string> = IFileTreeFileItem<TCT> | IFileTreeDirectoryItem<TCT>;
+
+/**
+ * Type of item in a file tree.
+ * @public
+ */
+declare type FileTreeItemType = 'directory' | 'file';
+
+/**
+ * Helper function to create a new {@link FileTree.FileTree | FileTree} instance
+ * with accessors for the filesystem.
+ * @param prefix - An optional prefix to prepended to supplied relative paths.
+ * @returns `Success` with the new {@link FileTree.FileTree | FileTree} instance
+ * if successful, or `Failure` with an error message otherwise.
+ * @public
+ */
+declare function forFilesystem<TCT extends string = string>(prefix?: string): Result<FileTree_2<TCT>>;
+
+/**
+ * Helper function to create a new {@link FileTree.FileTree | FileTree} instance
+ * with accessors for the filesystem.
+ * @param params - Optional {@link FileTree.IFileTreeInitParams | initialization parameters} for the file tree.
+ * @returns `Success` with the new {@link FileTree.FileTree | FileTree} instance
+ * if successful, or `Failure` with an error message otherwise.
+ * @public
+ */
+declare function forFilesystem<TCT extends string = string>(params?: IFileTreeInitParams<TCT>): Result<FileTree_2<TCT>>;
+
+/**
+ * Implementation of {@link FileTree.IFileTreeAccessors} that uses the
+ * file system to access files and directories.
+ * @public
+ */
+declare class FsFileTreeAccessors<TCT extends string = string> implements IFileTreeAccessors<TCT> {
+    /**
+     * Optional path prefix to prepend to all paths.
+     */
+    readonly prefix: string | undefined;
+    /**
+     * Function to infer the content type of a file.
+     * @public
+     */
+    protected readonly _inferContentType: (filePath: string) => Result<TCT | undefined>;
+    /**
+     * Construct a new instance of the {@link FileTree.FsFileTreeAccessors | FsFileTreeAccessors} class.
+     * @param params - Optional {@link FileTree.IFileTreeInitParams | initialization parameters}.
+     * @public
+     */
+    constructor(params?: IFileTreeInitParams<TCT>);
+    /**
+     * {@inheritdoc FileTree.IFileTreeAccessors.resolveAbsolutePath}
+     */
+    resolveAbsolutePath(...paths: string[]): string;
+    /**
+     * {@inheritdoc FileTree.IFileTreeAccessors.getExtension}
+     */
+    getExtension(itemPath: string): string;
+    /**
+     * {@inheritdoc FileTree.IFileTreeAccessors.getBaseName}
+     */
+    getBaseName(itemPath: string, suffix?: string): string;
+    /**
+     * {@inheritdoc FileTree.IFileTreeAccessors.joinPaths}
+     */
+    joinPaths(...paths: string[]): string;
+    /**
+     * {@inheritdoc FileTree.IFileTreeAccessors.getItem}
+     */
+    getItem(itemPath: string): Result<FileTreeItem<TCT>>;
+    /**
+     * {@inheritdoc FileTree.IFileTreeAccessors.getFileContents}
+     */
+    getFileContents(filePath: string): Result<string>;
+    /**
+     * {@inheritdoc FileTree.IFileTreeAccessors.getFileContentType}
+     */
+    getFileContentType(filePath: string, provided?: string): Result<TCT | undefined>;
+    /**
+     * {@inheritdoc FileTree.IFileTreeAccessors.getChildren}
+     */
+    getChildren(dirPath: string): Result<ReadonlyArray<FileTreeItem<TCT>>>;
+}
+
+/**
+ * Common abstraction layer interface for a tree of files
+ * (e.g. a file system or a zip file).
+ * @public
+ */
+declare interface IFileTreeAccessors<TCT extends string = string> {
+    /**
+     * Resolves paths to an absolute path.
+     * @param paths - Paths to resolve.
+     * @returns The resolved absolute path.
+     */
+    resolveAbsolutePath(...paths: string[]): string;
+    /**
+     * Gets the extension of a path.
+     * @param path - Path to get the extension of.
+     * @returns The extension of the path.
+     */
+    getExtension(path: string): string;
+    /**
+     * Gets the base name of a path.
+     * @param path - Path to get the base name of.
+     * @param suffix - Optional suffix to remove from the base name.
+     * @returns The base name of the path.
+     */
+    getBaseName(path: string, suffix?: string): string;
+    /**
+     * Joins paths together.
+     * @param paths - Paths to join.
+     * @returns The joined paths.
+     */
+    joinPaths(...paths: string[]): string;
+    /**
+     * Gets an item from the file tree.
+     * @param path - Path of the item to get.
+     * @returns The item if it exists.
+     */
+    getItem(path: string): Result<FileTreeItem<TCT>>;
+    /**
+     * Gets the contents of a file in the file tree.
+     * @param path - Absolute path of the file.
+     * @returns The contents of the file.
+     */
+    getFileContents(path: string): Result<string>;
+    /**
+     * Gets the content type of a file in the file tree.
+     * @param path - Absolute path of the file.
+     * @param provided - Optional supplied content type.
+     * @returns The content type of the file.
+     */
+    getFileContentType(path: string, provided?: string): Result<TCT | undefined>;
+    /**
+     * Gets the children of a directory in the file tree.
+     * @param path - Path of the directory.
+     * @returns The children of the directory.
+     */
+    getChildren(path: string): Result<ReadonlyArray<FileTreeItem<TCT>>>;
+}
+
+/**
+ * Interface for a directory in a file tree.
+ * @public
+ */
+declare interface IFileTreeDirectoryItem<TCT extends string = string> {
+    /**
+     * Indicates that this {@link FileTree.FileTreeItem | file tree item} is a directory
+     */
+    readonly type: 'directory';
+    /**
+     * The absolute path of the directory.
+     */
+    readonly absolutePath: string;
+    /**
+     * The name of the directory
+     */
+    readonly name: string;
+    /**
+     * Gets the children of the directory.
+     * @returns `Success` with the children of the directory if successful,
+     * or `Failure` with an error message otherwise.
+     */
+    getChildren(): Result<ReadonlyArray<FileTreeItem<TCT>>>;
+}
+
+/**
+ * Interface for a file in a file tree.
+ * @public
+ */
+declare interface IFileTreeFileItem<TCT extends string = string> {
+    /**
+     * Indicates that this {@link FileTree.FileTreeItem | file tree item} is a file.
+     */
+    readonly type: 'file';
+    /**
+     * The absolute path of the file.
+     */
+    readonly absolutePath: string;
+    /**
+     * The name of the file
+     */
+    readonly name: string;
+    /**
+     * The base name of the file (without extension)
+     */
+    readonly baseName: string;
+    /**
+     * The extension of the file
+     */
+    readonly extension: string;
+    /**
+     * An optional content type (e.g. mime type) for the file.
+     */
+    readonly contentType: TCT | undefined;
+    /**
+     * Gets the contents of the file as parsed JSON.
+     * @returns `Success` with the parsed JSON-compatible contents if successful, or
+     * `Failure` with an error message otherwise.
+     */
+    getContents(): Result<JsonValue>;
+    /**
+     * Gets the contents of the file as parsed JSON, converted to a specific type.
+     * @param converter - A `Validator` or `Converter`
+     * to convert the parsed JSON contents to the desired type.
+     * @returns `Success` with the converted contents if successful, or
+     * `Failure` with an error message otherwise.
+     */
+    getContents<T>(converter: Validator<T> | Converter<T>): Result<T>;
+    /**
+     * Gets the raw contents of the file as a string.
+     * @returns `Success` with the raw contents if successful, or
+     * `Failure` with an error message otherwise.
+     */
+    getRawContents(): Result<string>;
+}
+
+/**
+ * Initialization parameters for a file tree.
+ * @public
+ */
+declare interface IFileTreeInitParams<TCT extends string = string> {
+    prefix?: string;
+    inferContentType?: ContentTypeFactory<TCT>;
+}
+
+/**
+ * Represents a single file in an in-memory {@link FileTree | file tree}.
+ * @public
+ */
+declare interface IInMemoryFile<TCT extends string = string> {
+    /**
+     * The absolute path of the file in the tree.
+     */
+    readonly path: string;
+    /**
+     * The contents of the file
+     */
+    readonly contents: unknown;
+    /**
+     * The content type of the file.
+     */
+    readonly contentType?: TCT;
+}
+
 /**
  * Conversion context for JSON converters.
  * @public
@@ -126,6 +592,91 @@ declare interface IJsonValidatorContext {
     ignoreUndefinedProperties?: boolean;
 }
 
+/**
+ * Helper function to create a new {@link FileTree.FileTree | FileTree} instance
+ * with accessors for an in-memory file tree.
+ * @param files - An array of File |{@link FileTree.IInMemoryFile | in-memory files} to include in the tree.
+ * @param prefix - An optional prefix to add to the paths of all files in the tree.
+ * @returns `Success` with the new {@link FileTree.FileTree | FileTree} instance
+ * if successful, or `Failure` with an error message otherwise.
+ * @public
+ */
+declare function inMemory<TCT extends string = string>(files: IInMemoryFile<TCT>[], prefix?: string): Result<FileTree_2<TCT>>;
+
+/**
+ * Helper function to create a new {@link FileTree.FileTree | FileTree} instance
+ * with accessors for an in-memory file tree.
+ * @param files - An array of File |{@link FileTree.IInMemoryFile | in-memory files} to include in the tree.
+ * @param params - Optional {@link FileTree.IFileTreeInitParams | initialization parameters} for the file tree.
+ * @returns `Success` with the new {@link FileTree.FileTree | FileTree} instance
+ * if successful, or `Failure` with an error message otherwise.
+ * @public
+ */
+declare function inMemory<TCT extends string = string>(files: IInMemoryFile<TCT>[], params?: IFileTreeInitParams<TCT>): Result<FileTree_2<TCT>>;
+
+/**
+ * Implementation of {@link FileTree.IFileTreeAccessors} that uses an in-memory
+ * tree to access files and directories.
+ * @public
+ */
+declare class InMemoryTreeAccessors<TCT extends string = string> implements IFileTreeAccessors<TCT> {
+    private readonly _tree;
+    private readonly _inferContentType;
+    /**
+     * Protected constructor for derived classes.
+     * @param files - An array of {@link FileTree.IInMemoryFile | in-memory files} to include in the tree.
+     * @param params - Optional params for the tree.
+     * @public
+     */
+    protected constructor(files: IInMemoryFile<TCT>[], params?: IFileTreeInitParams<TCT>);
+    /**
+     * Creates a new {@link FileTree.InMemoryTreeAccessors | InMemoryTreeAccessors} instance with the supplied
+     * in-memory files.
+     * @param files - An array of {@link FileTree.IInMemoryFile | in-memory files} to include in the tree.
+     * @param prefix - Optional prefix for the tree.
+     */
+    static create<TCT extends string = string>(files: IInMemoryFile<TCT>[], prefix?: string): Result<InMemoryTreeAccessors<TCT>>;
+    /**
+     * Creates a new {@link FileTree.InMemoryTreeAccessors | InMemoryTreeAccessors} instance with the supplied
+     * in-memory files.
+     * @param files - An array of {@link FileTree.IInMemoryFile | in-memory files} to include in the tree.
+     * @param params - Optional params for the tree.
+     */
+    static create<TCT extends string = string>(files: IInMemoryFile<TCT>[], params?: IFileTreeInitParams<TCT>): Result<InMemoryTreeAccessors<TCT>>;
+    /**
+     * {@inheritdoc FileTree.IFileTreeAccessors.resolveAbsolutePath}
+     */
+    resolveAbsolutePath(...paths: string[]): string;
+    /**
+     * {@inheritdoc FileTree.IFileTreeAccessors.getExtension}
+     */
+    getExtension(path: string): string;
+    /**
+     * {@inheritdoc FileTree.IFileTreeAccessors.getBaseName}
+     */
+    getBaseName(path: string, suffix?: string): string;
+    /**
+     * {@inheritdoc FileTree.IFileTreeAccessors.joinPaths}
+     */
+    joinPaths(...paths: string[]): string;
+    /**
+     * {@inheritdoc FileTree.IFileTreeAccessors.getItem}
+     */
+    getItem(itemPath: string): Result<FileTreeItem<TCT>>;
+    /**
+     * {@inheritdoc FileTree.IFileTreeAccessors.getFileContents}
+     */
+    getFileContents(path: string): Result<string>;
+    /**
+     * {@inheritdoc FileTree.IFileTreeAccessors.getFileContentType}
+     */
+    getFileContentType(path: string, provided?: string): Result<TCT | undefined>;
+    /**
+     * {@inheritdoc FileTree.IFileTreeAccessors.getChildren}
+     */
+    getChildren(path: string): Result<ReadonlyArray<FileTreeItem<TCT>>>;
+}
+
 /**
  * Return value for one item in a directory conversion.
  * @public
@@ -265,6 +816,14 @@ declare namespace JsonFile {
         convertJsonDirectorySync,
         convertJsonDirectoryToMapSync,
         writeJsonFileSync,
+        JsonReviver,
+        JsonReplacerFunction,
+        JsonReplacerArray,
+        JsonReplacer,
+        IJsonLike,
+        DefaultJsonLike,
+        JsonTreeHelper,
+        DefaultJsonTreeHelper,
         IJsonFsDirectoryOptions,
         IReadDirectoryItem,
         ItemNameTransformFunction,
@@ -273,13 +832,7 @@ declare namespace JsonFile {
         JsonFsHelperInitOptions,
         DefaultJsonFsHelperConfig,
         JsonFsHelper,
-        DefaultJsonFsHelper,
-        JsonReviver,
-        JsonReplacerFunction,
-        JsonReplacerArray,
-        JsonReplacer,
-        IJsonLike,
-        DefaultJsonLike
+        DefaultJsonFsHelper
     }
 }
 export { JsonFile }
@@ -414,6 +967,62 @@ declare type JsonReplacerFunction = (key: string, value: JsonValue) => JsonValue
  */
 declare type JsonReviver = (key: string, value: JsonValue) => JsonValue;
 
+/**
+ * Helper class to work with JSON files using FileTree API (web-compatible).
+ * @public
+ */
+declare class JsonTreeHelper {
+    /**
+     * Configuration for this JsonTreeHelper.
+     */
+    readonly json: IJsonLike;
+    /**
+     * Construct a new JsonTreeHelper.
+     * @param json - Optional {@link JsonFile.IJsonLike | IJsonLike} used to process strings
+     * and JSON values.
+     */
+    constructor(json?: IJsonLike);
+    /**
+     * Read type-safe JSON from a file in a FileTree.
+     * @param fileTree - The FileTree to read from
+     * @param filePath - Path of the file to read within the tree
+     * @returns `Success` with a {@link JsonValue | JsonValue} or `Failure`
+     * with a message if an error occurs.
+     */
+    readJsonFromTree(fileTree: FileTree.FileTree, filePath: string): Result<JsonValue>;
+    /**
+     * Read a JSON file from a FileTree and apply a supplied converter or validator.
+     * @param fileTree - The FileTree to read from
+     * @param filePath - Path of the file to read within the tree
+     * @param cv - Converter or validator used to process the file.
+     * @param context - Optional context for the converter/validator
+     * @returns `Success` with a result of type `<T>`, or `Failure`
+     * with a message if an error occurs.
+     */
+    convertJsonFromTree<T, TC = unknown>(fileTree: FileTree.FileTree, filePath: string, cv: Converter<T, TC> | Validator<T, TC>, context?: TC): Result<T>;
+    /**
+     * Reads all JSON files from a directory in a FileTree and applies a converter or validator.
+     * @param fileTree - The FileTree to read from
+     * @param dirPath - The path of the directory within the tree
+     * @param cv - Converter or validator to apply to each JSON file
+     * @param filePattern - Optional regex pattern to filter files (defaults to .json files)
+     * @param context - Optional context for the converter/validator
+     * @returns Array of items with filename and converted content
+     */
+    convertJsonDirectoryFromTree<T, TC = unknown>(fileTree: FileTree.FileTree, dirPath: string, cv: Converter<T, TC> | Validator<T, TC>, filePattern?: RegExp, context?: TC): Result<IReadDirectoryItem<T>[]>;
+    /**
+     * Reads and converts all JSON files from a directory in a FileTree,
+     * returning a Map indexed by file base name.
+     * @param fileTree - The FileTree to read from
+     * @param dirPath - The path of the directory within the tree
+     * @param cv - Converter or validator to apply to each JSON file
+     * @param filePattern - Optional regex pattern to filter files
+     * @param context - Optional context for the converter/validator
+     * @returns Map of basename to converted content
+     */
+    convertJsonDirectoryToMapFromTree<T, TC = unknown>(fileTree: FileTree.FileTree, dirPath: string, cv: Converter<T, TC> | Validator<T, TC>, filePattern?: RegExp, context?: TC): Result<Map<string, T>>;
+}
+
 /**
  * A {@link JsonValue | JsonValue} is one of: a {@link JsonPrimitive | JsonPrimitive},
  * a {@link JsonObject | JsonObject} or an {@link JsonArray | JsonArray}.

package/lib/index.d.ts

@@ -1,6 +1,7 @@
 import * as Converters from './packlets/converters';
+import * as FileTree from './packlets/file-tree';
 import * as JsonFile from './packlets/json-file';
 import * as Validators from './packlets/validators';
 export * from './packlets/json';
-export { Converters, JsonFile, Validators };
+export { Converters, FileTree, JsonFile, Validators };
 //# sourceMappingURL=index.d.ts.map

package/lib/index.js

@@ -57,9 +57,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Validators = exports.JsonFile = exports.Converters = void 0;
+exports.Validators = exports.JsonFile = exports.FileTree = exports.Converters = void 0;
 const Converters = __importStar(require("./packlets/converters"));
 exports.Converters = Converters;
+const FileTree = __importStar(require("./packlets/file-tree"));
+exports.FileTree = FileTree;
 const JsonFile = __importStar(require("./packlets/json-file"));
 exports.JsonFile = JsonFile;
 const Validators = __importStar(require("./packlets/validators"));