@fgv/ts-res 5.0.0-28 → 5.0.0-29

package/dist/ts-res.d.ts

@@ -1828,12 +1828,18 @@ declare namespace Config {
     export {
         Model,
         Convert_9 as Convert,
+        createQualifierTypeFactory,
+        createResourceTypeFactory,
+        QualifierTypeFactoryFunction,
+        ResourceTypeFactoryFunction,
         IConfigInitFactory,
         ChainedConfigInitFactory,
         BuiltInQualifierTypeFactory,
         QualifierTypeFactory,
+        ValidatingQualifierTypeFactory,
         BuiltInResourceTypeFactory,
         ResourceTypeFactory,
+        ValidatingResourceTypeFactory,
         updateSystemConfigurationQualifierDefaultValues,
         ISystemConfigurationInitParams,
         SystemConfiguration,
@@ -2349,6 +2355,14 @@ declare namespace Convert_9 {
     }
 }
 
+/**
+ * Creates a {@link Config.IConfigInitFactory | IConfigInitFactory} from a factory function.
+ * @param fn - The factory function to wrap.
+ * @returns An `IConfigInitFactory` instance that delegates to the function.
+ * @public
+ */
+declare function createQualifierTypeFactory<T extends QualifierType = QualifierType>(fn: QualifierTypeFactoryFunction<T>): IConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, T>;
+
 /**
  * Creates a {@link QualifierTypes.QualifierType | QualifierType} from a configuration object.
  * This factory function determines the appropriate qualifier type based on the systemType
@@ -2373,6 +2387,14 @@ declare function createQualifierTypeFromConfig(typeConfig: Config_2.IAnyQualifie
  */
 declare function createQualifierTypeFromSystemConfig(typeConfig: Config_2.ISystemQualifierTypeConfig): Result<SystemQualifierType>;
 
+/**
+ * Creates a {@link Config.IConfigInitFactory | IConfigInitFactory} from a resource type factory function.
+ * @param fn - The factory function to wrap.
+ * @returns An `IConfigInitFactory` instance that delegates to the function.
+ * @public
+ */
+declare function createResourceTypeFactory(fn: ResourceTypeFactoryFunction): IConfigInitFactory<ResourceTypes.Config.IResourceTypeConfig, ResourceType>;
+
 /**
  * Creates a {@link ResourceTypes.ResourceType | ResourceType} from a configuration object.
  * @param config - The {@link ResourceTypes.Config.IResourceTypeConfig | configuration object}
@@ -7521,14 +7543,23 @@ declare function qualifierTypeConfig<T, TD = unknown>(config: Converter<T, TD>):
 declare class QualifierTypeFactory<T extends QualifierType = SystemQualifierType> extends ChainedConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, T | SystemQualifierType> {
     /**
      * Constructor for a {@link Config.QualifierTypeFactory | qualifier type factory}.
-     * @param factories - Array of {@link Config.IConfigInitFactory | factories} for custom qualifier types.
+     * @param factories - Array of factories for custom qualifier types. Can be:
+     *                    - {@link Config.IConfigInitFactory | IConfigInitFactory} instances
+     *                    - {@link Config.QualifierTypeFactoryFunction | Factory functions}
+     *                    - A mix of both
      *                    These are tried in order before falling back to built-in types.
      * @remarks The {@link Config.BuiltInQualifierTypeFactory | built-in factory} is always appended to handle
      *          system qualifier types (Language, Territory, Literal).
      */
-    constructor(factories: IConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, T>[]);
+    constructor(factories: Array<IConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, T> | QualifierTypeFactoryFunction<T>>);
 }
 
+/**
+ * Function signature for creating a qualifier type from configuration.
+ * @public
+ */
+declare type QualifierTypeFactoryFunction<T extends QualifierType = QualifierType> = (config: QualifierTypes.Config.IAnyQualifierTypeConfig) => Result<T>;
+
 /**
  * Branded number representing a validated qualifier type index.
  * @public
@@ -9257,12 +9288,21 @@ declare const resourceTypeConfig: ObjectConverter<IResourceTypeConfig<JsonObject
 declare class ResourceTypeFactory extends ChainedConfigInitFactory<ResourceTypes.Config.IResourceTypeConfig, ResourceType> {
     /**
      * Constructor for a resource type factory.
-     * @param factories - The {@link Config.IConfigInitFactory | factories}  to chain.
+     * @param factories - Array of factories for resource types. Can be:
+     *                    - {@link Config.IConfigInitFactory | IConfigInitFactory} instances
+     *                    - {@link Config.ResourceTypeFactoryFunction | Factory functions}
+     *                    - A mix of both
      * @remarks The {@link Config.BuiltInResourceTypeFactory | built-in factory} is always added to the end of the chain.
      */
