@fgv/ts-res 5.0.0-9 → 5.0.1-1

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

@@ -20,10 +20,46 @@
  * 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.systemQualifierTypeConfig = exports.systemLiteralQualifierTypeConfig = exports.systemTerritoryQualifierTypeConfig = exports.systemLanguageQualifierTypeConfig = exports.literalQualifierTypeConfig = exports.territoryQualifierTypeConfig = exports.languageQualifierTypeConfig = void 0;
+exports.anyQualifierTypeConfig = exports.jsonQualifierTypeConfig = exports.systemQualifierTypeConfig = exports.systemLiteralQualifierTypeConfig = exports.systemTerritoryQualifierTypeConfig = exports.systemLanguageQualifierTypeConfig = exports.literalQualifierTypeConfig = exports.territoryQualifierTypeConfig = exports.languageQualifierTypeConfig = void 0;
+exports.qualifierTypeConfig = qualifierTypeConfig;
 /* eslint-disable @rushstack/typedef-var */
 const ts_utils_1 = require("@fgv/ts-utils");
+const Common = __importStar(require("../../common"));
+const ts_json_base_1 = require("@fgv/ts-json-base");
 /**
  * A `Converter` for {@link QualifierTypes.Config.ILanguageQualifierTypeConfig | LanguageQualifierTypeConfig} objects.
  * @returns A `Converter` for {@link QualifierTypes.Config.ILanguageQualifierTypeConfig | LanguageQualifierTypeConfig} objects.
@@ -40,7 +76,8 @@ exports.languageQualifierTypeConfig = ts_utils_1.Converters.strictObject({
 exports.territoryQualifierTypeConfig = ts_utils_1.Converters.strictObject({
     allowContextList: ts_utils_1.Converters.boolean,
     acceptLowercase: ts_utils_1.Converters.boolean.optional(),
-    allowedTerritories: ts_utils_1.Converters.arrayOf(ts_utils_1.Converters.string).optional()
+    allowedTerritories: ts_utils_1.Converters.arrayOf(ts_utils_1.Converters.string).optional(),
+    hierarchy: ts_utils_1.Converters.recordOf(ts_utils_1.Converters.string).optional()
 });
 /**
  * A `Converter` for {@link QualifierTypes.Config.ILiteralQualifierTypeConfig | LiteralQualifierTypeConfig} objects.
@@ -93,4 +130,32 @@ exports.systemQualifierTypeConfig = ts_utils_1.Converters.discriminatedObject('s
     territory: exports.systemTerritoryQualifierTypeConfig,
     literal: exports.systemLiteralQualifierTypeConfig
 });
+/**
+ * A `Converter` for {@link QualifierTypes.Config.IQualifierTypeConfig | QualifierTypeConfig} objects.
+ * @returns A `Converter` for {@link QualifierTypes.Config.IQualifierTypeConfig | QualifierTypeConfig} objects.
+ * @param config - A `Converter` for the configuration object.
+ * @public
+ */
+function qualifierTypeConfig(config) {
+    return ts_utils_1.Converters.strictObject({
+        name: Common.Convert.qualifierTypeName,
+        systemType: Common.Convert.qualifierTypeName,
+        configuration: config.optional()
+    });
+}
+/**
+ * A `Converter` for {@link QualifierTypes.Config.IQualifierTypeConfig | QualifierTypeConfig} objects.
+ * @returns A `Converter` for {@link QualifierTypes.Config.IQualifierTypeConfig | QualifierTypeConfig} objects.
+ * @public
+ */
+exports.jsonQualifierTypeConfig = qualifierTypeConfig(ts_json_base_1.Converters.jsonObject);
+/**
+ * A `Converter` for {@link QualifierTypes.Config.IAnyQualifierTypeConfig | AnyQualifierTypeConfig} objects.
+ * @returns A `Converter` for {@link QualifierTypes.Config.IAnyQualifierTypeConfig | AnyQualifierTypeConfig} objects.
+ * @public
+ */
+exports.anyQualifierTypeConfig = ts_utils_1.Converters.oneOf([
+    exports.jsonQualifierTypeConfig,
+    exports.systemQualifierTypeConfig
+]);
 //# sourceMappingURL=convert.js.map

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

@@ -1,5 +1,4 @@
 import { JsonObject } from '@fgv/ts-json-base';
