@fgv/ts-json-base 5.0.1-1 → 5.0.1-10

package/lib/packlets/file-tree/fileTreeHelpers.inMemory.d.ts

@@ -0,0 +1,25 @@
+import { Result } from '@fgv/ts-utils';
+import { FileTree } from './fileTree';
+import { IInMemoryFile } from './in-memory';
+import { IFileTreeInitParams } from './fileTreeAccessors';
+/**
+ * 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
+ */
+export declare function inMemory<TCT extends string = string>(files: IInMemoryFile<TCT>[], prefix?: string): Result<FileTree<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
+ */
+export declare function inMemory<TCT extends string = string>(files: IInMemoryFile<TCT>[], params?: IFileTreeInitParams<TCT>): Result<FileTree<TCT>>;
+//# sourceMappingURL=fileTreeHelpers.inMemory.d.ts.map

package/lib/packlets/file-tree/fileTreeHelpers.inMemory.js

@@ -0,0 +1,31 @@
+"use strict";
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inMemory = inMemory;
+const fileTree_1 = require("./fileTree");
+const in_memory_1 = require("./in-memory");
+function inMemory(files, params) {
+    params = typeof params === 'string' ? { prefix: params } : params;
+    return in_memory_1.InMemoryTreeAccessors.create(files, params).onSuccess((hal) => fileTree_1.FileTree.create(hal));
+}
+//# sourceMappingURL=fileTreeHelpers.inMemory.js.map

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

@@ -22,17 +22,11 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.forFilesystem = forFilesystem;
-exports.inMemory = inMemory;
 const ts_utils_1 = require("@fgv/ts-utils");
 const fileTree_1 = require("./fileTree");
 const fsTree_1 = require("./fsTree");
-const in_memory_1 = require("./in-memory");
 function forFilesystem(params) {
     params = typeof params === 'string' ? { prefix: params } : params;
     return (0, ts_utils_1.captureResult)(() => new fsTree_1.FsFileTreeAccessors(params)).onSuccess((hal) => fileTree_1.FileTree.create(hal));
 }
-function inMemory(files, params) {
-    params = typeof params === 'string' ? { prefix: params } : params;
-    return in_memory_1.InMemoryTreeAccessors.create(files, params).onSuccess((hal) => fileTree_1.FileTree.create(hal));
-}
 //# sourceMappingURL=fileTreeHelpers.js.map

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

@@ -3,4 +3,5 @@ export * from './fileTree';
 export * from './directoryItem';
 export * from './fileItem';
 export * from './in-memory';
+export { inMemory } from './fileTreeHelpers.inMemory';
 //# sourceMappingURL=index.browser.d.ts.map

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

@@ -35,6 +35,7 @@ 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.inMemory = void 0;
 // Browser-safe FileTree exports - excludes Node.js filesystem dependencies
 // Export core interfaces and classes
 __exportStar(require("./fileTreeAccessors"), exports);
@@ -43,6 +44,8 @@ __exportStar(require("./directoryItem"), exports);
 __exportStar(require("./fileItem"), exports);
 // Export in-memory implementations for web compatibility
 __exportStar(require("./in-memory"), exports);
+var fileTreeHelpers_inMemory_1 = require("./fileTreeHelpers.inMemory");
+Object.defineProperty(exports, "inMemory", { enumerable: true, get: function () { return fileTreeHelpers_inMemory_1.inMemory; } });
 // Exclude:
 // - fsTree (requires Node.js fs/path)
 // - fileTreeHelpers (imports fsTree)

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

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

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

@@ -35,6 +35,7 @@ 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.inMemory = void 0;
 // Export core interfaces and classes
 __exportStar(require("./fileTreeAccessors"), exports);
 __exportStar(require("./fileTree"), exports);