-    constructor(factories: IConfigInitFactory<ResourceTypes.Config.IResourceTypeConfig, ResourceType>[]);
+    constructor(factories: Array<IConfigInitFactory<ResourceTypes.Config.IResourceTypeConfig, ResourceType> | ResourceTypeFactoryFunction>);
 }
 
+/**
+ * Function signature for creating a resource type from configuration.
+ * @public
+ */
+declare type ResourceTypeFactoryFunction = (config: ResourceTypes.Config.IResourceTypeConfig) => Result<ResourceType>;
+
 /**
  * Branded number representing a validated resource type index.
  * @public
@@ -10100,6 +10140,77 @@ declare function validateSystemConfiguration(config: unknown): Result<ISystemCon
  */
 declare function validateZipArchiveManifest(manifest: unknown): Result<Json_2.IZipArchiveManifest>;
 
+/**
+ * A factory that validates and creates {@link QualifierTypes.QualifierType | QualifierType} instances
+ * from weakly-typed configuration objects. This factory accepts configurations with unvalidated
+ * string properties and validates them before delegating to the underlying factory chain.
+ *
+ * This pattern is useful at package boundaries where type identity issues may occur with
+ * branded types across different package instances.
+ *
+ * @example
+ * ```typescript
+ * // Accept weakly-typed config from external source
+ * const validatingFactory = new ValidatingQualifierTypeFactory([customFactory]);
+ *
+ * // Config can have plain string types instead of branded types
+ * const config = {
+ *   name: 'my-qualifier',  // plain string, not QualifierTypeName
+ *   systemType: 'custom',   // plain string
+ *   configuration: { ... }
+ * };
+ *
+ * const result = validatingFactory.create(config); // Validates and converts internally
+ * ```
+ *
+ * @public
+ */
+declare class ValidatingQualifierTypeFactory<T extends QualifierType = SystemQualifierType> implements IConfigInitFactory<unknown, T | SystemQualifierType> {
+    private readonly _innerFactory;
+    /**
+     * Constructor for a validating qualifier type factory.
+     * @param factories - Array of factories for custom qualifier types. Can be:
+     *                    - {@link Config.IConfigInitFactory | IConfigInitFactory} instances
+     *                    - {@link Config.QualifierTypeFactoryFunction | Factory functions}
+     *                    - A mix of both
+     */
+    constructor(factories: Array<IConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, T> | QualifierTypeFactoryFunction<T>>);
+    /**
+     * Creates a qualifier type from a weakly-typed configuration object.
+     * @param config - The configuration object to validate and use for creation.
+     * @returns A result containing the new qualifier type if successful.
+     */
+    create(config: unknown): Result<T | SystemQualifierType>;
+}
+
+/**
+ * A factory that validates and creates {@link ResourceTypes.ResourceType | ResourceType} instances
+ * from weakly-typed configuration objects. This factory accepts configurations with unvalidated
+ * string properties and validates them before delegating to the underlying factory chain.
+ *
+ * This pattern is useful at package boundaries where type identity issues may occur with
+ * branded types across different package instances.
+ *
+ * @public
+ */
+declare class ValidatingResourceTypeFactory implements IConfigInitFactory<unknown, ResourceType> {
+    private readonly _innerFactory;
+    /**
+     * Constructor for a validating resource type factory.
+     * @param factories - Array of factories for resource types. Can be:
+     *                    - {@link Config.IConfigInitFactory | IConfigInitFactory} instances
+     *                    - {@link Config.ResourceTypeFactoryFunction | Factory functions}
+     *                    - A mix of both
+     */
+    constructor(factories: Array<IConfigInitFactory<ResourceTypes.Config.IResourceTypeConfig, ResourceType> | ResourceTypeFactoryFunction>);
+    /**
+     * Creates a resource type from a weakly-typed configuration object.
+     * @param config - The configuration object to validate and use for creation.
+     * @returns A result containing the new resource type if successful.
+     */
+    create(config: unknown): Result<ResourceType>;
+}
+
 /**
  * A {@link Runtime.SimpleContextQualifierProvider | SimpleContextQualifierProvider} with a
  * {@link Runtime.Context.ContextQualifierProviderValidator | validator} property that enables

package/lib/packlets/config/configInitFactory.d.ts

@@ -3,6 +3,16 @@ import { QualifierType, SystemQualifierType } from '../qualifier-types';
 import * as QualifierTypes from '../qualifier-types';
 import * as ResourceTypes from '../resource-types';
 import { ResourceType } from '../resource-types';
+/**
+ * Function signature for creating a qualifier type from configuration.
+ * @public
+ */
+export type QualifierTypeFactoryFunction<T extends QualifierType = QualifierType> = (config: QualifierTypes.Config.IAnyQualifierTypeConfig) => Result<T>;
+/**
+ * Function signature for creating a resource type from configuration.
+ * @public
+ */
+export type ResourceTypeFactoryFunction = (config: ResourceTypes.Config.IResourceTypeConfig) => Result<ResourceType>;
 /**
  * Interface for a factory that creates a new instance of a configuration object.
  * @public
@@ -15,6 +25,20 @@ export interface IConfigInitFactory<TConfig, T> {
      */
     create(config: TConfig): Result<T>;
 }