-import { LiteralValueHierarchyDecl } from '../literalValueHierarchy';
 /**
  * Templated configuration for {@link QualifierTypes.QualifierType | qualifier type} configuration.
  * @public
@@ -16,6 +15,16 @@ export interface IQualifierTypeConfig<T = JsonObject> {
 export interface ILanguageQualifierTypeConfig {
     allowContextList?: boolean;
 }
+/**
+ * Declares a hierarchy of literal values. The keys are the names of the values, and the
+ * values are the names of their parents.
+ * @remarks
+ * The hierarchy is defined as a tree, where each value can have multiple children but
+ * only one parent. The root of the tree has no parent. The hierarchy is used to
+ * determine the relationship between values when matching conditions and contexts.
+ * @public
+ */
+export type LiteralValueHierarchyDecl<T extends string> = Record<T, T>;
 /**
  * Configuration for {@link QualifierTypes.TerritoryQualifierType | territory qualifier type} configuration.
  * @public
@@ -25,7 +34,7 @@ export interface ITerritoryQualifierTypeConfig {
     acceptLowercase?: boolean;
     allowedTerritories?: string[];
     /**
-     * Optional {@link QualifierTypes.LiteralValueHierarchyDecl | hierarchy declaration}
+     * Optional {@link QualifierTypes.Config.LiteralValueHierarchyDecl | hierarchy declaration}
      * of territory values to use for matching. If not provided, no hierarchy will be used.
      */
     hierarchy?: LiteralValueHierarchyDecl<string>;
@@ -66,4 +75,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/convert.d.ts

@@ -16,7 +16,7 @@ export interface IQualifierTypeConvertContext {
  * index from a supplied {@link QualifierTypes.Convert.IQualifierTypeConvertContext | conversion context}.
  * @public
  */
-export declare const qualifierType: Converter<QualifierType, IQualifierTypeConvertContext>;
+export declare const qualifierType: Converter<QualifierType<import("@fgv/ts-json-base").JsonObject>, IQualifierTypeConvertContext>;
 /**
  * Gets a converter for {@link QualifierTypes.ILiteralValueHierarchyCreateParams | ILiteralValueHierarchyCreateParams}
  * objects with values validated by a supplied value converter.

package/lib/packlets/qualifier-types/helpers.d.ts

@@ -1,7 +1,16 @@
 import { Result } from '@fgv/ts-utils';
 import * as Config from './config';
 import { QualifierType } from './qualifierType';
-import { JsonObject } from '@fgv/ts-json-base';
+import { LanguageQualifierType } from './languageQualifierType';
+import { TerritoryQualifierType } from './territoryQualifierType';
+import { LiteralQualifierType } from './literalQualifierType';
+/**
+ * A discriminated union of all system qualifier types.
+ * This allows TypeScript to properly discriminate between specific qualifier type implementations
+ * and access their specific methods like getConfiguration().
+ * @public
+ */
+export type SystemQualifierType = LanguageQualifierType | TerritoryQualifierType | LiteralQualifierType;
 /**
  * Creates a {@link QualifierTypes.QualifierType | QualifierType} from a configuration object.
  * This factory function determines the appropriate qualifier type based on the systemType
@@ -12,16 +21,16 @@ import { JsonObject } from '@fgv/ts-json-base';
  * if successful, `Failure` with an error message otherwise.
  * @public
  */
-export declare function createQualifierTypeFromConfig(typeConfig: Config.IQualifierTypeConfig<JsonObject>): Result<QualifierType>;
+export declare function createQualifierTypeFromConfig(typeConfig: Config.IAnyQualifierTypeConfig): Result<QualifierType>;
 /**
- * Creates a {@link QualifierTypes.QualifierType | QualifierType} from a system configuration object.
+ * Creates a {@link QualifierTypes.SystemQualifierType | SystemQualifierType} from a system configuration object.
  * This factory function determines the appropriate qualifier type based on the systemType
  * and delegates to the appropriate type-specific createFromConfig method.
  * @param typeConfig - The {@link QualifierTypes.Config.ISystemQualifierTypeConfig | configuration object}
  * containing the name, systemType, and optional type-specific configuration.
- * @returns `Success` with the new {@link QualifierTypes.QualifierType | QualifierType}
+ * @returns `Success` with the new {@link QualifierTypes.SystemQualifierType | SystemQualifierType}
  * if successful, `Failure` with an error message otherwise.
  * @public
  */
-export declare function createQualifierTypeFromSystemConfig(typeConfig: Config.ISystemQualifierTypeConfig): Result<QualifierType>;
+export declare function createQualifierTypeFromSystemConfig(typeConfig: Config.ISystemQualifierTypeConfig): Result<SystemQualifierType>;
 //# sourceMappingURL=helpers.d.ts.map

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

@@ -93,12 +93,12 @@ function createQualifierTypeFromConfig(typeConfig) {
     }
 }
 /**
- * Creates a {@link QualifierTypes.QualifierType | QualifierType} from a system configuration object.
+ * Creates a {@link QualifierTypes.SystemQualifierType | SystemQualifierType} from a system configuration object.
  * This factory function determines the appropriate qualifier type based on the systemType
  * and delegates to the appropriate type-specific createFromConfig method.
  * @param typeConfig - The {@link QualifierTypes.Config.ISystemQualifierTypeConfig | configuration object}
  * containing the name, systemType, and optional type-specific configuration.
- * @returns `Success` with the new {@link QualifierTypes.QualifierType | QualifierType}
+ * @returns `Success` with the new {@link QualifierTypes.SystemQualifierType | SystemQualifierType}
  * if successful, `Failure` with an error message otherwise.
  * @public
  */

