@fgv/ts-res 5.0.0-2 → 5.0.0-21

package/lib/packlets/conditions/conditionSet.js

@@ -20,11 +20,45 @@
  * 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.ConditionSet = void 0;
 const ts_utils_1 = require("@fgv/ts-utils");
 const condition_1 = require("./condition");
 const common_1 = require("../common");
+const ConditionsConvert = __importStar(require("./convert"));
 /**
  * Represents a set of {@link Conditions.Condition | conditions} that must all be met in some runtime
  * context for a resource instance to be valid.
@@ -129,6 +163,43 @@ class ConditionSet {
     static getKeyForDecl(decl) {
         return common_1.Validate.toConditionSetKey(decl.conditions.map((c) => c.toKey()).join('+'));
     }
+    /**
+     * Gets a condition set key from a loose condition set declaration.
+     * @param conditionSet - The loose condition set declaration to convert.
+     * @param conditionCollector - The condition collector used for validation.
+     * @returns `Success` with the condition set key if successful, `Failure` otherwise.
+     * @public
+     */
+    static getKeyFromLooseDecl(conditionSet, conditionCollector) {
+        if (!conditionSet) {
+            return (0, ts_utils_1.succeed)(ConditionSet.UnconditionalKey);
+        }
+        // Convert ConditionSetDecl to IConditionSetDecl format
+        let conditionSetDecl;
+        if (Array.isArray(conditionSet)) {
+            // ConditionSetDeclAsArray: array of ILooseConditionDecl
+            conditionSetDecl = { conditions: conditionSet };
+        }
+        else {
+            // ConditionSetDeclAsRecord: Record<string, string | IChildConditionDecl>
+            const conditions = Object.entries(conditionSet).map(([qualifierName, value]) => {
+                if (typeof value === 'string') {
+                    return { qualifierName, value };
+                }
+                else {
+                    return Object.assign({ qualifierName }, value);
+                }
+            });
+            conditionSetDecl = { conditions };
+        }
+        // Validate and convert to IValidatedConditionSetDecl
+        return ConditionsConvert.validatedConditionSetDecl
+            .convert(conditionSetDecl, { conditions: conditionCollector })
+            .onSuccess((validatedDecl) => {
+            // Use proper ConditionSet.getKeyForDecl method to generate the key
+            return ConditionSet.getKeyForDecl(validatedDecl);
+        });
+    }
     /**
      * Gets a {@link ConditionSetToken | condition set token} for this condition set,
      * if possible.
@@ -174,7 +245,8 @@ class ConditionSet {
     toConditionSetRecordDecl(options) {
         const qualifiersToReduce = options === null || options === void 0 ? void 0 : options.qualifiersToReduce;
         const conditions = qualifiersToReduce
-            ? this.conditions.filter((c) => !qualifiersToReduce.has(c.qualifier.name))
+            ? /* c8 ignore next 1 - coverage intermittently misses the next line */
+                this.conditions.filter((c) => !qualifiersToReduce.has(c.qualifier.name))
             : this.conditions;
         return Object.fromEntries(conditions.map((c) => {
             return [c.qualifier.name, c.toValueOrChildConditionDecl(options)];
@@ -186,6 +258,7 @@ class ConditionSet {
      * @returns The {@link ResourceJson.Json.ConditionSetDeclAsArray | condition set declaration as an array} for this condition set.
      */
     toConditionSetArrayDecl(options) {
+        /* c8 ignore next 1 - defense in depth */
         const qualifiersToReduce = options === null || options === void 0 ? void 0 : options.qualifiersToReduce;
         const conditions = qualifiersToReduce
             ? this.conditions.filter((c) => !qualifiersToReduce.has(c.qualifier.name))

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

@@ -0,0 +1,78 @@
+import { Result } from '@fgv/ts-utils';
+import { QualifierType } from '../qualifier-types';
+import * as QualifierTypes from '../qualifier-types';
+import * as ResourceTypes from '../resource-types';
+import { ResourceType } from '../resource-types';
+/**
+ * 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>;
+}
+/**
+ * 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.QualifierType | QualifierType} from a {@link QualifierTypes.Config.ISystemQualifierTypeConfig | system qualifier type configuration}.
+ * @public
+ */
+export declare class BuiltInQualifierTypeFactory implements IConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, QualifierType> {
+    /** {@inheritDoc Config.IConfigInitFactory.create} */
+    create(config: QualifierTypes.Config.IAnyQualifierTypeConfig): Result<QualifierType>;
+}
+/**
+ * A factory that creates a {@link QualifierTypes.QualifierType | QualifierType} from a {@link QualifierTypes.Config.IAnyQualifierTypeConfig | system qualifier type configuration}
+ * by chaining a supplied factory with a {@link Config.BuiltInQualifierTypeFactory | built-in factory} that handles built-in qualifier types.
+ * @public
+ */
+export declare class QualifierTypeFactory extends ChainedConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, QualifierType> {
+    /**
+     * Constructor for a {@link Config.QualifierTypeFactory | qualifier type factory}.
+     * @param factories - The {@link Config.IConfigInitFactory | factories} to chain.
+     * @remarks The {@link Config.BuiltInQualifierTypeFactory | built-in factory} is always added to the end of the chain.
+     */
+    constructor(factories: IConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, QualifierType>[]);
+}
+/**
+ * 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 - The {@link Config.IConfigInitFactory | factories}  to chain.
+     * @remarks The {@link Config.BuiltInResourceTypeFactory | built-in factory} is always added to the end of the chain.
+     */
+    constructor(factories: IConfigInitFactory<ResourceTypes.Config.IResourceTypeConfig, ResourceType>[]);
+}
+//# sourceMappingURL=configInitFactory.d.ts.map

package/lib/packlets/config/configInitFactory.js

@@ -0,0 +1,147 @@
+"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.ResourceTypeFactory = exports.BuiltInResourceTypeFactory = exports.QualifierTypeFactory = exports.BuiltInQualifierTypeFactory = exports.ChainedConfigInitFactory = void 0;
+const ts_utils_1 = require("@fgv/ts-utils");
+const QualifierTypes = __importStar(require("../qualifier-types"));
+const ResourceTypes = __importStar(require("../resource-types"));
+/**
+ * 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.QualifierType | QualifierType} from a {@link QualifierTypes.Config.ISystemQualifierTypeConfig | system qualifier type configuration}.
+ * @public
+ */
+class BuiltInQualifierTypeFactory {
+    /** {@inheritDoc Config.IConfigInitFactory.create} */
+    create(config) {
+        if (QualifierTypes.Config.isSystemQualifierTypeConfig(config)) {
+            return QualifierTypes.createQualifierTypeFromSystemConfig(config);
+        }
+        return (0, ts_utils_1.fail)(`${config.name}: unknown built-in qualifier type (${config.systemType})`);
+    }
+}
+exports.BuiltInQualifierTypeFactory = BuiltInQualifierTypeFactory;
+/**
+ * A factory that creates a {@link QualifierTypes.QualifierType | QualifierType} from a {@link QualifierTypes.Config.IAnyQualifierTypeConfig | system qualifier type configuration}
+ * by chaining a supplied factory with a {@link Config.BuiltInQualifierTypeFactory | built-in factory} that handles built-in qualifier types.
+ * @public
+ */
+class QualifierTypeFactory extends ChainedConfigInitFactory {
+    /**
+     * Constructor for a {@link Config.QualifierTypeFactory | qualifier type factory}.
+     * @param factories - The {@link Config.IConfigInitFactory | factories} to chain.
+     * @remarks The {@link Config.BuiltInQualifierTypeFactory | built-in factory} is always added to the end of the chain.
+     */
+    constructor(factories) {
+        super([...factories, new BuiltInQualifierTypeFactory()]);
+    }
+}
+exports.QualifierTypeFactory = QualifierTypeFactory;
+/**
+ * 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 - The {@link Config.IConfigInitFactory | factories}  to chain.
+     * @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()]);
+    }
+}
+exports.ResourceTypeFactory = ResourceTypeFactory;
+//# sourceMappingURL=configInitFactory.js.map

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

@@ -1,3 +1,4 @@
+import { Result } from '@fgv/ts-utils';
 import { ISystemConfiguration } from './json';
 /**
  * A `Converter` for {@link Config.Model.ISystemConfiguration | ISystemConfiguration} objects.
@@ -11,4 +12,12 @@ export declare const systemConfiguration: import("@fgv/ts-utils").ObjectConverte
  * @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.js

@@ -55,6 +55,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.predefinedSystemConfiguration = exports.systemConfiguration = void 0;
+exports.validateSystemConfiguration = validateSystemConfiguration;
 /* eslint-disable @rushstack/typedef-var */
 const ts_utils_1 = require("@fgv/ts-utils");
 const QualifierTypes = __importStar(require("../qualifier-types"));
@@ -79,4 +80,14 @@ exports.systemConfiguration = ts_utils_1.Converters.strictObject({
  * @public
  */
 exports.predefinedSystemConfiguration = ts_utils_1.Converters.enumeratedValue(common_1.allPredefinedSystemConfigurations);
+/**
+ * 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
+ */
+function validateSystemConfiguration(config) {
+    return exports.systemConfiguration.convert(config);
+}
 //# sourceMappingURL=convert.js.map

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

@@ -1,5 +1,6 @@
 import * as Model from './json';
 import * as Convert from './convert';
+export * from './configInitFactory';
 export * from './systemConfiguration';
 export * from './common';
 export { Model, Convert };

package/lib/packlets/config/index.js

@@ -62,6 +62,7 @@ const Model = __importStar(require("./json"));
 exports.Model = Model;
 const Convert = __importStar(require("./convert"));
 exports.Convert = Convert;
+__exportStar(require("./configInitFactory"), exports);
 __exportStar(require("./systemConfiguration"), exports);
 __exportStar(require("./common"), exports);
 //# sourceMappingURL=index.js.map

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

@@ -1,8 +1,11 @@
 import { Result } from '@fgv/ts-utils';
-import { ReadOnlyQualifierTypeCollector } from '../qualifier-types';
+import * as QualifierTypes from '../qualifier-types';
+import * as ResourceTypes from '../resource-types';
+import { QualifierType, ReadOnlyQualifierTypeCollector } from '../qualifier-types';
 import { IReadOnlyQualifierCollector } from '../qualifiers';
-import { ReadOnlyResourceTypeCollector } from '../resource-types';
+import { ReadOnlyResourceTypeCollector, ResourceType } from '../resource-types';
 import { ISystemConfiguration } from './json';
+import { IConfigInitFactory } from './configInitFactory';
 /**
  * Parameters used to initialize a {@link Config.SystemConfiguration | SystemConfiguration}.
  * @public
@@ -14,6 +17,8 @@ export interface ISystemConfigurationInitParams {
      * Use `null` as the value to remove an existing default value.
      */
     qualifierDefaultValues?: Record<string, string | null>;
+    qualifierTypeFactory?: IConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, QualifierType>;
+    resourceTypeFactory?: IConfigInitFactory<ResourceTypes.Config.IResourceTypeConfig, ResourceType>;
 }
 /**
  * Creates a copy of the provided {@link Config.Model.ISystemConfiguration | system configuration}
@@ -58,7 +63,7 @@ export declare class SystemConfiguration {
      * @param config - The {@link Config.Model.ISystemConfiguration | system configuration} to use.
      * @public
      */
-    protected constructor(config: ISystemConfiguration);
+    protected constructor(config: ISystemConfiguration, initParams?: ISystemConfigurationInitParams);
     /**
      * Creates a new {@link Config.SystemConfiguration | SystemConfiguration} from the supplied
      * {@link Config.Model.ISystemConfiguration | system configuration}.
@@ -69,6 +74,14 @@ export declare class SystemConfiguration {
      * @public
      */
     static create(config: ISystemConfiguration, initParams?: ISystemConfigurationInitParams): Result<SystemConfiguration>;
+    /**
+     * Loads a {@link Config.SystemConfiguration | SystemConfiguration} from a file.
+     * @param path - The path to the file to load.
+     * @returns `Success` with the {@link Config.SystemConfiguration | SystemConfiguration}
+     * if successful, `Failure` with an error message otherwise.
+     * @public
+     */
+    static loadFromFile(path: string, initParams?: ISystemConfigurationInitParams): Result<SystemConfiguration>;
     /**
      * Returns the {@link Config.Model.ISystemConfiguration | system configuration} that this
      * {@link Config.SystemConfiguration | SystemConfiguration} was created from.

package/lib/packlets/config/systemConfiguration.js

@@ -20,50 +20,16 @@
  * 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.SystemConfiguration = void 0;
 exports.updateSystemConfigurationQualifierDefaultValues = updateSystemConfigurationQualifierDefaultValues;
 const ts_utils_1 = require("@fgv/ts-utils");
-const QualifierTypes = __importStar(require("../qualifier-types"));
-const ResourceTypes = __importStar(require("../resource-types"));
 const qualifier_types_1 = require("../qualifier-types");
 const qualifiers_1 = require("../qualifiers");
 const resource_types_1 = require("../resource-types");
 const convert_1 = require("./convert");
 const ts_json_base_1 = require("@fgv/ts-json-base");
+const configInitFactory_1 = require("./configInitFactory");
 /**
  * Creates a copy of the provided {@link Config.Model.ISystemConfiguration | system configuration}
  * with updated qualifier default values.
@@ -129,17 +95,20 @@ class SystemConfiguration {
      * @param config - The {@link Config.Model.ISystemConfiguration | system configuration} to use.
      * @public
      */
-    constructor(config) {
+    constructor(config, initParams) {
+        var _a, _b;
         this._config = config;
+        const qualifierTypeFactory = (_a = initParams === null || initParams === void 0 ? void 0 : initParams.qualifierTypeFactory) !== null && _a !== void 0 ? _a : new configInitFactory_1.BuiltInQualifierTypeFactory();
+        const resourceTypeFactory = (_b = initParams === null || initParams === void 0 ? void 0 : initParams.resourceTypeFactory) !== null && _b !== void 0 ? _b : new configInitFactory_1.BuiltInResourceTypeFactory();
         this.qualifierTypes = qualifier_types_1.QualifierTypeCollector.create({
-            qualifierTypes: (0, ts_utils_1.mapResults)(config.qualifierTypes.map(QualifierTypes.createQualifierTypeFromSystemConfig)).orThrow()
+            qualifierTypes: (0, ts_utils_1.mapResults)(config.qualifierTypes.map((tc) => qualifierTypeFactory.create(tc))).orThrow()
         }).orThrow();
         this.qualifiers = qualifiers_1.QualifierCollector.create({
             qualifierTypes: this.qualifierTypes,
             qualifiers: config.qualifiers
         }).orThrow();
         this.resourceTypes = resource_types_1.ResourceTypeCollector.create({
-            resourceTypes: (0, ts_utils_1.mapResults)(config.resourceTypes.map(ResourceTypes.createResourceTypeFromConfig)).orThrow()
+            resourceTypes: (0, ts_utils_1.mapResults)(config.resourceTypes.map((rt) => resourceTypeFactory.create(rt))).orThrow()
         }).orThrow();
     }
     /**
@@ -153,9 +122,19 @@ class SystemConfiguration {
      */
     static create(config, initParams) {
         if (initParams === null || initParams === void 0 ? void 0 : initParams.qualifierDefaultValues) {
-            return updateSystemConfigurationQualifierDefaultValues(config, initParams.qualifierDefaultValues).onSuccess((updatedConfig) => (0, ts_utils_1.captureResult)(() => new SystemConfiguration(updatedConfig)));
+            return updateSystemConfigurationQualifierDefaultValues(config, initParams.qualifierDefaultValues).onSuccess((updatedConfig) => (0, ts_utils_1.captureResult)(() => new SystemConfiguration(updatedConfig, (0, ts_utils_1.omit)(initParams, ['qualifierDefaultValues']))));
         }
-        return (0, ts_utils_1.captureResult)(() => new SystemConfiguration(config));
+        return (0, ts_utils_1.captureResult)(() => new SystemConfiguration(config, initParams));
+    }
+    /**
+     * Loads a {@link Config.SystemConfiguration | SystemConfiguration} from a file.
+     * @param path - The path to the file to load.
+     * @returns `Success` with the {@link Config.SystemConfiguration | SystemConfiguration}
+     * if successful, `Failure` with an error message otherwise.
+     * @public
+     */
+    static loadFromFile(path, initParams) {
+        return ts_json_base_1.JsonFile.convertJsonFileSync(path, convert_1.systemConfiguration).onSuccess((config) => SystemConfiguration.create(config, initParams));
     }
     /**
      * Returns the {@link Config.Model.ISystemConfiguration | system configuration} that this

package/lib/packlets/import/fsItem.js

@@ -110,19 +110,14 @@ class FsItem {
      * that should be silently ignored.
      */
     static createForPath(importPath, qualifiers, tree) {
-        if (tree === undefined) {
-            /* c8 ignore next 7 - functional code path tested but coverage intermittently missed */
-            const treeResult = ts_utils_1.FileTree.forFilesystem();
-            /* c8 ignore next 3 - defense in depth should never happen */
-            if (treeResult.isFailure()) {
-                return (0, ts_utils_1.failWithDetail)(treeResult.message, 'failed');
-            }
-            tree = treeResult.value;
-        }
-        return tree
-            .getItem(importPath)
-            .withDetail('failed')
-            .onSuccess((item) => FsItem.createForItem(item, qualifiers));
+        return (0, ts_utils_1.useOrInitialize)(tree, () => ts_utils_1.FileTree.forFilesystem())
+            .withDetail('failed', 'succeeded')
+            .onSuccess((tree) => {
+            return tree
+                .getItem(importPath)
+                .withDetail('failed')
+                .onSuccess((item) => FsItem.createForItem(item, qualifiers));
+        });
     }
     /**
      * Tries to parse a base name into a base name and a set of conditions.

package/lib/packlets/import/importers/jsonImporter.js

@@ -85,6 +85,7 @@ class JsonImporter {
      */
     import(item, manager) {
         var _a, _b;
+        /* c8 ignore next 1 - coverage intermittently misses the next line */
         if (!(0, importable_1.isImportable)(item) || item.type !== 'json') {
             /* c8 ignore next 3 - functional code path tested but coverage intermittently missed */
             const name = (_b = (_a = item.context) === null || _a === void 0 ? void 0 : _a.baseId) !== null && _b !== void 0 ? _b : 'unknown';

package/lib/packlets/qualifier-types/config/json.d.ts

@@ -66,4 +66,17 @@ export interface ISystemLiteralQualifierTypeConfig extends IQualifierTypeConfig<
  * @public
  */
 export type ISystemQualifierTypeConfig = ISystemLanguageQualifierTypeConfig | ISystemTerritoryQualifierTypeConfig | ISystemLiteralQualifierTypeConfig;
+/**
+ * A union of all qualifier type configurations.
+ * @public
+ */
+export type IAnyQualifierTypeConfig = IQualifierTypeConfig | ISystemQualifierTypeConfig;
+/**
+ * Checks if a {@link QualifierTypes.Config.IAnyQualifierTypeConfig | qualifier type configuration} is a
+ * {@link QualifierTypes.Config.ISystemQualifierTypeConfig | system qualifier type configuration}.
+ * @param config - The {@link QualifierTypes.Config.IAnyQualifierTypeConfig | qualifier type configuration} to check.
+ * @returns `true` if the configuration is a system qualifier type configuration, `false` otherwise.
+ * @public
+ */
+export declare function isSystemQualifierTypeConfig(config: IAnyQualifierTypeConfig): config is ISystemQualifierTypeConfig;
 //# sourceMappingURL=json.d.ts.map

package/lib/packlets/qualifier-types/config/json.js

@@ -21,4 +21,15 @@
  * SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSystemQualifierTypeConfig = isSystemQualifierTypeConfig;
+/**
+ * Checks if a {@link QualifierTypes.Config.IAnyQualifierTypeConfig | qualifier type configuration} is a
+ * {@link QualifierTypes.Config.ISystemQualifierTypeConfig | system qualifier type configuration}.
+ * @param config - The {@link QualifierTypes.Config.IAnyQualifierTypeConfig | qualifier type configuration} to check.
+ * @returns `true` if the configuration is a system qualifier type configuration, `false` otherwise.
+ * @public
+ */
+function isSystemQualifierTypeConfig(config) {
+    return (config.systemType === 'language' || config.systemType === 'territory' || config.systemType === 'literal');
+}
 //# sourceMappingURL=json.js.map

package/lib/packlets/qualifier-types/literalValueHierarchy.js

@@ -79,7 +79,7 @@ class LiteralValueHierarchy {
      */
     getAncestors(value) {
         const current = this.values.get(value);
-        /* c8 ignore next 2 - functional error case tested but coverage intermittently missed */
+        /* c8 ignore next 3 - functional error case tested but coverage intermittently missed */
         if (!current) {
             return (0, ts_utils_1.fail)(`${value}: not found in hierarchy`);
         }

package/lib/packlets/qualifiers/qualifierCollector.js

@@ -144,12 +144,11 @@ class QualifierCollector extends ts_utils_1.ValidatingConvertingCollector {
         return convert_1.validatedQualifierDecl
             .convert(decl, convertContext)
             .onSuccess((validated) => {
+            /* c8 ignore next 9 - coverage intermittently misses this block */
             if (this.hasNameOrToken(validated.token)) {
-                /* c8 ignore next 3 - functional error case tested but coverage intermittently missed */
                 return (0, ts_utils_1.fail)(`Qualifier token '${validated.token}' is not unique or collides with name`);
             }
             else if (this.hasNameOrToken(validated.name)) {
-                /* c8 ignore next 4 - functional error case tested but coverage intermittently missed */
                 return (0, ts_utils_1.fail)(`Qualifier name '${validated.name}' is not unique or collides with token`);
             }
             return (0, ts_utils_1.succeed)(validated);