+/**
+ * Creates a {@link Config.IConfigInitFactory | IConfigInitFactory} from a factory function.
+ * @param fn - The factory function to wrap.
+ * @returns An `IConfigInitFactory` instance that delegates to the function.
+ * @public
+ */
+export declare function createQualifierTypeFactory<T extends QualifierType = QualifierType>(fn: QualifierTypeFactoryFunction<T>): IConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, T>;
+/**
+ * Creates a {@link Config.IConfigInitFactory | IConfigInitFactory} from a resource type factory function.
+ * @param fn - The factory function to wrap.
+ * @returns An `IConfigInitFactory` instance that delegates to the function.
+ * @public
+ */
+export declare function createResourceTypeFactory(fn: ResourceTypeFactoryFunction): IConfigInitFactory<ResourceTypes.Config.IResourceTypeConfig, ResourceType>;
 /**
  * A factory that chains multiple factories together.
  * @public
@@ -87,12 +111,57 @@ export declare class BuiltInQualifierTypeFactory implements IConfigInitFactory<Q
 export declare class QualifierTypeFactory<T extends QualifierType = SystemQualifierType> extends ChainedConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, T | SystemQualifierType> {
     /**
      * Constructor for a {@link Config.QualifierTypeFactory | qualifier type factory}.
-     * @param factories - Array of {@link Config.IConfigInitFactory | factories} for custom qualifier types.
+     * @param factories - Array of factories for custom qualifier types. Can be:
+     *                    - {@link Config.IConfigInitFactory | IConfigInitFactory} instances
+     *                    - {@link Config.QualifierTypeFactoryFunction | Factory functions}
+     *                    - A mix of both
      *                    These are tried in order before falling back to built-in types.
      * @remarks The {@link Config.BuiltInQualifierTypeFactory | built-in factory} is always appended to handle
      *          system qualifier types (Language, Territory, Literal).
      */