package/lib/packlets/qualifier-types/languageQualifierType.d.ts

@@ -1,7 +1,8 @@
 import { Result } from '@fgv/ts-utils';
-import { ConditionOperator, QualifierConditionValue, QualifierContextValue, QualifierMatchScore } from '../common';
+import { ConditionOperator, QualifierConditionValue, QualifierContextValue, QualifierMatchScore, QualifierTypeName } from '../common';
 import { IQualifierTypeCreateParams, QualifierType } from './qualifierType';
 import * as Config from './config';
+import { JsonCompatible } from '@fgv/ts-json-base';
 /**
  * Interface defining the parameters that can be used to create a new
  * {@link QualifierTypes.LanguageQualifierType | LanguageQualifierType}.
@@ -24,7 +25,11 @@ export interface ILanguageQualifierTypeCreateParams extends Partial<IQualifierTy
  * Accepts a list of language tags in the context by default.
  * @public
  */
-export declare class LanguageQualifierType extends QualifierType {
+export declare class LanguageQualifierType extends QualifierType<JsonCompatible<Config.ILanguageQualifierTypeConfig>> {
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.systemTypeName}
+     */
+    readonly systemTypeName: QualifierTypeName;
     /**
      * Creates a new instance of a {@link QualifierTypes.LanguageQualifierType | language qualifier type}.
      * @param name - Optional name for the qualifier type. Defaults to 'language'.
@@ -54,6 +59,27 @@ export declare class LanguageQualifierType extends QualifierType {
      * {@inheritdoc QualifierTypes.IQualifierType.isValidConditionValue}
      */
     isValidConditionValue(value: string): value is QualifierConditionValue;
+    /**
+     * Gets a {@link QualifierTypes.Config.ISystemLanguageQualifierTypeConfig | strongly typed configuration object}
+     * for this qualifier type.
+     * @returns `Success` with the configuration if successful, `Failure` with an error message otherwise.
+     */
+    getConfiguration(): Result<Config.ISystemLanguageQualifierTypeConfig>;
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.getConfigurationJson}
+     */
+    getConfigurationJson(): Result<JsonCompatible<Config.ISystemLanguageQualifierTypeConfig>>;
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.validateConfigurationJson}
+     */
+    validateConfigurationJson(from: unknown): Result<JsonCompatible<Config.ISystemLanguageQualifierTypeConfig>>;
+    /**
+     * Validates a {@link QualifierTypes.Config.ISystemLanguageQualifierTypeConfig | strongly typed configuration object}
+     * for this qualifier type.
+     * @param from - The unknown data to validate as a configuration object.
+     * @returns `Success` with the validated configuration if successful, `Failure` with an error message otherwise.
+     */
+    validateConfiguration(from: unknown): Result<Config.ISystemLanguageQualifierTypeConfig>;
     /**
      * Matches a single language condition against a single language context value using
      * {@link https://github.com/ErikFortune/fgv/tree/main/libraries/ts-bcp47#tag-matching | similarity matching}.

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

@@ -20,12 +20,46 @@
  * 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.LanguageQualifierType = void 0;
 const ts_utils_1 = require("@fgv/ts-utils");
 const ts_bcp47_1 = require("@fgv/ts-bcp47");
 const common_1 = require("../common");
 const qualifierType_1 = require("./qualifierType");
+const Config = __importStar(require("./config"));
 const ts_json_base_1 = require("@fgv/ts-json-base");
 /**
  * {@link QualifierTypes.QualifierType | Qualifier type} which matches BCP-47 language tags
@@ -48,6 +82,10 @@ class LanguageQualifierType extends qualifierType_1.QualifierType {
         const validated = index ? { index: common_1.Convert.qualifierTypeIndex.convert(index).orThrow() } : {};
         super(Object.assign({ name,
             allowContextList }, validated));
+        /**
+         * {@inheritdoc QualifierTypes.IQualifierType.systemTypeName}
+         */
+        this.systemTypeName = common_1.Convert.qualifierTypeName.convert('language').orThrow();
     }
     /**
      * Creates a new instance of a {@link QualifierTypes.LanguageQualifierType | language qualifier type}.
@@ -84,6 +122,41 @@ class LanguageQualifierType extends qualifierType_1.QualifierType {
             .onSuccess((tag) => (0, ts_utils_1.succeed)(tag.isValid))
             .orDefault(false);
     }
+    /**
+     * Gets a {@link QualifierTypes.Config.ISystemLanguageQualifierTypeConfig | strongly typed configuration object}
+     * for this qualifier type.
+     * @returns `Success` with the configuration if successful, `Failure` with an error message otherwise.
+     */
+    getConfiguration() {
+        return this.getConfigurationJson().onSuccess((json) => Config.Convert.systemLanguageQualifierTypeConfig.convert(json));
+    }
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.getConfigurationJson}
+     */
+    getConfigurationJson() {
+        return (0, ts_utils_1.succeed)({
+            name: this.name,
+            systemType: 'language',
+            configuration: {
+                allowContextList: this.allowContextList
+            }
+        });
+    }
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.validateConfigurationJson}
+     */
+    validateConfigurationJson(from) {
+        return Config.Convert.systemLanguageQualifierTypeConfig.convert(from);
+    }
+    /**
+     * Validates a {@link QualifierTypes.Config.ISystemLanguageQualifierTypeConfig | strongly typed configuration object}
+     * for this qualifier type.
+     * @param from - The unknown data to validate as a configuration object.
+     * @returns `Success` with the validated configuration if successful, `Failure` with an error message otherwise.
+     */
+    validateConfiguration(from) {
+        return Config.Convert.systemLanguageQualifierTypeConfig.convert(from);
+    }
     /**
      * Matches a single language condition against a single language context value using
      * {@link https://github.com/ErikFortune/fgv/tree/main/libraries/ts-bcp47#tag-matching | similarity matching}.

package/lib/packlets/qualifier-types/literalQualifierType.d.ts

@@ -1,8 +1,9 @@
 import { Result } from '@fgv/ts-utils';
-import { ConditionOperator, QualifierConditionValue, QualifierContextValue, QualifierMatchScore } from '../common';
+import { ConditionOperator, QualifierConditionValue, QualifierContextValue, QualifierMatchScore, QualifierTypeName } from '../common';
 import { QualifierType } from './qualifierType';
-import { LiteralValueHierarchy, LiteralValueHierarchyDecl } from './literalValueHierarchy';
+import { LiteralValueHierarchy } from './literalValueHierarchy';
 import * as Config from './config';
+import { JsonCompatible } from '@fgv/ts-json-base';
 /**
  * Interface defining the parameters that can be used to create a new
  * {@link QualifierTypes.LiteralQualifierType | LiteralQualifierType}.
@@ -29,10 +30,10 @@ export interface ILiteralQualifierTypeCreateParams {
      */
     enumeratedValues?: ReadonlyArray<string>;
     /**
-     * Optional {@link QualifierTypes.LiteralValueHierarchyDecl | hierarchy declaration}
+     * Optional {@link QualifierTypes.Config.LiteralValueHierarchyDecl | hierarchy declaration}
      * of literal values to use for matching. If not provided, no hierarchy will be used.
      */
