@fgv/ts-res 5.1.0-37 → 5.1.0-39

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

@@ -1,217 +0,0 @@
-import { Result } from '@fgv/ts-utils';
-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
- */
-export interface IConfigInitFactory<TConfig, T> {
-    /**
-     * Creates a new instance of a configuration object.
-     * @param config - The configuration object to create.
-     * @returns A result containing the new instance of the configuration object.
-     */
-    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
- */
-export declare class ChainedConfigInitFactory<TConfig, T> implements IConfigInitFactory<TConfig, T> {
-    readonly factories: IConfigInitFactory<TConfig, T>[];
-    /**
-     * Constructor for a chained config init factory.
-     * @param factories - The factories to chain.
-     */
-    constructor(factories: IConfigInitFactory<TConfig, T>[]);
-    /**
-     * Creates a new instance of a configuration object.
-     * @param config - The configuration object to create.
-     * @returns A result containing the new instance of the configuration object.
-     */
-    create(config: TConfig): Result<T>;
-}
-/**
- * A factory that creates a {@link QualifierTypes.SystemQualifierType | SystemQualifierType} from
- * {@link QualifierTypes.Config.IAnyQualifierTypeConfig | any qualifier type configuration}.
- * @returns `Success` with the new {@link QualifierTypes.SystemQualifierType | SystemQualifierType}
- * if successful, `Failure` with an error message otherwise.
- * @public
- */
-export declare class BuiltInQualifierTypeFactory implements IConfigInitFactory<QualifierTypes.Config.ISystemQualifierTypeConfig, SystemQualifierType> {
-    /** {@inheritDoc Config.IConfigInitFactory.create} */
-    create(config: QualifierTypes.Config.IAnyQualifierTypeConfig): Result<SystemQualifierType>;
-}
-/**
- * A factory that creates {@link QualifierTypes.QualifierType | QualifierType} instances from configuration,
- * supporting both built-in system types and custom external types.
- *
- * This factory allows external consumers to extend the qualifier type system with their own custom types
- * while maintaining support for all built-in types (Language, Territory, Literal).
- *
- * @typeParam T - The custom qualifier type(s) to support. Defaults to {@link QualifierTypes.SystemQualifierType | SystemQualifierType}.
- *
- * @example Creating a factory with custom qualifier types
- * ```typescript
- * // Define a custom qualifier type
- * class CustomQualifierType extends QualifierType {
- *   // ... implementation
- * }
- *
- * // Define a discriminated union of all types
- * type AppQualifierType = SystemQualifierType | CustomQualifierType;
- *
- * // Create a factory that handles custom types
- * const customFactory: IConfigInitFactory<IAnyQualifierTypeConfig, CustomQualifierType> = {
- *   create(config) {
- *     // ... handle custom type creation
- *   }
- * };
- *
- * // Create the combined factory
- * const qualifierTypeFactory = new QualifierTypeFactory<AppQualifierType>([customFactory]);
- *
- * // The factory returns T | SystemQualifierType, supporting all types
- * const result = qualifierTypeFactory.create(config); // Result<AppQualifierType | SystemQualifierType>
- * ```
- *
- * @remarks
- * - The factory chains custom factories with the built-in factory
- * - Custom factories are tried first, falling back to built-in types
- * - The return type is a union of custom types (T) and system types
- *
- * @public
- */
-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 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: 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}.
- * @public
- */
-export declare class BuiltInResourceTypeFactory implements IConfigInitFactory<ResourceTypes.Config.IResourceTypeConfig, ResourceType> {
-    /** {@inheritDoc Config.IConfigInitFactory.create} */
-    create(config: ResourceTypes.Config.IResourceTypeConfig): Result<ResourceType>;
-}
-/**
- * A factory that creates a {@link ResourceTypes.ResourceType | ResourceType} from a {@link ResourceTypes.Config.IResourceTypeConfig | resource type configuration}
- * by chaining a supplied factory with a {@link Config.BuiltInResourceTypeFactory | built-in factory} that handles built-in resource types.
- * @public
- */
-export declare class ResourceTypeFactory extends ChainedConfigInitFactory<ResourceTypes.Config.IResourceTypeConfig, ResourceType> {
-    /**
-     * Constructor for a 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
-     * @remarks The {@link Config.BuiltInResourceTypeFactory | built-in factory} is always added to the end of the chain.
-     */
-    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.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"configInitFactory.d.ts","sourceRoot":"","sources":["../../../src/packlets/config/configInitFactory.ts"],"names":[],"mappings":"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"}