-    constructor(factories: IConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, T>[]);
+    constructor(factories: Array<IConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, T> | QualifierTypeFactoryFunction<T>>);
+}
+/**
+ * A factory that validates and creates {@link QualifierTypes.QualifierType | QualifierType} instances
+ * from weakly-typed configuration objects. This factory accepts configurations with unvalidated
+ * string properties and validates them before delegating to the underlying factory chain.
+ *
+ * This pattern is useful at package boundaries where type identity issues may occur with
+ * branded types across different package instances.
+ *
+ * @example
+ * ```typescript
+ * // Accept weakly-typed config from external source
+ * const validatingFactory = new ValidatingQualifierTypeFactory([customFactory]);
+ *
+ * // Config can have plain string types instead of branded types
+ * const config = {
+ *   name: 'my-qualifier',  // plain string, not QualifierTypeName
+ *   systemType: 'custom',   // plain string
+ *   configuration: { ... }
+ * };
+ *
+ * const result = validatingFactory.create(config); // Validates and converts internally
+ * ```
+ *
+ * @public
+ */
+export declare class ValidatingQualifierTypeFactory<T extends QualifierType = SystemQualifierType> implements IConfigInitFactory<unknown, T | SystemQualifierType> {
+    private readonly _innerFactory;
+    /**
+     * Constructor for a validating qualifier type factory.
+     * @param factories - Array of factories for custom qualifier types. Can be:
+     *                    - {@link Config.IConfigInitFactory | IConfigInitFactory} instances
+     *                    - {@link Config.QualifierTypeFactoryFunction | Factory functions}
+     *                    - A mix of both
+     */
+    constructor(factories: Array<IConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, T> | QualifierTypeFactoryFunction<T>>);
+    /**
+     * Creates a qualifier type from a weakly-typed configuration object.
+     * @param config - The configuration object to validate and use for creation.
+     * @returns A result containing the new qualifier type if successful.
+     */
+    create(config: unknown): Result<T | SystemQualifierType>;
 }
 /**
  * A factory that creates a {@link ResourceTypes.ResourceType | ResourceType} from a {@link ResourceTypes.Config.IResourceTypeConfig | resource type configuration}.
@@ -110,9 +179,39 @@ export declare class BuiltInResourceTypeFactory implements IConfigInitFactory<Re
 export declare class ResourceTypeFactory extends ChainedConfigInitFactory<ResourceTypes.Config.IResourceTypeConfig, ResourceType> {
     /**
      * Constructor for a resource type factory.
-     * @param factories - The {@link Config.IConfigInitFactory | factories}  to chain.
+     * @param factories - Array of factories for resource types. Can be:
+     *                    - {@link Config.IConfigInitFactory | IConfigInitFactory} instances
+     *                    - {@link Config.ResourceTypeFactoryFunction | Factory functions}
+     *                    - A mix of both
      * @remarks The {@link Config.BuiltInResourceTypeFactory | built-in factory} is always added to the end of the chain.
      */
-    constructor(factories: IConfigInitFactory<ResourceTypes.Config.IResourceTypeConfig, ResourceType>[]);
+    constructor(factories: Array<IConfigInitFactory<ResourceTypes.Config.IResourceTypeConfig, ResourceType> | ResourceTypeFactoryFunction>);
+}
+/**
+ * A factory that validates and creates {@link ResourceTypes.ResourceType | ResourceType} instances
+ * from weakly-typed configuration objects. This factory accepts configurations with unvalidated
+ * string properties and validates them before delegating to the underlying factory chain.
+ *
+ * This pattern is useful at package boundaries where type identity issues may occur with
+ * branded types across different package instances.
+ *
+ * @public
+ */
+export declare class ValidatingResourceTypeFactory implements IConfigInitFactory<unknown, ResourceType> {
+    private readonly _innerFactory;
+    /**
+     * Constructor for a validating resource type factory.
+     * @param factories - Array of factories for resource types. Can be:
+     *                    - {@link Config.IConfigInitFactory | IConfigInitFactory} instances
+     *                    - {@link Config.ResourceTypeFactoryFunction | Factory functions}
+     *                    - A mix of both
+     */
+    constructor(factories: Array<IConfigInitFactory<ResourceTypes.Config.IResourceTypeConfig, ResourceType> | ResourceTypeFactoryFunction>);
+    /**
+     * Creates a resource type from a weakly-typed configuration object.
+     * @param config - The configuration object to validate and use for creation.
+     * @returns A result containing the new resource type if successful.
+     */
+    create(config: unknown): Result<ResourceType>;
 }
 //# sourceMappingURL=configInitFactory.d.ts.map

package/lib/packlets/config/configInitFactory.js

@@ -54,10 +54,34 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResourceTypeFactory = exports.BuiltInResourceTypeFactory = exports.QualifierTypeFactory = exports.BuiltInQualifierTypeFactory = exports.ChainedConfigInitFactory = void 0;
+exports.ValidatingResourceTypeFactory = exports.ResourceTypeFactory = exports.BuiltInResourceTypeFactory = exports.ValidatingQualifierTypeFactory = exports.QualifierTypeFactory = exports.BuiltInQualifierTypeFactory = exports.ChainedConfigInitFactory = void 0;
+exports.createQualifierTypeFactory = createQualifierTypeFactory;
+exports.createResourceTypeFactory = createResourceTypeFactory;
 const ts_utils_1 = require("@fgv/ts-utils");
 const QualifierTypes = __importStar(require("../qualifier-types"));
 const ResourceTypes = __importStar(require("../resource-types"));