-    hierarchy?: LiteralValueHierarchyDecl<string>;
+    hierarchy?: Config.LiteralValueHierarchyDecl<string>;
     /**
      * Global index for this qualifier type.
      */
@@ -43,7 +44,11 @@ export interface ILiteralQualifierTypeCreateParams {
  * optionally case-sensitive or matching against an ordered list of values at runtime.
  * @public
  */
-export declare class LiteralQualifierType extends QualifierType {
+export declare class LiteralQualifierType extends QualifierType<JsonCompatible<Config.ILiteralQualifierTypeConfig>> {
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.systemTypeName}
+     */
+    readonly systemTypeName: QualifierTypeName;
     /**
      * Indicates whether the qualifier match is case-sensitive.
      */
@@ -79,6 +84,27 @@ export declare class LiteralQualifierType extends QualifierType {
      * {@inheritdoc QualifierTypes.IQualifierType.isPotentialMatch}
      */
     isPotentialMatch(conditionValue: string, contextValue: string): boolean;
+    /**
+     * Gets a {@link QualifierTypes.Config.ISystemLiteralQualifierTypeConfig | strongly typed configuration object}
+     * for this qualifier type.
+     * @returns `Success` with the configuration if successful, `Failure` with an error message otherwise.
+     */
+    getConfiguration(): Result<Config.ISystemLiteralQualifierTypeConfig>;
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.getConfigurationJson}
+     */
+    getConfigurationJson(): Result<JsonCompatible<Config.ISystemLiteralQualifierTypeConfig>>;
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.validateConfigurationJson}
+     */
+    validateConfigurationJson(from: unknown): Result<JsonCompatible<Config.ISystemLiteralQualifierTypeConfig>>;
+    /**
+     * Validates a {@link QualifierTypes.Config.ISystemLiteralQualifierTypeConfig | strongly typed configuration object}
+     * for this qualifier type.
+     * @param from - The unknown data to validate as a configuration object.
+     * @returns `Success` with the validated configuration if successful, `Failure` with an error message otherwise.
+     */
+    validateConfiguration(from: unknown): Result<Config.ISystemLiteralQualifierTypeConfig>;
     /**
      * {@inheritdoc QualifierTypes.QualifierType._matchOne}
      */

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

@@ -20,12 +20,46 @@
  * 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.LiteralQualifierType = void 0;
 const ts_utils_1 = require("@fgv/ts-utils");
 const common_1 = require("../common");
 const qualifierType_1 = require("./qualifierType");
 const literalValueHierarchy_1 = require("./literalValueHierarchy");
+const Config = __importStar(require("./config"));
 const ts_json_base_1 = require("@fgv/ts-json-base");
 /**
  * A {@link QualifierTypes.QualifierType | qualifier} that matches a literal value,
@@ -49,6 +83,10 @@ class LiteralQualifierType extends qualifierType_1.QualifierType {
             allowContextList,
             index: index !== undefined ? common_1.Convert.qualifierTypeIndex.convert(index).orThrow() : undefined
         });
+        /**
+         * {@inheritdoc QualifierTypes.IQualifierType.systemTypeName}
+         */
+        this.systemTypeName = common_1.Convert.qualifierTypeName.convert('literal').orThrow();
         this.caseSensitive = caseSensitive === true;
         this.enumeratedValues = enumeratedValues
             ? (0, ts_utils_1.mapResults)(Array.from(enumeratedValues).map(LiteralQualifierType.toLiteralConditionValue)).orThrow()
@@ -91,6 +129,43 @@ class LiteralQualifierType extends qualifierType_1.QualifierType {
         }
         return false;
     }