@@ -42,6 +43,8 @@ __exportStar(require("./directoryItem"), exports);
 __exportStar(require("./fileItem"), 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");
+Object.defineProperty(exports, "inMemory", { enumerable: true, get: function () { return fileTreeHelpers_inMemory_1.inMemory; } });
 // Export in-memory implementations for web compatibility
 __exportStar(require("./in-memory"), exports);
 // Note: FsFileTreeAccessors is now only imported by fileTreeHelpers.ts

package/lib/packlets/json/common.d.ts

@@ -58,7 +58,7 @@ type IsUnknown<T> = unknown extends T ? ([T] extends [unknown] ? true : false) :
  *   email?: string; // Optional property can be undefined
  * }
  *
- * type UserCompatible = JsonCompatible<IUser>; // Allows undefined for email
+ * type UserCompatible = JsonCompatibleType<IUser>; // Allows undefined for email
  *
  * const user: UserCompatible = {
  *   name: "John",
@@ -72,8 +72,8 @@ type IsUnknown<T> = unknown extends T ? ([T] extends [unknown] ? true : false) :
  *
  * @public
  */
-export type JsonCompatible<T> = IsUnknown<T> extends true ? JsonValue : T extends JsonPrimitive | undefined ? T : T extends Array<unknown> ? JsonCompatibleArray<T[number]> : T extends Function ? ['Error: Function is not JSON-compatible'] : T extends object ? {
-    [K in keyof T]: JsonCompatible<T[K]>;
+export type JsonCompatibleType<T> = IsUnknown<T> extends true ? JsonValue : T extends JsonPrimitive | undefined ? T : T extends Array<unknown> ? JsonCompatibleArray<T[number]> : T extends Function ? ['Error: Function is not JSON-compatible'] : T extends object ? {
+    [K in keyof T]: JsonCompatibleType<T[K]>;
 } : ['Error: Non-JSON type'];
 /**
  * A type that represents an array of JSON-compatible values.
@@ -81,7 +81,7 @@ export type JsonCompatible<T> = IsUnknown<T> extends true ? JsonValue : T extend
  * @returns A constrained type that is compatible with JSON serialization.
  * @public
  */
-export type JsonCompatibleArray<T> = Array<JsonCompatible<T>>;
+export type JsonCompatibleArray<T> = Array<JsonCompatibleType<T>>;
 /**
  * Test if an `unknown` is a {@link JsonValue | JsonValue}.
  * @param from - The `unknown` to be tested

package/lib/packlets/json-compatible/common.d.ts

@@ -0,0 +1,43 @@
+import { Converter as BaseConverter, ObjectConverter as BaseObjectConverter, Validation, Validator as BaseValidator } from '@fgv/ts-utils';
+import { JsonCompatibleType } from '../json';
+/**
+ * A converter which converts a supplied `unknown` value to a valid {@link JsonCompatibleType | JsonCompatible} value.
+ * @public
+ */
+export type Converter<T, TC = unknown> = BaseConverter<JsonCompatibleType<T>, TC>;
+/**
+ * A validator which validates a supplied `unknown` value to a valid {@link JsonCompatibleType | JsonCompatible} value.
+ * @public
+ */
+export type Validator<T, TC = unknown> = BaseValidator<JsonCompatibleType<T>, TC>;
+/**
+ * A converter which converts a supplied `unknown` value to a valid {@link JsonCompatibleType | JsonCompatible} value.
+ * @public
+ */
+export type ObjectConverter<T, TC = unknown> = BaseObjectConverter<JsonCompatibleType<T>, TC>;
+/**
+ * A validator which validates a supplied `unknown` value to a valid {@link JsonCompatibleType | JsonCompatible} value.
+ * @public
+ */
+export type ObjectValidator<T, TC = unknown> = Validation.Classes.ObjectValidator<JsonCompatibleType<T>, TC>;
+/**
+ * A converter which converts a supplied `unknown` value to a valid array of {@link JsonCompatibleType | JsonCompatible} values.
+ * @public
+ */
+export type ArrayConverter<T, TC = unknown> = BaseConverter<JsonCompatibleType<T>[], TC>;
+/**
+ * A validator which validates arrays of {@link JsonCompatibleType | JsonCompatible} values in place.
+ * @public
+ */
+export type ArrayValidator<T, TC = unknown> = Validation.Classes.ArrayValidator<JsonCompatibleType<T>, TC>;
+/**
+ * A converter which converts a supplied `unknown` value to a valid record of {@link JsonCompatibleType | JsonCompatible} values.
+ * @public
+ */
+export type RecordConverter<T, TC = unknown, TK extends string = string> = BaseConverter<Record<TK, JsonCompatibleType<T>>, TC>;
+/**
+ * A validator which validates a record of {@link JsonCompatibleType | JsonCompatible} values.
+ * @public
+ */
+export type RecordValidator<T, TC = unknown, TK extends string = string> = Validation.Validator<Record<TK, JsonCompatibleType<T>>, TC>;
+//# sourceMappingURL=common.d.ts.map

package/lib/packlets/json-compatible/common.js

@@ -0,0 +1,24 @@
+"use strict";
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=common.js.map

package/lib/packlets/json-compatible/converters.d.ts

@@ -0,0 +1,60 @@
+import { Conversion, Converters } from '@fgv/ts-utils';
+import * as JsonCompatible from './common';
+import { JsonCompatibleType } from '../json';
+/**
+ * A helper function to create a {@link JsonCompatible.ArrayConverter | JSON-compatible ArrayConverter<T, TC>}
+ * which converts a supplied `unknown` value to a valid array of {@link JsonCompatibleType | JsonCompatibleType<T>}.
+ * @param converter - {@link JsonCompatible.Converter | JSON-compatible Converter<T, TC>} or {@link JsonCompatible.Validator | JSON-compatible Validator<T>} used for each item in the source array.
+ * @param onError - The error handling option to use for the conversion.
+ * @returns A {@link JsonCompatible.ArrayConverter | JSON-compatible ArrayConverter<T, TC>} which returns `JsonCompatibleType<T>[]`.
+ * @public
+ */
+export declare function arrayOf<T, TC = unknown>(converter: JsonCompatible.Converter<T, TC> | JsonCompatible.Validator<T, TC>, onError?: Conversion.OnError): JsonCompatible.ArrayConverter<T, TC>;
+/**
+ * A helper function to create a {@link JsonCompatible.RecordConverter | JSON-compatible RecordConverter<T, TC, TK>}
+ * which converts the `string`-keyed properties using a supplied {@link JsonCompatible.Converter | JSON-compatible Converter<T, TC>} or
+ * {@link JsonCompatible.Validator | JSON-compatible Validator<T>} to produce a
+ * `Record<TK, JsonCompatibleType<T>>`.
+ * @remarks
+ * If present, the supplied `Converters.KeyedConverterOptions` can provide a strongly-typed
+ * converter for keys and/or control the handling of elements that fail conversion.
+ * @param converter - {@link JsonCompatible.Converter | JSON-compatible Converter<T, TC>}
+ * or {@link JsonCompatible.Validator | JSON-compatible Validator<T>} used for each item in the source object.
+ * @param options - Optional `Converters.KeyedConverterOptions<TK, TC>` which
+ * supplies a key converter and/or error-handling options.
+ * @returns A {@link JsonCompatible.RecordConverter | JSON-compatible RecordConverter<T, TC, TK>} which
+ * converts a supplied `unknown` value to a valid record of {@link JsonCompatibleType | JsonCompatible} values.
+ * @public
+ */
+export declare function recordOf<T, TC = unknown, TK extends string = string>(converter: JsonCompatible.Converter<T, TC> | JsonCompatible.Validator<T, TC>, options?: Converters.KeyedConverterOptions<TK, TC>): JsonCompatible.RecordConverter<T, TC, TK>;
+/**
+ * A helper function to create a {@link JsonCompatible.ObjectConverter | JSON-compatible ObjectConverter<T, TC>} which converts a
+ * supplied `unknown` value to a valid {@link JsonCompatibleType | JsonCompatibleType<T>} value.
+ * @param properties - The properties to convert.
+ * @param options - The options to use for the conversion.
+ * @returns A {@link JsonCompatible.ObjectConverter | JSON-compatible ObjectConverter<T, TC>} which
+ * converts a supplied `unknown` value to a valid {@link JsonCompatibleType | JsonCompatibleType<T>} value.
+ * @public
+ */
+export declare function object<T, TC = unknown>(properties: Conversion.FieldConverters<JsonCompatibleType<T>, TC>, options?: Conversion.ObjectConverterOptions<JsonCompatibleType<T>>): JsonCompatible.ObjectConverter<T, TC>;
+/**
+ * A helper function to create a {@link JsonCompatible.ObjectConverter | JSON-compatible ObjectConverter<T, TC>} which converts a
+ * supplied `unknown` value to a valid {@link JsonCompatibleType | JsonCompatibleType<T>} value.
+ * @param properties - The properties to convert.
+ * @param options - The options to use for the conversion.
+ * @returns A {@link JsonCompatible.ObjectConverter | JSON-compatible ObjectConverter<T, TC>} which
+ * converts a supplied `unknown` value to a valid {@link JsonCompatibleType | JsonCompatibleType<T>} value.
+ * @public
+ */
+export declare function strictObject<T, TC = unknown>(properties: Conversion.FieldConverters<JsonCompatibleType<T>, TC>, options?: Converters.StrictObjectConverterOptions<JsonCompatibleType<T>>): JsonCompatible.ObjectConverter<T, TC>;
+/**
+ * A helper function to create a {@link JsonCompatible.Converter | JSON-compatible Converter<T, TC>} which converts a
+ * supplied `unknown` value to a valid {@link JsonCompatibleType | JsonCompatibleType<T>} value.
+ * @param discriminatorProp - The name of the property used to discriminate types.
+ * @param converters - The converters to use for the conversion.
+ * @returns A {@link JsonCompatible.Converter | JSON-compatible Converter<T, TC>} which
+ * converts a supplied `unknown` value to a valid {@link JsonCompatibleType | JsonCompatibleType<T>} value.
+ * @public
+ */
+export declare function discriminatedObject<T, TD extends string = string, TC = unknown>(discriminatorProp: string, converters: Converters.DiscriminatedObjectConverters<JsonCompatibleType<T>, TD, TC>): JsonCompatible.Converter<T, TC>;
+//# sourceMappingURL=converters.d.ts.map

package/lib/packlets/json-compatible/converters.js

@@ -0,0 +1,97 @@
+"use strict";
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayOf = arrayOf;
+exports.recordOf = recordOf;
+exports.object = object;
+exports.strictObject = strictObject;
+exports.discriminatedObject = discriminatedObject;
+const ts_utils_1 = require("@fgv/ts-utils");
+/**
+ * A helper function to create a {@link JsonCompatible.ArrayConverter | JSON-compatible ArrayConverter<T, TC>}
+ * which converts a supplied `unknown` value to a valid array of {@link JsonCompatibleType | JsonCompatibleType<T>}.
+ * @param converter - {@link JsonCompatible.Converter | JSON-compatible Converter<T, TC>} or {@link JsonCompatible.Validator | JSON-compatible Validator<T>} used for each item in the source array.
+ * @param onError - The error handling option to use for the conversion.
+ * @returns A {@link JsonCompatible.ArrayConverter | JSON-compatible ArrayConverter<T, TC>} which returns `JsonCompatibleType<T>[]`.
+ * @public
+ */
+function arrayOf(converter, onError = 'failOnError') {
+    return ts_utils_1.Converters.arrayOf(converter, onError);
+}
+/**
+ * A helper function to create a {@link JsonCompatible.RecordConverter | JSON-compatible RecordConverter<T, TC, TK>}
+ * which converts the `string`-keyed properties using a supplied {@link JsonCompatible.Converter | JSON-compatible Converter<T, TC>} or
+ * {@link JsonCompatible.Validator | JSON-compatible Validator<T>} to produce a
+ * `Record<TK, JsonCompatibleType<T>>`.
+ * @remarks
+ * If present, the supplied `Converters.KeyedConverterOptions` can provide a strongly-typed
+ * converter for keys and/or control the handling of elements that fail conversion.
+ * @param converter - {@link JsonCompatible.Converter | JSON-compatible Converter<T, TC>}
+ * or {@link JsonCompatible.Validator | JSON-compatible Validator<T>} used for each item in the source object.
+ * @param options - Optional `Converters.KeyedConverterOptions<TK, TC>` which
+ * supplies a key converter and/or error-handling options.
+ * @returns A {@link JsonCompatible.RecordConverter | JSON-compatible RecordConverter<T, TC, TK>} which
+ * converts a supplied `unknown` value to a valid record of {@link JsonCompatibleType | JsonCompatible} values.
+ * @public
+ */
+function recordOf(converter, options) {
+    return ts_utils_1.Converters.recordOf(converter, options !== null && options !== void 0 ? options : { onError: 'fail' });
+}
+/**
+ * A helper function to create a {@link JsonCompatible.ObjectConverter | JSON-compatible ObjectConverter<T, TC>} which converts a
+ * supplied `unknown` value to a valid {@link JsonCompatibleType | JsonCompatibleType<T>} value.
+ * @param properties - The properties to convert.
+ * @param options - The options to use for the conversion.
+ * @returns A {@link JsonCompatible.ObjectConverter | JSON-compatible ObjectConverter<T, TC>} which
+ * converts a supplied `unknown` value to a valid {@link JsonCompatibleType | JsonCompatibleType<T>} value.
+ * @public
+ */
+function object(properties, options) {
+    return new ts_utils_1.Conversion.ObjectConverter(properties, options);
+}
+/**
+ * A helper function to create a {@link JsonCompatible.ObjectConverter | JSON-compatible ObjectConverter<T, TC>} which converts a
+ * supplied `unknown` value to a valid {@link JsonCompatibleType | JsonCompatibleType<T>} value.
+ * @param properties - The properties to convert.
+ * @param options - The options to use for the conversion.
+ * @returns A {@link JsonCompatible.ObjectConverter | JSON-compatible ObjectConverter<T, TC>} which
+ * converts a supplied `unknown` value to a valid {@link JsonCompatibleType | JsonCompatibleType<T>} value.
+ * @public
+ */
+function strictObject(properties, options) {
+    const objectOptions = Object.assign(Object.assign({}, options), { strict: true });
+    return new ts_utils_1.Conversion.ObjectConverter(properties, objectOptions);
+}
+/**
+ * A helper function to create a {@link JsonCompatible.Converter | JSON-compatible Converter<T, TC>} which converts a
+ * supplied `unknown` value to a valid {@link JsonCompatibleType | JsonCompatibleType<T>} value.
+ * @param discriminatorProp - The name of the property used to discriminate types.
+ * @param converters - The converters to use for the conversion.
+ * @returns A {@link JsonCompatible.Converter | JSON-compatible Converter<T, TC>} which
+ * converts a supplied `unknown` value to a valid {@link JsonCompatibleType | JsonCompatibleType<T>} value.
+ * @public
+ */
+function discriminatedObject(discriminatorProp, converters) {
+    return ts_utils_1.Converters.discriminatedObject(discriminatorProp, converters);
+}
+//# sourceMappingURL=converters.js.map

package/lib/packlets/json-compatible/index.d.ts

@@ -0,0 +1,5 @@
+export * from './common';
+import * as Converters from './converters';
+import * as Validators from './validators';
+export { Converters, Validators };
+//# sourceMappingURL=index.d.ts.map

package/lib/packlets/json-compatible/index.js

@@ -0,0 +1,66 @@
+"use strict";
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+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);
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Validators = exports.Converters = void 0;
+__exportStar(require("./common"), exports);
+const Converters = __importStar(require("./converters"));
+exports.Converters = Converters;
+const Validators = __importStar(require("./validators"));
+exports.Validators = Validators;
+//# sourceMappingURL=index.js.map

package/lib/packlets/json-compatible/validators.d.ts

@@ -0,0 +1,29 @@
+import { JsonCompatibleType } from '../json';
+import * as JsonCompatible from './common';
+import { Validation, Validators } from '@fgv/ts-utils';
+/**
+ * A helper function to create a {@link JsonCompatible.ArrayValidator | JSON-compatible ArrayValidator<T, TC>} which validates a supplied `unknown` value to a valid {@link JsonCompatibleType | JsonCompatible} value.
+ * @param validateElement - The element validator to use.
+ * @param params - The parameters to use for the validation.
+ * @returns A {@link JsonCompatible.ArrayValidator | JSON-compatible ArrayValidator<T, TC>} which validates a supplied `unknown` value to a valid {@link JsonCompatibleType | JsonCompatible} value.
+ * @public
+ */
+export declare function arrayOf<T, TC = unknown>(validateElement: JsonCompatible.Validator<T, TC>, params?: Omit<Validation.Classes.ArrayValidatorConstructorParams<JsonCompatibleType<T>, TC>, 'validateElement'>): JsonCompatible.ArrayValidator<T, TC>;
+/**
+ * A helper function to create a {@link JsonCompatible.RecordValidator | JSON-compatible RecordValidator<T, TC, TK>} which validates a supplied `unknown` value
+ * to a valid {@link JsonCompatibleType | JsonCompatible} value.
+ * @param validateElement - The element validator to use.
+ * @param options - The options to use for the validation.
+ * @returns A `Validation.Validator<Record<TK, JsonCompatibleType<T>>, TC>` which validates a supplied `unknown` value to a valid {@link JsonCompatibleType | JsonCompatible} value.
+ * @public
+ */
+export declare function recordOf<T, TC = unknown, TK extends string = string>(validateElement: JsonCompatible.Validator<T, TC>, options?: Validators.IRecordOfValidatorOptions<TK, TC>): JsonCompatible.RecordValidator<T, TC, TK>;
+/**
+ * A helper function to create a {@link JsonCompatible.ObjectValidator | JSON-compatible ObjectValidator<T, TC>} which validates a supplied `unknown` value to a valid {@link JsonCompatibleType | JsonCompatible} value.
+ * @param properties - The properties to validate.
+ * @param params - The parameters to use for the validation.
+ * @returns A {@link JsonCompatible.ObjectValidator | JSON-compatible ObjectValidator<T, TC>} which validates a supplied `unknown` value to a valid {@link JsonCompatibleType | JsonCompatible} value.
+ * @public
+ */
+export declare function object<T, TC = unknown>(properties: Validation.Classes.FieldValidators<JsonCompatibleType<T>, TC>, params?: Omit<Validation.Classes.ObjectValidatorConstructorParams<JsonCompatibleType<T>, TC>, 'fields'>): JsonCompatible.ObjectValidator<T, TC>;
+//# sourceMappingURL=validators.d.ts.map

package/lib/packlets/json-compatible/validators.js

@@ -0,0 +1,59 @@
+"use strict";
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayOf = arrayOf;
+exports.recordOf = recordOf;
+exports.object = object;
+const ts_utils_1 = require("@fgv/ts-utils");
+/**
+ * A helper function to create a {@link JsonCompatible.ArrayValidator | JSON-compatible ArrayValidator<T, TC>} which validates a supplied `unknown` value to a valid {@link JsonCompatibleType | JsonCompatible} value.
+ * @param validateElement - The element validator to use.
+ * @param params - The parameters to use for the validation.
+ * @returns A {@link JsonCompatible.ArrayValidator | JSON-compatible ArrayValidator<T, TC>} which validates a supplied `unknown` value to a valid {@link JsonCompatibleType | JsonCompatible} value.
+ * @public
+ */
+function arrayOf(validateElement, params) {
+    return ts_utils_1.Validators.arrayOf(validateElement, params !== null && params !== void 0 ? params : {});
+}
+/**
+ * A helper function to create a {@link JsonCompatible.RecordValidator | JSON-compatible RecordValidator<T, TC, TK>} which validates a supplied `unknown` value
+ * to a valid {@link JsonCompatibleType | JsonCompatible} value.
+ * @param validateElement - The element validator to use.
+ * @param options - The options to use for the validation.
+ * @returns A `Validation.Validator<Record<TK, JsonCompatibleType<T>>, TC>` which validates a supplied `unknown` value to a valid {@link JsonCompatibleType | JsonCompatible} value.
+ * @public
+ */
+function recordOf(validateElement, options) {
+    return ts_utils_1.Validators.recordOf(validateElement, options !== null && options !== void 0 ? options : {});
+}
+/**
+ * A helper function to create a {@link JsonCompatible.ObjectValidator | JSON-compatible ObjectValidator<T, TC>} which validates a supplied `unknown` value to a valid {@link JsonCompatibleType | JsonCompatible} value.
+ * @param properties - The properties to validate.
+ * @param params - The parameters to use for the validation.
+ * @returns A {@link JsonCompatible.ObjectValidator | JSON-compatible ObjectValidator<T, TC>} which validates a supplied `unknown` value to a valid {@link JsonCompatibleType | JsonCompatible} value.
+ * @public
+ */
+function object(properties, params) {
+    return ts_utils_1.Validators.object(properties, params !== null && params !== void 0 ? params : {});
+}
+//# sourceMappingURL=validators.js.map

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

@@ -1,4 +1,4 @@
-export * from './file';
 export * from './jsonLike';
 export * from './jsonTreeHelper';
+export type { IJsonFsDirectoryOptions, IReadDirectoryItem, ItemNameTransformFunction, IJsonFsDirectoryToMapOptions, IJsonFsHelperConfig, JsonFsHelperInitOptions } from './jsonFsHelper';
 //# sourceMappingURL=index.browser.d.ts.map

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

@@ -36,11 +36,11 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 // Browser-safe JSON file exports - excludes Node.js filesystem dependencies
-// Export core JSON functionality (no filesystem deps)
-__exportStar(require("./file"), exports);
+// Export browser-safe core functionality
 __exportStar(require("./jsonLike"), exports);
 // Export FileTree-based helper (web-compatible)
 __exportStar(require("./jsonTreeHelper"), exports);
 // Exclude:
+// - file.ts (wraps jsonFsHelper - requires Node.js fs/path)
 // - jsonFsHelper (requires Node.js fs/path)
 //# sourceMappingURL=index.browser.js.map

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

@@ -46,7 +46,7 @@ class JsonTreeHelper {
      */
     readJsonFromTree(fileTree, filePath) {
         return fileTree.getFile(filePath).onSuccess((file) => {
-            // Now getContents() returns JsonCompatible<unknown> which is assignable to JsonValue!
+            // Now getContents() returns JsonCompatibleType<unknown> which is assignable to JsonValue!
             return file.getContents();
         });
     }

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

@@ -1,4 +1,4 @@
-import { Validator } from '@fgv/ts-utils';
+import { Validation, Validator } from '@fgv/ts-utils';
 import { JsonArray, JsonObject, JsonPrimitive, JsonValue } from '../json';
 /**
  * Validation context for in-place JSON validators.
@@ -37,4 +37,44 @@ export declare const jsonArray: Validator<JsonArray, IJsonValidatorContext>;
  * @public
  */
 export declare const jsonValue: Validator<JsonValue, IJsonValidatorContext>;
+/**
+ * A {@link Validation.Classes.StringValidator | 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.
+ * Accepts {@link Validators.IJsonValidatorContext | IJsonValidatorContext} but ignores it.
+ * @public
+ */
+export declare const number: Validator<number, IJsonValidatorContext>;
+/**
+ * A {@link Validation.Classes.BooleanValidator | BooleanValidator} which validates a boolean in place.
+ * Accepts {@link Validators.IJsonValidatorContext | 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.
+ * 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
+ * supplied enumerated values. Anything else fails.
+ *
+ * @remarks
+ * This JSON variant accepts an {@link Validators.IJsonValidatorContext | 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>`.
+ * @public
+ */
+export declare function enumeratedValue<T>(values: ReadonlyArray<T>, message?: string): Validator<T, IJsonValidatorContext | ReadonlyArray<T>>;
 //# sourceMappingURL=validators.d.ts.map