+/**
+ * Creates a {@link Config.IConfigInitFactory | IConfigInitFactory} from a factory function.
+ * @param fn - The factory function to wrap.
+ * @returns An `IConfigInitFactory` instance that delegates to the function.
+ * @public
+ */
+function createQualifierTypeFactory(fn) {
+    return {
+        create: fn
+    };
+}
+/**
+ * Creates a {@link Config.IConfigInitFactory | IConfigInitFactory} from a resource type factory function.
+ * @param fn - The factory function to wrap.
+ * @returns An `IConfigInitFactory` instance that delegates to the function.
+ * @public
+ */
+function createResourceTypeFactory(fn) {
+    return {
+        create: fn
+    };
+}
 /**
  * A factory that chains multiple factories together.
  * @public
@@ -146,16 +170,70 @@ exports.BuiltInQualifierTypeFactory = BuiltInQualifierTypeFactory;
 class QualifierTypeFactory extends ChainedConfigInitFactory {
     /**
      * Constructor for a {@link Config.QualifierTypeFactory | qualifier type factory}.
-     * @param factories - Array of {@link Config.IConfigInitFactory | factories} for custom qualifier types.
+     * @param factories - Array of factories for custom qualifier types. Can be:
+     *                    - {@link Config.IConfigInitFactory | IConfigInitFactory} instances
+     *                    - {@link Config.QualifierTypeFactoryFunction | Factory functions}
+     *                    - A mix of both
      *                    These are tried in order before falling back to built-in types.
      * @remarks The {@link Config.BuiltInQualifierTypeFactory | built-in factory} is always appended to handle
      *          system qualifier types (Language, Territory, Literal).
      */
     constructor(factories) {
-        super([...factories, new BuiltInQualifierTypeFactory()]);
+        const normalizedFactories = factories.map((f) => typeof f === 'function' ? createQualifierTypeFactory(f) : f);
+        super([...normalizedFactories, new BuiltInQualifierTypeFactory()]);
     }
 }
 exports.QualifierTypeFactory = QualifierTypeFactory;
+/**
+ * A factory that validates and creates {@link QualifierTypes.QualifierType | QualifierType} instances
+ * from weakly-typed configuration objects. This factory accepts configurations with unvalidated
+ * string properties and validates them before delegating to the underlying factory chain.
+ *
+ * This pattern is useful at package boundaries where type identity issues may occur with
+ * branded types across different package instances.
+ *
+ * @example
+ * ```typescript
+ * // Accept weakly-typed config from external source
+ * const validatingFactory = new ValidatingQualifierTypeFactory([customFactory]);
+ *
+ * // Config can have plain string types instead of branded types
+ * const config = {
+ *   name: 'my-qualifier',  // plain string, not QualifierTypeName
+ *   systemType: 'custom',   // plain string
+ *   configuration: { ... }
+ * };
+ *
+ * const result = validatingFactory.create(config); // Validates and converts internally
+ * ```
+ *
+ * @public
+ */
+class ValidatingQualifierTypeFactory {
+    /**
+     * Constructor for a validating qualifier type factory.
+     * @param factories - Array of factories for custom qualifier types. Can be:
+     *                    - {@link Config.IConfigInitFactory | IConfigInitFactory} instances
+     *                    - {@link Config.QualifierTypeFactoryFunction | Factory functions}
+     *                    - A mix of both
+     */
+    constructor(factories) {
+        this._innerFactory = new QualifierTypeFactory(factories);
+    }
+    /**
+     * Creates a qualifier type from a weakly-typed configuration object.
+     * @param config - The configuration object to validate and use for creation.
+     * @returns A result containing the new qualifier type if successful.
+     */
+    create(config) {
+        return QualifierTypes.Config.Convert.anyQualifierTypeConfig
+            .convert(config)
+            .onSuccess((validatedConfig) => {
+            return this._innerFactory.create(validatedConfig);
+        });
+    }
+}
+exports.ValidatingQualifierTypeFactory = ValidatingQualifierTypeFactory;
 /**
  * A factory that creates a {@link ResourceTypes.ResourceType | ResourceType} from a {@link ResourceTypes.Config.IResourceTypeConfig | resource type configuration}.
  * @public
@@ -175,13 +253,50 @@ exports.BuiltInResourceTypeFactory = BuiltInResourceTypeFactory;
 class ResourceTypeFactory extends ChainedConfigInitFactory {
     /**
      * Constructor for a resource type factory.
-     * @param factories - The {@link Config.IConfigInitFactory | factories}  to chain.
+     * @param factories - Array of factories for resource types. Can be:
+     *                    - {@link Config.IConfigInitFactory | IConfigInitFactory} instances
+     *                    - {@link Config.ResourceTypeFactoryFunction | Factory functions}
+     *                    - A mix of both
      * @remarks The {@link Config.BuiltInResourceTypeFactory | built-in factory} is always added to the end of the chain.
      */
     constructor(factories) {
         factories = factories !== null && factories !== void 0 ? factories : [];
-        super([...factories, new BuiltInResourceTypeFactory()]);
+        const normalizedFactories = factories.map((f) => typeof f === 'function' ? createResourceTypeFactory(f) : f);
+        super([...normalizedFactories, new BuiltInResourceTypeFactory()]);
     }
 }
 exports.ResourceTypeFactory = ResourceTypeFactory;