+    /**
+     * Gets a {@link QualifierTypes.Config.ISystemLiteralQualifierTypeConfig | strongly typed configuration object}
+     * for this qualifier type.
+     * @returns `Success` with the configuration if successful, `Failure` with an error message otherwise.
+     */
+    getConfiguration() {
+        return this.getConfigurationJson().onSuccess((json) => Config.Convert.systemLiteralQualifierTypeConfig.convert(json));
+    }
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.getConfigurationJson}
+     */
+    getConfigurationJson() {
+        const hierarchy = this.hierarchy ? { hierarchy: this.hierarchy.asRecord() } : {};
+        const enumeratedValues = this.enumeratedValues
+            ? { enumeratedValues: [...this.enumeratedValues] }
+            : {};
+        return (0, ts_utils_1.succeed)({
+            name: this.name,
+            systemType: 'literal',
+            configuration: Object.assign(Object.assign({ allowContextList: this.allowContextList, caseSensitive: this.caseSensitive }, enumeratedValues), hierarchy)
+        });
+    }
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.validateConfigurationJson}
+     */
+    validateConfigurationJson(from) {
+        return Config.Convert.systemLiteralQualifierTypeConfig.convert(from);
+    }
+    /**
+     * Validates a {@link QualifierTypes.Config.ISystemLiteralQualifierTypeConfig | strongly typed configuration object}
+     * for this qualifier type.
+     * @param from - The unknown data to validate as a configuration object.
+     * @returns `Success` with the validated configuration if successful, `Failure` with an error message otherwise.
+     */
+    validateConfiguration(from) {
+        return Config.Convert.systemLiteralQualifierTypeConfig.convert(from);
+    }
     /**
      * {@inheritdoc QualifierTypes.QualifierType._matchOne}
      */