package/lib/packlets/config/configInitFactory.js

@@ -1,303 +0,0 @@
-"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 __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.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
- */
-class ChainedConfigInitFactory {
-    /**
-     * Constructor for a chained config init factory.
-     * @param factories - The factories to chain.
-     */
-    constructor(factories) {
-        this.factories = factories;
-    }
-    /**
-     * Creates a new instance of a configuration object.
-     * @param config - The configuration object to create.
-     * @returns A result containing the new instance of the configuration object.
-     */
-    create(config) {
-        for (const factory of this.factories) {
-            const result = factory.create(config);
-            if (result.isSuccess()) {
-                return result;
-            }
-        }
-        return (0, ts_utils_1.fail)('No factory was able to create the configuration object');
-    }
-}
-exports.ChainedConfigInitFactory = ChainedConfigInitFactory;
-/**
- * A factory that creates a {@link QualifierTypes.SystemQualifierType | SystemQualifierType} from
- * {@link QualifierTypes.Config.IAnyQualifierTypeConfig | any qualifier type configuration}.
- * @returns `Success` with the new {@link QualifierTypes.SystemQualifierType | SystemQualifierType}
- * if successful, `Failure` with an error message otherwise.
- * @public
- */
-class BuiltInQualifierTypeFactory {
-    /** {@inheritDoc Config.IConfigInitFactory.create} */
-    create(config) {
-        if (QualifierTypes.Config.isSystemQualifierTypeConfig(config)) {
-            return QualifierTypes.createQualifierTypeFromSystemConfig(config);
-        }
-        /* c8 ignore next 2 - functional code tested but coverage intermittently missed */
-        return (0, ts_utils_1.fail)(`${config.name}: unknown built-in qualifier type (${config.systemType})`);
-    }
-}
-exports.BuiltInQualifierTypeFactory = BuiltInQualifierTypeFactory;
-/**
- * A factory that creates {@link QualifierTypes.QualifierType | QualifierType} instances from configuration,
- * supporting both built-in system types and custom external types.
- *
- * This factory allows external consumers to extend the qualifier type system with their own custom types
- * while maintaining support for all built-in types (Language, Territory, Literal).
- *
- * @typeParam T - The custom qualifier type(s) to support. Defaults to {@link QualifierTypes.SystemQualifierType | SystemQualifierType}.
- *
- * @example Creating a factory with custom qualifier types
- * ```typescript
- * // Define a custom qualifier type
- * class CustomQualifierType extends QualifierType {
- *   // ... implementation
- * }
- *
- * // Define a discriminated union of all types
- * type AppQualifierType = SystemQualifierType | CustomQualifierType;
- *
- * // Create a factory that handles custom types
- * const customFactory: IConfigInitFactory<IAnyQualifierTypeConfig, CustomQualifierType> = {
- *   create(config) {
- *     // ... handle custom type creation
- *   }
- * };
- *
- * // Create the combined factory
- * const qualifierTypeFactory = new QualifierTypeFactory<AppQualifierType>([customFactory]);
- *
- * // The factory returns T | SystemQualifierType, supporting all types
- * const result = qualifierTypeFactory.create(config); // Result<AppQualifierType | SystemQualifierType>
- * ```
- *
- * @remarks
- * - The factory chains custom factories with the built-in factory
- * - Custom factories are tried first, falling back to built-in types
- * - The return type is a union of custom types (T) and system types
- *
- * @public
- */
-class QualifierTypeFactory extends ChainedConfigInitFactory {
-    /**
-     * Constructor for a {@link Config.QualifierTypeFactory | 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
-     *                    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) {
-        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
- */
-class BuiltInResourceTypeFactory {
-    /** {@inheritDoc Config.IConfigInitFactory.create} */
-    create(config) {
-        return ResourceTypes.createResourceTypeFromConfig(config);
-    }
-}
-exports.BuiltInResourceTypeFactory = BuiltInResourceTypeFactory;
-/**
- * A factory that creates a {@link ResourceTypes.ResourceType | ResourceType} from a {@link ResourceTypes.Config.IResourceTypeConfig | resource type configuration}
- * by chaining a supplied factory with a {@link Config.BuiltInResourceTypeFactory | built-in factory} that handles built-in resource types.
- * @public
- */
-class ResourceTypeFactory extends ChainedConfigInitFactory {
-    /**
-     * Constructor for a 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
-     * @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 : [];
-        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/lib/packlets/config/configInitFactory.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"configInitFactory.js","sourceRoot":"","sources":["../../../src/packlets/config/configInitFactory.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2025 Erik Fortune\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\nimport { Result, fail } from '@fgv/ts-utils';\nimport { QualifierType, SystemQualifierType } from '../qualifier-types';\nimport * as QualifierTypes from '../qualifier-types';\nimport * as ResourceTypes from '../resource-types';\nimport { ResourceType } from '../resource-types';\n\n/**\n * Function signature for creating a qualifier type from configuration.\n * @public\n */\nexport type QualifierTypeFactoryFunction<T extends QualifierType = QualifierType> = (\n  config: QualifierTypes.Config.IAnyQualifierTypeConfig\n) => Result<T>;\n\n/**\n * Function signature for creating a resource type from configuration.\n * @public\n */\nexport type ResourceTypeFactoryFunction = (\n  config: ResourceTypes.Config.IResourceTypeConfig\n) => Result<ResourceType>;\n\n/**\n * Interface for a factory that creates a new instance of a configuration object.\n * @public\n */\nexport interface IConfigInitFactory<TConfig, T> {\n  /**\n   * Creates a new instance of a configuration object.\n   * @param config - The configuration object to create.\n   * @returns A result containing the new instance of the configuration object.\n   */\n  create(config: TConfig): Result<T>;\n}\n\n/**\n * Creates a {@link Config.IConfigInitFactory | IConfigInitFactory} from a factory function.\n * @param fn - The factory function to wrap.\n * @returns An `IConfigInitFactory` instance that delegates to the function.\n * @public\n */\nexport function createQualifierTypeFactory<T extends QualifierType = QualifierType>(\n  fn: QualifierTypeFactoryFunction<T>\n): IConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, T> {\n  return {\n    create: fn\n  };\n}\n\n/**\n * Creates a {@link Config.IConfigInitFactory | IConfigInitFactory} from a resource type factory function.\n * @param fn - The factory function to wrap.\n * @returns An `IConfigInitFactory` instance that delegates to the function.\n * @public\n */\nexport function createResourceTypeFactory(\n  fn: ResourceTypeFactoryFunction\n): IConfigInitFactory<ResourceTypes.Config.IResourceTypeConfig, ResourceType> {\n  return {\n    create: fn\n  };\n}\n\n/**\n * A factory that chains multiple factories together.\n * @public\n */\nexport class ChainedConfigInitFactory<TConfig, T> implements IConfigInitFactory<TConfig, T> {\n  public readonly factories: IConfigInitFactory<TConfig, T>[];\n\n  /**\n   * Constructor for a chained config init factory.\n   * @param factories - The factories to chain.\n   */\n  public constructor(factories: IConfigInitFactory<TConfig, T>[]) {\n    this.factories = factories;\n  }\n\n  /**\n   * Creates a new instance of a configuration object.\n   * @param config - The configuration object to create.\n   * @returns A result containing the new instance of the configuration object.\n   */\n  public create(config: TConfig): Result<T> {\n    for (const factory of this.factories) {\n      const result = factory.create(config);\n      if (result.isSuccess()) {\n        return result;\n      }\n    }\n    return fail('No factory was able to create the configuration object');\n  }\n}\n\n/**\n * A factory that creates a {@link QualifierTypes.SystemQualifierType | SystemQualifierType} from\n * {@link QualifierTypes.Config.IAnyQualifierTypeConfig | any qualifier type configuration}.\n * @returns `Success` with the new {@link QualifierTypes.SystemQualifierType | SystemQualifierType}\n * if successful, `Failure` with an error message otherwise.\n * @public\n */\nexport class BuiltInQualifierTypeFactory\n  implements IConfigInitFactory<QualifierTypes.Config.ISystemQualifierTypeConfig, SystemQualifierType>\n{\n  /** {@inheritDoc Config.IConfigInitFactory.create} */\n  public create(config: QualifierTypes.Config.IAnyQualifierTypeConfig): Result<SystemQualifierType> {\n    if (QualifierTypes.Config.isSystemQualifierTypeConfig(config)) {\n      return QualifierTypes.createQualifierTypeFromSystemConfig(config);\n    }\n    /* c8 ignore next 2 - functional code tested but coverage intermittently missed */\n    return fail(`${config.name}: unknown built-in qualifier type (${config.systemType})`);\n  }\n}\n\n/**\n * A factory that creates {@link QualifierTypes.QualifierType | QualifierType} instances from configuration,\n * supporting both built-in system types and custom external types.\n *\n * This factory allows external consumers to extend the qualifier type system with their own custom types\n * while maintaining support for all built-in types (Language, Territory, Literal).\n *\n * @typeParam T - The custom qualifier type(s) to support. Defaults to {@link QualifierTypes.SystemQualifierType | SystemQualifierType}.\n *\n * @example Creating a factory with custom qualifier types\n * ```typescript\n * // Define a custom qualifier type\n * class CustomQualifierType extends QualifierType {\n *   // ... implementation\n * }\n *\n * // Define a discriminated union of all types\n * type AppQualifierType = SystemQualifierType | CustomQualifierType;\n *\n * // Create a factory that handles custom types\n * const customFactory: IConfigInitFactory<IAnyQualifierTypeConfig, CustomQualifierType> = {\n *   create(config) {\n *     // ... handle custom type creation\n *   }\n * };\n *\n * // Create the combined factory\n * const qualifierTypeFactory = new QualifierTypeFactory<AppQualifierType>([customFactory]);\n *\n * // The factory returns T | SystemQualifierType, supporting all types\n * const result = qualifierTypeFactory.create(config); // Result<AppQualifierType | SystemQualifierType>\n * ```\n *\n * @remarks\n * - The factory chains custom factories with the built-in factory\n * - Custom factories are tried first, falling back to built-in types\n * - The return type is a union of custom types (T) and system types\n *\n * @public\n */\nexport class QualifierTypeFactory<\n  T extends QualifierType = SystemQualifierType\n> extends ChainedConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, T | SystemQualifierType> {\n  /**\n   * Constructor for a {@link Config.QualifierTypeFactory | qualifier type factory}.\n   * @param factories - Array of factories for custom qualifier types. Can be:\n   *                    - {@link Config.IConfigInitFactory | IConfigInitFactory} instances\n   *                    - {@link Config.QualifierTypeFactoryFunction | Factory functions}\n   *                    - A mix of both\n   *                    These are tried in order before falling back to built-in types.\n   * @remarks The {@link Config.BuiltInQualifierTypeFactory | built-in factory} is always appended to handle\n   *          system qualifier types (Language, Territory, Literal).\n   */\n  public constructor(\n    factories: Array<\n      IConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, T> | QualifierTypeFactoryFunction<T>\n    >\n  ) {\n    const normalizedFactories = factories.map((f) =>\n      typeof f === 'function' ? createQualifierTypeFactory(f) : f\n    );\n    super([...normalizedFactories, new BuiltInQualifierTypeFactory()]);\n  }\n}\n\n/**\n * A factory that validates and creates {@link QualifierTypes.QualifierType | QualifierType} instances\n * from weakly-typed configuration objects. This factory accepts configurations with unvalidated\n * string properties and validates them before delegating to the underlying factory chain.\n *\n * This pattern is useful at package boundaries where type identity issues may occur with\n * branded types across different package instances.\n *\n * @example\n * ```typescript\n * // Accept weakly-typed config from external source\n * const validatingFactory = new ValidatingQualifierTypeFactory([customFactory]);\n *\n * // Config can have plain string types instead of branded types\n * const config = {\n *   name: 'my-qualifier',  // plain string, not QualifierTypeName\n *   systemType: 'custom',   // plain string\n *   configuration: { ... }\n * };\n *\n * const result = validatingFactory.create(config); // Validates and converts internally\n * ```\n *\n * @public\n */\nexport class ValidatingQualifierTypeFactory<T extends QualifierType = SystemQualifierType>\n  implements IConfigInitFactory<unknown, T | SystemQualifierType>\n{\n  private readonly _innerFactory: QualifierTypeFactory<T>;\n\n  /**\n   * Constructor for a validating qualifier type factory.\n   * @param factories - Array of factories for custom qualifier types. Can be:\n   *                    - {@link Config.IConfigInitFactory | IConfigInitFactory} instances\n   *                    - {@link Config.QualifierTypeFactoryFunction | Factory functions}\n   *                    - A mix of both\n   */\n  public constructor(\n    factories: Array<\n      IConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, T> | QualifierTypeFactoryFunction<T>\n    >\n  ) {\n    this._innerFactory = new QualifierTypeFactory(factories);\n  }\n\n  /**\n   * Creates a qualifier type from a weakly-typed configuration object.\n   * @param config - The configuration object to validate and use for creation.\n   * @returns A result containing the new qualifier type if successful.\n   */\n  public create(config: unknown): Result<T | SystemQualifierType> {\n    return QualifierTypes.Config.Convert.anyQualifierTypeConfig\n      .convert(config)\n      .onSuccess((validatedConfig) => {\n        return this._innerFactory.create(validatedConfig);\n      });\n  }\n}\n\n/**\n * A factory that creates a {@link ResourceTypes.ResourceType | ResourceType} from a {@link ResourceTypes.Config.IResourceTypeConfig | resource type configuration}.\n * @public\n */\nexport class BuiltInResourceTypeFactory\n  implements IConfigInitFactory<ResourceTypes.Config.IResourceTypeConfig, ResourceType>\n{\n  /** {@inheritDoc Config.IConfigInitFactory.create} */\n  public create(config: ResourceTypes.Config.IResourceTypeConfig): Result<ResourceType> {\n    return ResourceTypes.createResourceTypeFromConfig(config);\n  }\n}\n\n/**\n * A factory that creates a {@link ResourceTypes.ResourceType | ResourceType} from a {@link ResourceTypes.Config.IResourceTypeConfig | resource type configuration}\n * by chaining a supplied factory with a {@link Config.BuiltInResourceTypeFactory | built-in factory} that handles built-in resource types.\n * @public\n */\nexport class ResourceTypeFactory extends ChainedConfigInitFactory<\n  ResourceTypes.Config.IResourceTypeConfig,\n  ResourceType\n> {\n  /**\n   * Constructor for a resource type factory.\n   * @param factories - Array of factories for resource types. Can be:\n   *                    - {@link Config.IConfigInitFactory | IConfigInitFactory} instances\n   *                    - {@link Config.ResourceTypeFactoryFunction | Factory functions}\n   *                    - A mix of both\n   * @remarks The {@link Config.BuiltInResourceTypeFactory | built-in factory} is always added to the end of the chain.\n   */\n  public constructor(\n    factories: Array<\n      IConfigInitFactory<ResourceTypes.Config.IResourceTypeConfig, ResourceType> | ResourceTypeFactoryFunction\n    >\n  ) {\n    factories = factories ?? [];\n    const normalizedFactories = factories.map((f) =>\n      typeof f === 'function' ? createResourceTypeFactory(f) : f\n    );\n    super([...normalizedFactories, new BuiltInResourceTypeFactory()]);\n  }\n}\n\n/**\n * A factory that validates and creates {@link ResourceTypes.ResourceType | ResourceType} instances\n * from weakly-typed configuration objects. This factory accepts configurations with unvalidated\n * string properties and validates them before delegating to the underlying factory chain.\n *\n * This pattern is useful at package boundaries where type identity issues may occur with\n * branded types across different package instances.\n *\n * @public\n */\nexport class ValidatingResourceTypeFactory implements IConfigInitFactory<unknown, ResourceType> {\n  private readonly _innerFactory: ResourceTypeFactory;\n\n  /**\n   * Constructor for a validating resource type factory.\n   * @param factories - Array of factories for resource types. Can be:\n   *                    - {@link Config.IConfigInitFactory | IConfigInitFactory} instances\n   *                    - {@link Config.ResourceTypeFactoryFunction | Factory functions}\n   *                    - A mix of both\n   */\n  public constructor(\n    factories: Array<\n      IConfigInitFactory<ResourceTypes.Config.IResourceTypeConfig, ResourceType> | ResourceTypeFactoryFunction\n    >\n  ) {\n    this._innerFactory = new ResourceTypeFactory(factories);\n  }\n\n  /**\n   * Creates a resource type from a weakly-typed configuration object.\n   * @param config - The configuration object to validate and use for creation.\n   * @returns A result containing the new resource type if successful.\n   */\n  public create(config: unknown): Result<ResourceType> {\n    return ResourceTypes.Config.Convert.resourceTypeConfig.convert(config).onSuccess((validatedConfig) => {\n      return this._innerFactory.create(validatedConfig);\n    });\n  }\n}\n"]}

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

@@ -1,23 +0,0 @@
-import { Result } from '@fgv/ts-utils';
-import { ISystemConfiguration } from './json';
-/**
- * A `Converter` for {@link Config.Model.ISystemConfiguration | ISystemConfiguration} objects.
- * @returns A `Converter` for {@link Config.Model.ISystemConfiguration | ISystemConfiguration} objects.
- * @public
- */
-export declare const systemConfiguration: import("@fgv/ts-utils").ObjectConverter<ISystemConfiguration, unknown>;
-/**
- * A `Converter` for {@link Config.PredefinedSystemConfiguration | PredefinedSystemConfiguration} values.
- * @returns A `Converter` for {@link Config.PredefinedSystemConfiguration | PredefinedSystemConfiguration} values.
- * @public
- */
-export declare const predefinedSystemConfiguration: import("@fgv/ts-utils").Converter<import("./common").PredefinedSystemConfiguration, readonly import("./common").PredefinedSystemConfiguration[]>;
-/**
- * Validate a {@link Config.Model.ISystemConfiguration | ISystemConfiguration} object.
- * @param config - The system configuration to validate
- * @returns `Success` with the validated system configuration if successful,
- * or `Failure` with an error message if validation fails.
- * @public
- */
-export declare function validateSystemConfiguration(config: unknown): Result<ISystemConfiguration>;
-//# sourceMappingURL=convert.d.ts.map

package/lib/packlets/config/convert.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"convert.d.ts","sourceRoot":"","sources":["../../../src/packlets/config/convert.ts"],"names":[],"mappings":"AAwBA,OAAO,EAAc,MAAM,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,EAAE,oBAAoB,EAAE,MAAM,QAAQ,CAAC;AAM9C;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,wEAM9B,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,6BAA6B,kJAAgE,CAAC;AAE3G;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAAC,oBAAoB,CAAC,CAEzF"}