+/**
+ * A factory that validates and creates {@link ResourceTypes.ResourceType | ResourceType} instances
+ * from weakly-typed configuration objects. This factory accepts configurations with unvalidated
+ * string properties and validates them before delegating to the underlying factory chain.
+ *
+ * This pattern is useful at package boundaries where type identity issues may occur with
+ * branded types across different package instances.
+ *
+ * @public
+ */
+class ValidatingResourceTypeFactory {
+    /**
+     * Constructor for a validating resource type factory.
+     * @param factories - Array of factories for resource types. Can be:
+     *                    - {@link Config.IConfigInitFactory | IConfigInitFactory} instances
+     *                    - {@link Config.ResourceTypeFactoryFunction | Factory functions}
+     *                    - A mix of both
+     */
+    constructor(factories) {
+        this._innerFactory = new ResourceTypeFactory(factories);
+    }
+    /**
+     * Creates a resource type from a weakly-typed configuration object.
+     * @param config - The configuration object to validate and use for creation.
+     * @returns A result containing the new resource type if successful.
+     */
+    create(config) {
+        return ResourceTypes.Config.Convert.resourceTypeConfig.convert(config).onSuccess((validatedConfig) => {
+            return this._innerFactory.create(validatedConfig);
+        });
+    }
+}
+exports.ValidatingResourceTypeFactory = ValidatingResourceTypeFactory;
 //# sourceMappingURL=configInitFactory.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fgv/ts-res",
-  "version": "5.0.0-28",
+  "version": "5.0.0-29",
   "description": "Multi-dimensional Resource Runtime",
   "main": "lib/index.js",
   "types": "dist/ts-res.d.ts",
@@ -44,16 +44,16 @@
     "@rushstack/heft-node-rig": "2.9.5",
     "@types/heft-jest": "1.0.6",
     "eslint-plugin-tsdoc": "~0.4.0",
-    "@fgv/ts-extras": "5.0.0-28",
-    "@fgv/ts-utils-jest": "5.0.0-28"
+    "@fgv/ts-utils-jest": "5.0.0-29",
+    "@fgv/ts-extras": "5.0.0-29"
   },
   "dependencies": {
     "luxon": "^3.7.2",
     "fflate": "~0.8.2",
-    "@fgv/ts-json-base": "5.0.0-28",
-    "@fgv/ts-bcp47": "5.0.0-28",
-    "@fgv/ts-utils": "5.0.0-28",
-    "@fgv/ts-json": "5.0.0-28"
+    "@fgv/ts-utils": "5.0.0-29",
+    "@fgv/ts-json-base": "5.0.0-29",
+    "@fgv/ts-bcp47": "5.0.0-29",
+    "@fgv/ts-json": "5.0.0-29"
   },
   "scripts": {
     "build": "heft build --clean",