package/lib/packlets/qualifier-types/literalValueHierarchy.d.ts

@@ -1,15 +1,6 @@
 import { Result } from '@fgv/ts-utils';
 import { ConditionOperator, QualifierConditionValue, QualifierContextValue, QualifierMatchScore } from '../common';
-/**
- * Declares a hierarchy of literal values. The keys are the names of the values, and the
- * values are the names of their parents.
- * @remarks
- * The hierarchy is defined as a tree, where each value can have multiple children but
- * only one parent. The root of the tree has no parent. The hierarchy is used to
- * determine the relationship between values when matching conditions and contexts.
- * @public
- */
-export type LiteralValueHierarchyDecl<T extends string> = Partial<Record<T, T>>;
+import { LiteralValueHierarchyDecl } from './config';
 /**
  * Describes a single valid literal value including optional parent and child values.
  * @public
@@ -26,7 +17,7 @@ export interface ILiteralValue<T extends string> {
  */
 export interface ILiteralValueHierarchyCreateParams<T extends string = string> {
     values: ReadonlyArray<T>;
-    hierarchy?: LiteralValueHierarchyDecl<T>;
+    hierarchy?: Partial<LiteralValueHierarchyDecl<T>>;
 }
 /**
  * A class that implements a hierarchy of literal values. The hierarchy is defined as a
@@ -110,5 +101,10 @@ export declare class LiteralValueHierarchy<T extends string = string> {
      */
     match(condition: QualifierConditionValue, context: QualifierContextValue, __operator?: ConditionOperator): QualifierMatchScore;
     protected static _buildValuesFromHierarchy<T extends string>(params: ILiteralValueHierarchyCreateParams<T>): Result<ReadonlyMap<T, ILiteralValue<T>>>;
+    /**
+     * Converts the hierarchy to a record of parent-child relationships.
+     * @returns A record of parent-child relationships.
+     */
+    asRecord(): Record<string, string>;
 }
 //# sourceMappingURL=literalValueHierarchy.d.ts.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`);
         }
@@ -102,6 +102,7 @@ class LiteralValueHierarchy {
         if (ancestors.isSuccess()) {
             return ancestors.value.includes(possibleAncestor);
         }
+        /* c8 ignore next 1 - edge case: ancestor validation fallback */
         return false;
     }
     /**
@@ -223,6 +224,16 @@ class LiteralValueHierarchy {
         }
         return errors.returnOrReport((0, ts_utils_1.succeed)(valueMap));
     }
+    /**
+     * Converts the hierarchy to a record of parent-child relationships.
+     * @returns A record of parent-child relationships.
+     */
+    asRecord() {
+        const entries = Array.from(this.values.values())
+            .filter((v) => v.parent !== undefined)
+            .map((v) => [v.name, v.parent.name]);
+        return Object.fromEntries(entries);
+    }
 }
 exports.LiteralValueHierarchy = LiteralValueHierarchy;
 //# sourceMappingURL=literalValueHierarchy.js.map