@fgv/ts-res 4.5.0-2 → 5.0.0-0

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

@@ -25,20 +25,24 @@ 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 ts_json_base_1 = require("@fgv/ts-json-base");
 /**
- * A {@link QualifierTypes.QualifierType | qualifier} that matches a literal value., optionally case-sensitive
- * or matching against an ordered list of values at runtime.
+ * A {@link QualifierTypes.QualifierType | qualifier} that matches a literal value,
+ * optionally case-sensitive or matching against an ordered list of values at runtime.
  * @public
  */
 class LiteralQualifierType extends qualifierType_1.QualifierType {
     /**
      * Constructs a new {@link QualifierTypes.LiteralQualifierType | LiteralQualifierType}.
      * @param name - Optional name for the qualifier type. Defaults to 'literal'.
-     * @param caseSensitive - Optional flag indicating whether the match should be case-sensitive. Defaults to false.
-     * @param allowContextList - Optional flag indicating whether the context can be a list of values. Defaults to false.
+     * @param caseSensitive - Optional flag indicating whether the match should be
+     * case-sensitive. Defaults to `false`.
+     * @param allowContextList - Optional flag indicating whether the context can be a
+     * list of values. Defaults to `false`.
      * @public
      */
-    constructor({ name, caseSensitive, allowContextList, enumeratedValues, index }) {
+    constructor({ name, caseSensitive, allowContextList, enumeratedValues, hierarchy, index }) {
         allowContextList = allowContextList !== false;
         super({
             name: name !== null && name !== void 0 ? name : 'literal',
@@ -49,10 +53,17 @@ class LiteralQualifierType extends qualifierType_1.QualifierType {
         this.enumeratedValues = enumeratedValues
             ? (0, ts_utils_1.mapResults)(Array.from(enumeratedValues).map(LiteralQualifierType.toLiteralConditionValue)).orThrow()
             : undefined;
+        if (hierarchy) {
+            /* c8 ignore next 5 - defensive coding: enumeratedValues ?? [] fallback enables open values mode */
+            this.hierarchy = literalValueHierarchy_1.LiteralValueHierarchy.create({
+                values: enumeratedValues !== null && enumeratedValues !== void 0 ? enumeratedValues : [],
+                hierarchy: hierarchy
+            }).orThrow();
+        }
     }
     /**
-     * Determines whether a value is a valid condition value for a literal qualifier. The
-     * {@link QualifierTypes.LiteralQualifierType | LiteralQualifierType} accepts
+     * Determines whether a value is a valid condition value for a literal qualifier.
+     * The {@link QualifierTypes.LiteralQualifierType | LiteralQualifierType} accepts
      * any identifier as a valid condition value.
      * @param value - The value to validate.
      * @returns `true` if the value is a valid condition value, `false` otherwise.
@@ -69,7 +80,10 @@ class LiteralQualifierType extends qualifierType_1.QualifierType {
     /**
      * {@inheritdoc QualifierTypes.QualifierType._matchOne}
      */
-    _matchOne(condition, context, operator) {
+    _matchOne(condition, context, __operator) {
+        if (this.hierarchy) {
+            return this.hierarchy.match(condition, context, __operator);
+        }
         if (this.caseSensitive) {
             return condition === context ? common_1.PerfectMatch : common_1.NoMatch;
         }
@@ -88,6 +102,26 @@ class LiteralQualifierType extends qualifierType_1.QualifierType {
     static create(params) {
         return (0, ts_utils_1.captureResult)(() => new LiteralQualifierType(params !== null && params !== void 0 ? params : {}));
     }
+    /**
+     * Creates a new {@link QualifierTypes.LiteralQualifierType | LiteralQualifierType} from a configuration object.
+     * @param config - The {@link QualifierTypes.Config.IQualifierTypeConfig | configuration object} containing
+     * the name, systemType, and optional literal-specific configuration including case sensitivity,
+     * enumerated values, and hierarchy information.
+     * @returns `Success` with the new {@link QualifierTypes.LiteralQualifierType | LiteralQualifierType}
+     * if successful, `Failure` with an error message otherwise.
+     * @public
+     */
+    static createFromConfig(config) {
+        var _a;
+        const literalConfig = (_a = config.configuration) !== null && _a !== void 0 ? _a : {};
+        return (0, ts_json_base_1.sanitizeJsonObject)({
+            name: config.name,
+            allowContextList: literalConfig.allowContextList === true,
+            caseSensitive: literalConfig.caseSensitive,
+            enumeratedValues: literalConfig.enumeratedValues,
+            hierarchy: literalConfig.hierarchy
+        }).onSuccess(LiteralQualifierType.create);
+    }
     /**
      * Checks if the given value is a valid literal condition value.
      * @param from - The value to validate.
@@ -100,8 +134,8 @@ class LiteralQualifierType extends qualifierType_1.QualifierType {
     /**
      * Converts a string to a {@link QualifierConditionValue | literal condition value}.
      * @param from - The string to convert.
-     * @returns `Success` with the converted value if valid, or `Failure` with an error message
-     * if not.
+     * @returns `Success` with the converted value if valid, or `Failure` with an error
+     * message if not.
      * @public
      */
     static toLiteralConditionValue(from) {

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

@@ -1 +1 @@
-{"version":3,"file":"literalQualifierType.js","sourceRoot":"","sources":["../../../src/packlets/qualifier-types/literalQualifierType.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;;;AAEH,4CAAiF;AACjF,sCASmB;AACnB,mDAAgD;AAoChD;;;;GAIG;AACH,MAAa,oBAAqB,SAAQ,6BAAa;IAWrD;;;;;;OAMG;IACH,YAAsB,EACpB,IAAI,EACJ,aAAa,EACb,gBAAgB,EAChB,gBAAgB,EAChB,KAAK,EAC6B;QAClC,gBAAgB,GAAG,gBAAgB,KAAK,KAAK,CAAC;QAC9C,KAAK,CAAC;YACJ,IAAI,EAAE,IAAI,aAAJ,IAAI,cAAJ,IAAI,GAAI,SAAS;YACvB,gBAAgB;YAChB,KAAK,EAAE,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,gBAAO,CAAC,kBAAkB,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,SAAS;SAC7F,CAAC,CAAC;QACH,IAAI,CAAC,aAAa,GAAG,aAAa,KAAK,IAAI,CAAC;QAC5C,IAAI,CAAC,gBAAgB,GAAG,gBAAgB;YACtC,CAAC,CAAC,IAAA,qBAAU,EAAC,KAAK,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC,GAAG,CAAC,oBAAoB,CAAC,uBAAuB,CAAC,CAAC,CAAC,OAAO,EAAE;YACtG,CAAC,CAAC,SAAS,CAAC;IAChB,CAAC;IAED;;;;;;OAMG;IACI,qBAAqB,CAAC,KAAa;QACxC,IAAI,IAAI,CAAC,gBAAgB,EAAE,CAAC;YAC1B,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;gBACvB,OAAO,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,KAAgC,CAAC,CAAC;YAC1E,CAAC;YACD,OAAO,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,KAAK,KAAK,CAAC,WAAW,EAAE,CAAC,CAAC;QACpF,CAAC;QACD,OAAO,oBAAoB,CAAC,4BAA4B,CAAC,KAAK,CAAC,CAAC;IAClE,CAAC;IAED;;OAEG;IACO,SAAS,CACjB,SAAkC,EAClC,OAA8B,EAC9B,QAA2B;QAE3B,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;YACvB,OAAO,SAAS,KAAM,OAAkB,CAAC,CAAC,CAAC,qBAAY,CAAC,CAAC,CAAC,gBAAO,CAAC;QACpE,CAAC;aAAM,CAAC;YACN,OAAO,SAAS,CAAC,WAAW,EAAE,KAAK,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,qBAAY,CAAC,CAAC,CAAC,gBAAO,CAAC;QACpF,CAAC;IACH,CAAC;IAED;;;;;;;OAOG;IACI,MAAM,CAAC,MAAM,CAAC,MAA0C;QAC7D,OAAO,IAAA,wBAAa,EAAC,GAAG,EAAE,CAAC,IAAI,oBAAoB,CAAC,MAAM,aAAN,MAAM,cAAN,MAAM,GAAI,EAAE,CAAC,CAAC,CAAC;IACrE,CAAC;IAED;;;;;OAKG;IACI,MAAM,CAAC,4BAA4B,CAAC,IAAY;QACrD,OAAO,iBAAQ,CAAC,kBAAkB,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC3D,CAAC;IAED;;;;;;OAMG;IACI,MAAM,CAAC,uBAAuB,CAAC,IAAY;QAChD,OAAO,oBAAoB,CAAC,4BAA4B,CAAC,IAAI,CAAC;YAC5D,CAAC,CAAC,IAAA,kBAAO,EAAC,IAAI,CAAC;YACf,CAAC,CAAC,IAAA,eAAI,EAAC,GAAG,IAAI,wCAAwC,CAAC,CAAC;IAC5D,CAAC;CACF;AAvGD,oDAuGC","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 { captureResult, mapResults, Result, fail, succeed } from '@fgv/ts-utils';\nimport {\n  ConditionOperator,\n  Convert,\n  NoMatch,\n  PerfectMatch,\n  QualifierConditionValue,\n  QualifierContextValue,\n  QualifierMatchScore,\n  Validate\n} from '../common';\nimport { QualifierType } from './qualifierType';\n\n/**\n * Interface defining the parameters that can be used to create a new\n * {@link QualifierTypes.LiteralQualifierType | LiteralQualifierType}.\n * @public\n */\nexport interface ILiteralQualifierTypeCreateParams {\n  /**\n   * Optional name for the qualifier type. Defaults to 'literal'.\n   */\n  name?: string;\n\n  /**\n   * Optional flag indicating whether the context can be a list of values.\n   * Defaults to `true`.\n   */\n  allowContextList?: boolean;\n\n  /**\n   * Optional flag indicating whether the match should be case-sensitive. Defaults to false.\n   */\n  caseSensitive?: boolean;\n\n  /**\n   * Optional array of enumerated values to further constrain the type. Defaults to no\n   * constraint.\n   */\n  enumeratedValues?: ReadonlyArray<string>;\n\n  /**\n   * Global index for this qualifier type.\n   */\n  index?: number;\n}\n\n/**\n * A {@link QualifierTypes.QualifierType | qualifier} that matches a literal value., optionally case-sensitive\n * or matching against an ordered list of values at runtime.\n * @public\n */\nexport class LiteralQualifierType extends QualifierType {\n  /**\n   * Indicates whether the qualifier match is case-sensitive.\n   */\n  public readonly caseSensitive: boolean;\n\n  /**\n   * Optional array of enumerated values to further constrain the type.\n   */\n  public readonly enumeratedValues?: ReadonlyArray<QualifierConditionValue>;\n\n  /**\n   * Constructs a new {@link QualifierTypes.LiteralQualifierType | LiteralQualifierType}.\n   * @param name - Optional name for the qualifier type. Defaults to 'literal'.\n   * @param caseSensitive - Optional flag indicating whether the match should be case-sensitive. Defaults to false.\n   * @param allowContextList - Optional flag indicating whether the context can be a list of values. Defaults to false.\n   * @public\n   */\n  protected constructor({\n    name,\n    caseSensitive,\n    allowContextList,\n    enumeratedValues,\n    index\n  }: ILiteralQualifierTypeCreateParams) {\n    allowContextList = allowContextList !== false;\n    super({\n      name: name ?? 'literal',\n      allowContextList,\n      index: index !== undefined ? Convert.qualifierTypeIndex.convert(index).orThrow() : undefined\n    });\n    this.caseSensitive = caseSensitive === true;\n    this.enumeratedValues = enumeratedValues\n      ? mapResults(Array.from(enumeratedValues).map(LiteralQualifierType.toLiteralConditionValue)).orThrow()\n      : undefined;\n  }\n\n  /**\n   * Determines whether a value is a valid condition value for a literal qualifier. The\n   * {@link QualifierTypes.LiteralQualifierType | LiteralQualifierType} accepts\n   * any identifier as a valid condition value.\n   * @param value - The value to validate.\n   * @returns `true` if the value is a valid condition value, `false` otherwise.\n   */\n  public isValidConditionValue(value: string): value is QualifierConditionValue {\n    if (this.enumeratedValues) {\n      if (this.caseSensitive) {\n        return this.enumeratedValues.includes(value as QualifierConditionValue);\n      }\n      return this.enumeratedValues.some((v) => v.toLowerCase() === value.toLowerCase());\n    }\n    return LiteralQualifierType.isValidLiteralConditionValue(value);\n  }\n\n  /**\n   * {@inheritdoc QualifierTypes.QualifierType._matchOne}\n   */\n  protected _matchOne(\n    condition: QualifierConditionValue,\n    context: QualifierContextValue,\n    operator: ConditionOperator\n  ): QualifierMatchScore {\n    if (this.caseSensitive) {\n      return condition === (context as string) ? PerfectMatch : NoMatch;\n    } else {\n      return condition.toLowerCase() === context.toLowerCase() ? PerfectMatch : NoMatch;\n    }\n  }\n\n  /**\n   * Creates a new {@link QualifierTypes.LiteralQualifierType | LiteralQualifierType}.\n   * @param params - Optional {@link QualifierTypes.ILiteralQualifierTypeCreateParams | parameters}\n   * to use when creating the new instance.\n   * @returns `Success` with the new {@link QualifierTypes.LiteralQualifierType | LiteralQualifierType}\n   * if successful, `Failure` with an error message otherwise.\n   * @public\n   */\n  public static create(params?: ILiteralQualifierTypeCreateParams): Result<LiteralQualifierType> {\n    return captureResult(() => new LiteralQualifierType(params ?? {}));\n  }\n\n  /**\n   * Checks if the given value is a valid literal condition value.\n   * @param from - The value to validate.\n   * @returns `true` if the value is a valid literal condition value, otherwise `false`.\n   * @public\n   */\n  public static isValidLiteralConditionValue(from: string): from is QualifierConditionValue {\n    return Validate.RegularExpressions.identifier.test(from);\n  }\n\n  /**\n   * Converts a string to a {@link QualifierConditionValue | literal condition value}.\n   * @param from - The string to convert.\n   * @returns `Success` with the converted value if valid, or `Failure` with an error message\n   * if not.\n   * @public\n   */\n  public static toLiteralConditionValue(from: string): Result<QualifierConditionValue> {\n    return LiteralQualifierType.isValidLiteralConditionValue(from)\n      ? succeed(from)\n      : fail(`${from}: not a valid literal condition value.`);\n  }\n}\n"]}
+{"version":3,"file":"literalQualifierType.js","sourceRoot":"","sources":["../../../src/packlets/qualifier-types/literalQualifierType.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 { captureResult, mapResults, Result, fail, succeed } from '@fgv/ts-utils';\nimport {\n  ConditionOperator,\n  Convert,\n  NoMatch,\n  PerfectMatch,\n  QualifierConditionValue,\n  QualifierContextValue,\n  QualifierMatchScore,\n  Validate\n} from '../common';\nimport { QualifierType } from './qualifierType';\nimport { LiteralValueHierarchy, LiteralValueHierarchyDecl } from './literalValueHierarchy';\nimport * as Config from './config';\nimport { sanitizeJsonObject } from '@fgv/ts-json-base';\n\n/**\n * Interface defining the parameters that can be used to create a new\n * {@link QualifierTypes.LiteralQualifierType | LiteralQualifierType}.\n * @public\n */\nexport interface ILiteralQualifierTypeCreateParams {\n  /**\n   * Optional name for the qualifier type. Defaults to 'literal'.\n   */\n  name?: string;\n\n  /**\n   * Optional flag indicating whether the context can be a list of values.\n   * Defaults to `true`.\n   */\n  allowContextList?: boolean;\n\n  /**\n   * Optional flag indicating whether the match should be case-sensitive.\n   * Defaults to `false`.\n   */\n  caseSensitive?: boolean;\n\n  /**\n   * Optional array of enumerated values to further constrain the type.\n   * Defaults to no constraint.\n   */\n  enumeratedValues?: ReadonlyArray<string>;\n\n  /**\n   * Optional {@link QualifierTypes.LiteralValueHierarchyDecl | hierarchy declaration}\n   * of literal values to use for matching. If not provided, no hierarchy will be used.\n   */\n  hierarchy?: LiteralValueHierarchyDecl<string>;\n\n  /**\n   * Global index for this qualifier type.\n   */\n  index?: number;\n}\n\n/**\n * A {@link QualifierTypes.QualifierType | qualifier} that matches a literal value,\n * optionally case-sensitive or matching against an ordered list of values at runtime.\n * @public\n */\nexport class LiteralQualifierType extends QualifierType {\n  /**\n   * Indicates whether the qualifier match is case-sensitive.\n   */\n  public readonly caseSensitive: boolean;\n\n  /**\n   * Optional array of enumerated values to further constrain the type.\n   */\n  public readonly enumeratedValues?: ReadonlyArray<QualifierConditionValue>;\n\n  /**\n   * Optional {@link QualifierTypes.LiteralValueHierarchy | hierarchy} of literal\n   * values to use for matching. If not provided, no hierarchy will be used.\n   */\n  public readonly hierarchy?: LiteralValueHierarchy<string>;\n\n  /**\n   * Constructs a new {@link QualifierTypes.LiteralQualifierType | LiteralQualifierType}.\n   * @param name - Optional name for the qualifier type. Defaults to 'literal'.\n   * @param caseSensitive - Optional flag indicating whether the match should be\n   * case-sensitive. Defaults to `false`.\n   * @param allowContextList - Optional flag indicating whether the context can be a\n   * list of values. Defaults to `false`.\n   * @public\n   */\n  protected constructor({\n    name,\n    caseSensitive,\n    allowContextList,\n    enumeratedValues,\n    hierarchy,\n    index\n  }: ILiteralQualifierTypeCreateParams) {\n    allowContextList = allowContextList !== false;\n    super({\n      name: name ?? 'literal',\n      allowContextList,\n      index: index !== undefined ? Convert.qualifierTypeIndex.convert(index).orThrow() : undefined\n    });\n    this.caseSensitive = caseSensitive === true;\n    this.enumeratedValues = enumeratedValues\n      ? mapResults(Array.from(enumeratedValues).map(LiteralQualifierType.toLiteralConditionValue)).orThrow()\n      : undefined;\n    if (hierarchy) {\n      /* c8 ignore next 5 - defensive coding: enumeratedValues ?? [] fallback enables open values mode */\n      this.hierarchy = LiteralValueHierarchy.create({\n        values: enumeratedValues ?? [],\n        hierarchy: hierarchy\n      }).orThrow();\n    }\n  }\n\n  /**\n   * Determines whether a value is a valid condition value for a literal qualifier.\n   * The {@link QualifierTypes.LiteralQualifierType | LiteralQualifierType} accepts\n   * any identifier as a valid condition value.\n   * @param value - The value to validate.\n   * @returns `true` if the value is a valid condition value, `false` otherwise.\n   */\n  public isValidConditionValue(value: string): value is QualifierConditionValue {\n    if (this.enumeratedValues) {\n      if (this.caseSensitive) {\n        return this.enumeratedValues.includes(value as QualifierConditionValue);\n      }\n      return this.enumeratedValues.some((v) => v.toLowerCase() === value.toLowerCase());\n    }\n    return LiteralQualifierType.isValidLiteralConditionValue(value);\n  }\n\n  /**\n   * {@inheritdoc QualifierTypes.QualifierType._matchOne}\n   */\n  protected _matchOne(\n    condition: QualifierConditionValue,\n    context: QualifierContextValue,\n    __operator: ConditionOperator\n  ): QualifierMatchScore {\n    if (this.hierarchy) {\n      return this.hierarchy.match(condition, context, __operator);\n    }\n    if (this.caseSensitive) {\n      return condition === (context as string) ? PerfectMatch : NoMatch;\n    } else {\n      return condition.toLowerCase() === context.toLowerCase() ? PerfectMatch : NoMatch;\n    }\n  }\n\n  /**\n   * Creates a new {@link QualifierTypes.LiteralQualifierType | LiteralQualifierType}.\n   * @param params - Optional {@link QualifierTypes.ILiteralQualifierTypeCreateParams | parameters}\n   * to use when creating the new instance.\n   * @returns `Success` with the new {@link QualifierTypes.LiteralQualifierType | LiteralQualifierType}\n   * if successful, `Failure` with an error message otherwise.\n   * @public\n   */\n  public static create(params?: ILiteralQualifierTypeCreateParams): Result<LiteralQualifierType> {\n    return captureResult(() => new LiteralQualifierType(params ?? {}));\n  }\n\n  /**\n   * Creates a new {@link QualifierTypes.LiteralQualifierType | LiteralQualifierType} from a configuration object.\n   * @param config - The {@link QualifierTypes.Config.IQualifierTypeConfig | configuration object} containing\n   * the name, systemType, and optional literal-specific configuration including case sensitivity,\n   * enumerated values, and hierarchy information.\n   * @returns `Success` with the new {@link QualifierTypes.LiteralQualifierType | LiteralQualifierType}\n   * if successful, `Failure` with an error message otherwise.\n   * @public\n   */\n  public static createFromConfig(\n    config: Config.IQualifierTypeConfig<Config.ILiteralQualifierTypeConfig>\n  ): Result<LiteralQualifierType> {\n    const literalConfig = config.configuration ?? {};\n    return sanitizeJsonObject<ILiteralQualifierTypeCreateParams>({\n      name: config.name,\n      allowContextList: literalConfig.allowContextList === true,\n      caseSensitive: literalConfig.caseSensitive,\n      enumeratedValues: literalConfig.enumeratedValues,\n      hierarchy: literalConfig.hierarchy\n    }).onSuccess(LiteralQualifierType.create);\n  }\n\n  /**\n   * Checks if the given value is a valid literal condition value.\n   * @param from - The value to validate.\n   * @returns `true` if the value is a valid literal condition value, otherwise `false`.\n   * @public\n   */\n  public static isValidLiteralConditionValue(from: string): from is QualifierConditionValue {\n    return Validate.RegularExpressions.identifier.test(from);\n  }\n\n  /**\n   * Converts a string to a {@link QualifierConditionValue | literal condition value}.\n   * @param from - The string to convert.\n   * @returns `Success` with the converted value if valid, or `Failure` with an error\n   * message if not.\n   * @public\n   */\n  public static toLiteralConditionValue(from: string): Result<QualifierConditionValue> {\n    return LiteralQualifierType.isValidLiteralConditionValue(from)\n      ? succeed(from)\n      : fail(`${from}: not a valid literal condition value.`);\n  }\n}\n"]}

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

@@ -0,0 +1,107 @@
+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>>;
+/**
+ * Describes a single valid literal value including optional parent and child values.
+ * @public
+ */
+export interface ILiteralValue<T extends string> {
+    readonly name: T;
+    readonly parent?: ILiteralValue<T>;
+    readonly children?: ReadonlyArray<T>;
+}
+/**
+ * Describes the parameters used to create a new
+ * {@link QualifierTypes.LiteralValueHierarchy | LiteralValueHierarchy}.
+ * @public
+ */
+export interface ILiteralValueHierarchyCreateParams<T extends string = string> {
+    values: ReadonlyArray<T>;
+    hierarchy?: LiteralValueHierarchyDecl<T>;
+}
+/**
+ * A class that implements a hierarchy of literal values. 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.
+ *
+ * @remarks
+ * The hierarchy can be created in two modes:
+ * - **Constrained mode**: When enumerated values are provided, only those values are allowed
+ *   in the hierarchy and matching operations.
+ * - **Open values mode**: When no enumerated values are provided, all values referenced in
+ *   the hierarchy are automatically collected and used. This allows for flexible hierarchies
+ *   where any value can be used in matching operations.
+ * @public
+ */
+export declare class LiteralValueHierarchy<T extends string = string> {
+    /**
+     * A map of all allowed literal values to the corresponding
+     * {@link QualifierTypes.ILiteralValue | ILiteralValue} validated definition.
+     */
+    readonly values: ReadonlyMap<T, ILiteralValue<T>>;
+    /**
+     * Indicates whether this hierarchy was created with open values (no enumerated values
+     * provided), allowing any value to be used in matching operations.
+     */
+    readonly isOpenValues: boolean;
+    protected constructor(params: ILiteralValueHierarchyCreateParams<T>);
+    /**
+     * Creates a new {@link QualifierTypes.LiteralValueHierarchy | LiteralValueHierarchy} instance.
+     * @param params - The {@link QualifierTypes.ILiteralValueHierarchyCreateParams | parameters}
+     * used to create the hierarchy.
+     * @returns `Success` with the new hierarchy or `Failure` with an error message.
+     */
+    static create<T extends string>(params: ILiteralValueHierarchyCreateParams<T>): Result<LiteralValueHierarchy<T>>;
+    /**
+     * Checks if a value exists in the hierarchy.
+     * @param value - The value to check.
+     * @returns `true` if the value exists in the hierarchy, `false` otherwise.
+     */
+    hasValue(value: T): boolean;
+    /**
+     * Gets all root values (values with no parent) in the hierarchy.
+     * @returns `Success` with an array of root values.
+     */
+    getRoots(): Result<T[]>;
+    /**
+     * Gets all ancestors of a value in the hierarchy.
+     * @param value - The value to get ancestors for.
+     * @returns `Success` with an array of ancestor values, ordered from immediate parent
+     * to root, or `Failure` if the value is not in the hierarchy.
+     */
+    getAncestors(value: T): Result<T[]>;
+    /**
+     * Gets all descendants of a value in the hierarchy.
+     * @param value - The value to get descendants for.
+     * @returns `Success` with an array of descendant values, or `Failure` if the value
+     * is not in the hierarchy.
+     */
+    getDescendants(value: T): Result<T[]>;
+    match(condition: T, context: T): QualifierMatchScore;
+    /**
+     * Matches a condition value against a context value, where an exact match of the
+     * condition and context returns {@link PerfectMatch | PerfectMatch}, a condition
+     * value that does not match the context value or any of its ancestors returns
+     * {@link NoMatch | NoMatch}, and a condition value that matches the context value
+     * or any of its ancestors returns a positive score that is less than
+     * {@link PerfectMatch | PerfectMatch}, with the score decreasing with each ancestor
+     * in the hierarchy.
+     * @param condition - The condition value to match.
+     * @param context - The context value to match against.
+     * @param __operator - The operator used for matching (not used in this implementation).
+     * @returns A {@link QualifierMatchScore | QualifierMatchScore} indicating the match score.
+     */
+    match(condition: QualifierConditionValue, context: QualifierContextValue, __operator?: ConditionOperator): QualifierMatchScore;
+    protected static _buildValuesFromHierarchy<T extends string>(params: ILiteralValueHierarchyCreateParams<T>): Result<ReadonlyMap<T, ILiteralValue<T>>>;
+}
+//# sourceMappingURL=literalValueHierarchy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"literalValueHierarchy.d.ts","sourceRoot":"","sources":["../../../src/packlets/qualifier-types/literalValueHierarchy.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAoC,MAAM,EAAiB,MAAM,eAAe,CAAC;AACxF,OAAO,EACL,iBAAiB,EAGjB,uBAAuB,EACvB,qBAAqB,EACrB,mBAAmB,EAEpB,MAAM,WAAW,CAAC;AAEnB;;;;;;;;GAQG;AACH,MAAM,MAAM,yBAAyB,CAAC,CAAC,SAAS,MAAM,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAEhF;;;GAGG;AACH,MAAM,WAAW,aAAa,CAAC,CAAC,SAAS,MAAM;IAC7C,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;IACjB,QAAQ,CAAC,MAAM,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC;IACnC,QAAQ,CAAC,QAAQ,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC;CACtC;AAED;;;;GAIG;AACH,MAAM,WAAW,kCAAkC,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM;IAC3E,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC;IACzB,SAAS,CAAC,EAAE,yBAAyB,CAAC,CAAC,CAAC,CAAC;CAC1C;AAaD;;;;;;;;;;;;;;GAcG;AACH,qBAAa,qBAAqB,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM;IAC1D;;;OAGG;IACH,SAAgB,MAAM,EAAE,WAAW,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;IAEzD;;;OAGG;IACH,SAAgB,YAAY,EAAE,OAAO,CAAC;IAEtC,SAAS,aAAa,MAAM,EAAE,kCAAkC,CAAC,CAAC,CAAC;IAMnE;;;;;OAKG;WACW,MAAM,CAAC,CAAC,SAAS,MAAM,EACnC,MAAM,EAAE,kCAAkC,CAAC,CAAC,CAAC,GAC5C,MAAM,CAAC,qBAAqB,CAAC,CAAC,CAAC,CAAC;IAInC;;;;OAIG;IACI,QAAQ,CAAC,KAAK,EAAE,CAAC,GAAG,OAAO;IAIlC;;;OAGG;IACI,QAAQ,IAAI,MAAM,CAAC,CAAC,EAAE,CAAC;IAQ9B;;;;;OAKG;IACI,YAAY,CAAC,KAAK,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,EAAE,CAAC;IAkB1C;;;;;OAKG;IACI,cAAc,CAAC,KAAK,EAAE,CAAC,GAAG,MAAM,CAAC,CAAC,EAAE,CAAC;IAoBrC,KAAK,CAAC,SAAS,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,GAAG,mBAAmB;IAC3D;;;;;;;;;;;;OAYG;IACI,KAAK,CACV,SAAS,EAAE,uBAAuB,EAClC,OAAO,EAAE,qBAAqB,EAC9B,UAAU,CAAC,EAAE,iBAAiB,GAC7B,mBAAmB;IAuCtB,SAAS,CAAC,MAAM,CAAC,yBAAyB,CAAC,CAAC,SAAS,MAAM,EACzD,MAAM,EAAE,kCAAkC,CAAC,CAAC,CAAC,GAC5C,MAAM,CAAC,WAAW,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;CAkE5C"}

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

@@ -0,0 +1,215 @@
+"use strict";
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiteralValueHierarchy = void 0;
+const ts_utils_1 = require("@fgv/ts-utils");
+const common_1 = require("../common");
+/**
+ * A class that implements a hierarchy of literal values. 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.
+ *
+ * @remarks
+ * The hierarchy can be created in two modes:
+ * - **Constrained mode**: When enumerated values are provided, only those values are allowed
+ *   in the hierarchy and matching operations.
+ * - **Open values mode**: When no enumerated values are provided, all values referenced in
+ *   the hierarchy are automatically collected and used. This allows for flexible hierarchies
+ *   where any value can be used in matching operations.
+ * @public
+ */
+class LiteralValueHierarchy {
+    constructor(params) {
+        const result = LiteralValueHierarchy._buildValuesFromHierarchy(params);
+        this.values = result.orThrow();
+        this.isOpenValues = !params.values || params.values.length === 0;
+    }
+    /**
+     * Creates a new {@link QualifierTypes.LiteralValueHierarchy | LiteralValueHierarchy} instance.
+     * @param params - The {@link QualifierTypes.ILiteralValueHierarchyCreateParams | parameters}
+     * used to create the hierarchy.
+     * @returns `Success` with the new hierarchy or `Failure` with an error message.
+     */
+    static create(params) {
+        return (0, ts_utils_1.captureResult)(() => new LiteralValueHierarchy(params));
+    }
+    /**
+     * Checks if a value exists in the hierarchy.
+     * @param value - The value to check.
+     * @returns `true` if the value exists in the hierarchy, `false` otherwise.
+     */
+    hasValue(value) {
+        return this.values.has(value);
+    }
+    /**
+     * Gets all root values (values with no parent) in the hierarchy.
+     * @returns `Success` with an array of root values.
+     */
+    getRoots() {
+        return (0, ts_utils_1.succeed)(Array.from(this.values.values())
+            .filter((v) => !v.parent)
+            .map((v) => v.name));
+    }
+    /**
+     * Gets all ancestors of a value in the hierarchy.
+     * @param value - The value to get ancestors for.
+     * @returns `Success` with an array of ancestor values, ordered from immediate parent
+     * to root, or `Failure` if the value is not in the hierarchy.
+     */
+    getAncestors(value) {
+        const current = this.values.get(value);
+        /* c8 ignore next 2 - functional error case tested but coverage intermittently missed */
+        if (!current) {
+            return (0, ts_utils_1.fail)(`${value}: not found in hierarchy`);
+        }
+        const ancestors = [];
+        let ancestor = current.parent;
+        while (ancestor) {
+            ancestors.push(ancestor.name);
+            ancestor = ancestor.parent;
+        }
+        return (0, ts_utils_1.succeed)(ancestors);
+    }
+    /**
+     * Gets all descendants of a value in the hierarchy.
+     * @param value - The value to get descendants for.
+     * @returns `Success` with an array of descendant values, or `Failure` if the value
+     * is not in the hierarchy.
+     */
+    getDescendants(value) {
+        const current = this.values.get(value);
+        if (!current) {
+            return (0, ts_utils_1.fail)(`${value}: not found in hierarchy`);
+        }
+        const descendants = [];
+        if (current.children) {
+            for (const childName of current.children) {
+                descendants.push(childName);
+                const childDescendants = this.getDescendants(childName);
+                if (childDescendants.isSuccess()) {
+                    descendants.push(...childDescendants.value);
+                }
+            }
+        }
+        return (0, ts_utils_1.succeed)(descendants);
+    }
+    match(condition, context, __operator) {
+        var _a;
+        // For open hierarchies, skip validation and allow any values
+        if (!this.isOpenValues) {
+            // Validate that both condition and context exist in the hierarchy
+            /* c8 ignore next 2 - functional error case tested but coverage intermittently missed */
+            if (!this.values.has(condition)) {
+                return common_1.NoMatch;
+            }
+            /* c8 ignore next 2 - functional error case tested but coverage intermittently missed */
+            if (!this.values.has(context)) {
+                return common_1.NoMatch;
+            }
+        }
+        if (condition === context) {
+            return common_1.PerfectMatch;
+        }
+        // For open hierarchies, if values aren't in the hierarchy, treat as no match
+        // but don't fail validation
+        const values = this.values;
+        /* c8 ignore next 1 - ? is defense in depth */
+        let value = (_a = values.get(context)) === null || _a === void 0 ? void 0 : _a.parent;
+        /* c8 ignore next 2 - functional error case tested but coverage intermittently missed */
+        if (!value) {
+            return common_1.NoMatch;
+        }
+        let score = common_1.PerfectMatch;
+        while (value) {
+            score *= 0.9;
+            if (value.name === condition) {
+                return common_1.Convert.qualifierMatchScore.convert(score).orDefault(common_1.NoMatch);
+            }
+            value = value.parent;
+        }
+        return common_1.NoMatch;
+    }
+    static _buildValuesFromHierarchy(params) {
+        var _a;
+        const errors = new ts_utils_1.MessageAggregator();
+        const values = params.values;
+        const hierarchy = (_a = params.hierarchy) !== null && _a !== void 0 ? _a : {};
+        // If no values are provided, collect all values from the hierarchy
+        let allValues;
+        if (!values || values.length === 0) {
+            const hierarchyValues = new Set();
+            // Add all keys and values from the hierarchy
+            Object.keys(hierarchy).forEach((key) => hierarchyValues.add(key));
+            Object.values(hierarchy).forEach((value) => hierarchyValues.add(value));
+            allValues = Array.from(hierarchyValues);
+        }
+        else {
+            allValues = [...values];
+        }
+        const valueMap = new Map(allValues.map((name) => [name, { name }]));
+        if (hierarchy) {
+            for (const [valueName, parentName] of Object.entries(hierarchy)) {
+                const value = valueMap.get(valueName);
+                if (!value) {
+                    errors.addMessage(`${valueName}: invalid literal value.`);
+                    continue;
+                }
+                const parent = valueMap.get(parentName);
+                if (!parent) {
+                    errors.addMessage(`${valueName}: parent ${parentName} is not a valid literal value.`);
+                    continue;
+                }
+                let ancestor = parent.parent;
+                let circular = false;
+                const ancestors = [];
+                while (ancestor) {
+                    /* c8 ignore next 1 - defensive coding: complex circular reference detection intermittently missed */
+                    ancestors.push(ancestor.name);
+                    /* c8 ignore next 1 - defensive coding: ancestor.parent === value is very difficult to reach */
+                    if (ancestor.parent === parent || ancestor.parent === value) {
+                        /* c8 ignore next 3 - defensive coding: circular reference error reporting intermittently missed */
+                        errors.addMessage(`${valueName}: Circular reference detected: ${ancestors.join('->')}`);
+                        circular = true;
+                        break;
+                    }
+                    ancestor = ancestor.parent;
+                }
+                /* c8 ignore next 2 - defensive coding: circular reference handling intermittently missed */
+                if (circular) {
+                    continue;
+                }
+                value.parent = parent;
+                if (parent.children) {
+                    parent.children.push(value.name);
+                }
+                else {
+                    parent.children = [value.name];
+                }
+            }
+        }
+        return errors.returnOrReport((0, ts_utils_1.succeed)(valueMap));
+    }
+}
+exports.LiteralValueHierarchy = LiteralValueHierarchy;
+//# sourceMappingURL=literalValueHierarchy.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"literalValueHierarchy.js","sourceRoot":"","sources":["../../../src/packlets/qualifier-types/literalValueHierarchy.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;;;AAEH,4CAAwF;AACxF,sCAQmB;AA4CnB;;;;;;;;;;;;;;GAcG;AACH,MAAa,qBAAqB;IAahC,YAAsB,MAA6C;QACjE,MAAM,MAAM,GAAG,qBAAqB,CAAC,yBAAyB,CAAC,MAAM,CAAC,CAAC;QACvE,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC,OAAO,EAAE,CAAC;QAC/B,IAAI,CAAC,YAAY,GAAG,CAAC,MAAM,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC,CAAC;IACnE,CAAC;IAED;;;;;OAKG;IACI,MAAM,CAAC,MAAM,CAClB,MAA6C;QAE7C,OAAO,IAAA,wBAAa,EAAC,GAAG,EAAE,CAAC,IAAI,qBAAqB,CAAC,MAAM,CAAC,CAAC,CAAC;IAChE,CAAC;IAED;;;;OAIG;IACI,QAAQ,CAAC,KAAQ;QACtB,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;IAChC,CAAC;IAED;;;OAGG;IACI,QAAQ;QACb,OAAO,IAAA,kBAAO,EACZ,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;aAC7B,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;aACxB,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CACtB,CAAC;IACJ,CAAC;IAED;;;;;OAKG;IACI,YAAY,CAAC,KAAQ;QAC1B,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACvC,wFAAwF;QACxF,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,OAAO,IAAA,eAAI,EAAC,GAAG,KAAK,0BAA0B,CAAC,CAAC;QAClD,CAAC;QAED,MAAM,SAAS,GAAQ,EAAE,CAAC;QAC1B,IAAI,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC;QAE9B,OAAO,QAAQ,EAAE,CAAC;YAChB,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;YAC9B,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC;QAC7B,CAAC;QAED,OAAO,IAAA,kBAAO,EAAC,SAAS,CAAC,CAAC;IAC5B,CAAC;IAED;;;;;OAKG;IACI,cAAc,CAAC,KAAQ;QAC5B,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;QACvC,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,OAAO,IAAA,eAAI,EAAC,GAAG,KAAK,0BAA0B,CAAC,CAAC;QAClD,CAAC;QAED,MAAM,WAAW,GAAQ,EAAE,CAAC;QAC5B,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;YACrB,KAAK,MAAM,SAAS,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;gBACzC,WAAW,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;gBAC5B,MAAM,gBAAgB,GAAG,IAAI,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;gBACxD,IAAI,gBAAgB,CAAC,SAAS,EAAE,EAAE,CAAC;oBACjC,WAAW,CAAC,IAAI,CAAC,GAAG,gBAAgB,CAAC,KAAK,CAAC,CAAC;gBAC9C,CAAC;YACH,CAAC;QACH,CAAC;QAED,OAAO,IAAA,kBAAO,EAAC,WAAW,CAAC,CAAC;IAC9B,CAAC;IAqBM,KAAK,CAAC,SAAiB,EAAE,OAAe,EAAE,UAA8B;;QAC7E,6DAA6D;QAC7D,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,CAAC;YACvB,kEAAkE;YAClE,wFAAwF;YACxF,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,SAAc,CAAC,EAAE,CAAC;gBACrC,OAAO,gBAAO,CAAC;YACjB,CAAC;YACD,wFAAwF;YACxF,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,OAAY,CAAC,EAAE,CAAC;gBACnC,OAAO,gBAAO,CAAC;YACjB,CAAC;QACH,CAAC;QAED,IAAK,SAAoB,KAAM,OAAkB,EAAE,CAAC;YAClD,OAAO,qBAAY,CAAC;QACtB,CAAC;QAED,6EAA6E;QAC7E,4BAA4B;QAC5B,MAAM,MAAM,GAA+C,IAAI,CAAC,MAAM,CAAC;QACvE,8CAA8C;QAC9C,IAAI,KAAK,GAAG,MAAA,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,0CAAE,MAAM,CAAC;QACxC,wFAAwF;QACxF,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,OAAO,gBAAO,CAAC;QACjB,CAAC;QACD,IAAI,KAAK,GAAG,qBAAsB,CAAC;QACnC,OAAO,KAAK,EAAE,CAAC;YACb,KAAK,IAAI,GAAG,CAAC;YACb,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;gBAC7B,OAAO,gBAAgB,CAAC,mBAAmB,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,gBAAO,CAAC,CAAC;YAChF,CAAC;YACD,KAAK,GAAG,KAAK,CAAC,MAAM,CAAC;QACvB,CAAC;QACD,OAAO,gBAAO,CAAC;IACjB,CAAC;IAES,MAAM,CAAC,yBAAyB,CACxC,MAA6C;;QAE7C,MAAM,MAAM,GAAG,IAAI,4BAAiB,EAAE,CAAC;QACvC,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC;QAC7B,MAAM,SAAS,GAAG,MAAA,MAAM,CAAC,SAAS,mCAAI,EAAE,CAAC;QAEzC,mEAAmE;QACnE,IAAI,SAAc,CAAC;QACnB,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACnC,MAAM,eAAe,GAAG,IAAI,GAAG,EAAK,CAAC;YACrC,6CAA6C;YAC7C,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,eAAe,CAAC,GAAG,CAAC,GAAQ,CAAC,CAAC,CAAC;YACvE,MAAM,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,eAAe,CAAC,GAAG,CAAC,KAAU,CAAC,CAAC,CAAC;YAC7E,SAAS,GAAG,KAAK,CAAC,IAAI,CAAC,eAAe,CAAC,CAAC;QAC1C,CAAC;aAAM,CAAC;YACN,SAAS,GAAG,CAAC,GAAG,MAAM,CAAC,CAAC;QAC1B,CAAC;QAED,MAAM,QAAQ,GAAG,IAAI,GAAG,CAA6B,SAAS,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC;QAEhG,IAAI,SAAS,EAAE,CAAC;YACd,KAAK,MAAM,CAAC,SAAS,EAAE,UAAU,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC;gBAChE,MAAM,KAAK,GAAG,QAAQ,CAAC,GAAG,CAAC,SAAc,CAAC,CAAC;gBAC3C,IAAI,CAAC,KAAK,EAAE,CAAC;oBACX,MAAM,CAAC,UAAU,CAAC,GAAG,SAAS,0BAA0B,CAAC,CAAC;oBAC1D,SAAS;gBACX,CAAC;gBAED,MAAM,MAAM,GAAG,QAAQ,CAAC,GAAG,CAAC,UAAe,CAAC,CAAC;gBAC7C,IAAI,CAAC,MAAM,EAAE,CAAC;oBACZ,MAAM,CAAC,UAAU,CAAC,GAAG,SAAS,YAAY,UAAU,gCAAgC,CAAC,CAAC;oBACtF,SAAS;gBACX,CAAC;gBAED,IAAI,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC;gBAC7B,IAAI,QAAQ,GAAG,KAAK,CAAC;gBACrB,MAAM,SAAS,GAAQ,EAAE,CAAC;gBAE1B,OAAO,QAAQ,EAAE,CAAC;oBAChB,qGAAqG;oBACrG,SAAS,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;oBAC9B,+FAA+F;oBAC/F,IAAI,QAAQ,CAAC,MAAM,KAAK,MAAM,IAAI,QAAQ,CAAC,MAAM,KAAK,KAAK,EAAE,CAAC;wBAC5D,mGAAmG;wBACnG,MAAM,CAAC,UAAU,CAAC,GAAG,SAAS,kCAAkC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;wBACxF,QAAQ,GAAG,IAAI,CAAC;wBAChB,MAAM;oBACR,CAAC;oBACD,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC;gBAC7B,CAAC;gBAED,4FAA4F;gBAC5F,IAAI,QAAQ,EAAE,CAAC;oBACb,SAAS;gBACX,CAAC;gBAED,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC;gBACtB,IAAI,MAAM,CAAC,QAAQ,EAAE,CAAC;oBACpB,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;gBACnC,CAAC;qBAAM,CAAC;oBACN,MAAM,CAAC,QAAQ,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;gBACjC,CAAC;YACH,CAAC;QACH,CAAC;QAED,OAAO,MAAM,CAAC,cAAc,CAAC,IAAA,kBAAO,EAAC,QAAQ,CAAC,CAAC,CAAC;IAClD,CAAC;CACF;AAnOD,sDAmOC","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 { captureResult, MessageAggregator, Result, succeed, fail } from '@fgv/ts-utils';\nimport {\n  ConditionOperator,\n  NoMatch,\n  PerfectMatch,\n  QualifierConditionValue,\n  QualifierContextValue,\n  QualifierMatchScore,\n  Convert as CommonConverters\n} from '../common';\n\n/**\n * Declares a hierarchy of literal values. The keys are the names of the values, and the\n * values are the names of their parents.\n * @remarks\n * The hierarchy is defined as a tree, where each value can have multiple children but\n * only one parent. The root of the tree has no parent. The hierarchy is used to\n * determine the relationship between values when matching conditions and contexts.\n * @public\n */\nexport type LiteralValueHierarchyDecl<T extends string> = Partial<Record<T, T>>;\n\n/**\n * Describes a single valid literal value including optional parent and child values.\n * @public\n */\nexport interface ILiteralValue<T extends string> {\n  readonly name: T;\n  readonly parent?: ILiteralValue<T>;\n  readonly children?: ReadonlyArray<T>;\n}\n\n/**\n * Describes the parameters used to create a new\n * {@link QualifierTypes.LiteralValueHierarchy | LiteralValueHierarchy}.\n * @public\n */\nexport interface ILiteralValueHierarchyCreateParams<T extends string = string> {\n  values: ReadonlyArray<T>;\n  hierarchy?: LiteralValueHierarchyDecl<T>;\n}\n\n/**\n * Internal interface used during hierarchy construction to build\n * {@link QualifierTypes.ILiteralValue | ILiteralValue} objects.\n * @public\n */\ninterface ILiteralValueBuilder<T extends string> {\n  readonly name: T;\n  parent?: ILiteralValue<T>;\n  children?: T[];\n}\n\n/**\n * A class that implements a hierarchy of literal values. The hierarchy is defined as a\n * tree, where each value can have multiple children but only one parent. The root of the\n * tree has no parent. The hierarchy is used to determine the relationship between values\n * when matching conditions and contexts.\n *\n * @remarks\n * The hierarchy can be created in two modes:\n * - **Constrained mode**: When enumerated values are provided, only those values are allowed\n *   in the hierarchy and matching operations.\n * - **Open values mode**: When no enumerated values are provided, all values referenced in\n *   the hierarchy are automatically collected and used. This allows for flexible hierarchies\n *   where any value can be used in matching operations.\n * @public\n */\nexport class LiteralValueHierarchy<T extends string = string> {\n  /**\n   * A map of all allowed literal values to the corresponding\n   * {@link QualifierTypes.ILiteralValue | ILiteralValue} validated definition.\n   */\n  public readonly values: ReadonlyMap<T, ILiteralValue<T>>;\n\n  /**\n   * Indicates whether this hierarchy was created with open values (no enumerated values\n   * provided), allowing any value to be used in matching operations.\n   */\n  public readonly isOpenValues: boolean;\n\n  protected constructor(params: ILiteralValueHierarchyCreateParams<T>) {\n    const result = LiteralValueHierarchy._buildValuesFromHierarchy(params);\n    this.values = result.orThrow();\n    this.isOpenValues = !params.values || params.values.length === 0;\n  }\n\n  /**\n   * Creates a new {@link QualifierTypes.LiteralValueHierarchy | LiteralValueHierarchy} instance.\n   * @param params - The {@link QualifierTypes.ILiteralValueHierarchyCreateParams | parameters}\n   * used to create the hierarchy.\n   * @returns `Success` with the new hierarchy or `Failure` with an error message.\n   */\n  public static create<T extends string>(\n    params: ILiteralValueHierarchyCreateParams<T>\n  ): Result<LiteralValueHierarchy<T>> {\n    return captureResult(() => new LiteralValueHierarchy(params));\n  }\n\n  /**\n   * Checks if a value exists in the hierarchy.\n   * @param value - The value to check.\n   * @returns `true` if the value exists in the hierarchy, `false` otherwise.\n   */\n  public hasValue(value: T): boolean {\n    return this.values.has(value);\n  }\n\n  /**\n   * Gets all root values (values with no parent) in the hierarchy.\n   * @returns `Success` with an array of root values.\n   */\n  public getRoots(): Result<T[]> {\n    return succeed(\n      Array.from(this.values.values())\n        .filter((v) => !v.parent)\n        .map((v) => v.name)\n    );\n  }\n\n  /**\n   * Gets all ancestors of a value in the hierarchy.\n   * @param value - The value to get ancestors for.\n   * @returns `Success` with an array of ancestor values, ordered from immediate parent\n   * to root, or `Failure` if the value is not in the hierarchy.\n   */\n  public getAncestors(value: T): Result<T[]> {\n    const current = this.values.get(value);\n    /* c8 ignore next 2 - functional error case tested but coverage intermittently missed */\n    if (!current) {\n      return fail(`${value}: not found in hierarchy`);\n    }\n\n    const ancestors: T[] = [];\n    let ancestor = current.parent;\n\n    while (ancestor) {\n      ancestors.push(ancestor.name);\n      ancestor = ancestor.parent;\n    }\n\n    return succeed(ancestors);\n  }\n\n  /**\n   * Gets all descendants of a value in the hierarchy.\n   * @param value - The value to get descendants for.\n   * @returns `Success` with an array of descendant values, or `Failure` if the value\n   * is not in the hierarchy.\n   */\n  public getDescendants(value: T): Result<T[]> {\n    const current = this.values.get(value);\n    if (!current) {\n      return fail(`${value}: not found in hierarchy`);\n    }\n\n    const descendants: T[] = [];\n    if (current.children) {\n      for (const childName of current.children) {\n        descendants.push(childName);\n        const childDescendants = this.getDescendants(childName);\n        if (childDescendants.isSuccess()) {\n          descendants.push(...childDescendants.value);\n        }\n      }\n    }\n\n    return succeed(descendants);\n  }\n\n  public match(condition: T, context: T): QualifierMatchScore;\n  /**\n   * Matches a condition value against a context value, where an exact match of the\n   * condition and context returns {@link PerfectMatch | PerfectMatch}, a condition\n   * value that does not match the context value or any of its ancestors returns\n   * {@link NoMatch | NoMatch}, and a condition value that matches the context value\n   * or any of its ancestors returns a positive score that is less than\n   * {@link PerfectMatch | PerfectMatch}, with the score decreasing with each ancestor\n   * in the hierarchy.\n   * @param condition - The condition value to match.\n   * @param context - The context value to match against.\n   * @param __operator - The operator used for matching (not used in this implementation).\n   * @returns A {@link QualifierMatchScore | QualifierMatchScore} indicating the match score.\n   */\n  public match(\n    condition: QualifierConditionValue,\n    context: QualifierContextValue,\n    __operator?: ConditionOperator\n  ): QualifierMatchScore;\n  public match(condition: string, context: string, __operator?: ConditionOperator): QualifierMatchScore {\n    // For open hierarchies, skip validation and allow any values\n    if (!this.isOpenValues) {\n      // Validate that both condition and context exist in the hierarchy\n      /* c8 ignore next 2 - functional error case tested but coverage intermittently missed */\n      if (!this.values.has(condition as T)) {\n        return NoMatch;\n      }\n      /* c8 ignore next 2 - functional error case tested but coverage intermittently missed */\n      if (!this.values.has(context as T)) {\n        return NoMatch;\n      }\n    }\n\n    if ((condition as string) === (context as string)) {\n      return PerfectMatch;\n    }\n\n    // For open hierarchies, if values aren't in the hierarchy, treat as no match\n    // but don't fail validation\n    const values: ReadonlyMap<string, ILiteralValue<string>> = this.values;\n    /* c8 ignore next 1 - ? is defense in depth */\n    let value = values.get(context)?.parent;\n    /* c8 ignore next 2 - functional error case tested but coverage intermittently missed */\n    if (!value) {\n      return NoMatch;\n    }\n    let score = PerfectMatch as number;\n    while (value) {\n      score *= 0.9;\n      if (value.name === condition) {\n        return CommonConverters.qualifierMatchScore.convert(score).orDefault(NoMatch);\n      }\n      value = value.parent;\n    }\n    return NoMatch;\n  }\n\n  protected static _buildValuesFromHierarchy<T extends string>(\n    params: ILiteralValueHierarchyCreateParams<T>\n  ): Result<ReadonlyMap<T, ILiteralValue<T>>> {\n    const errors = new MessageAggregator();\n    const values = params.values;\n    const hierarchy = params.hierarchy ?? {};\n\n    // If no values are provided, collect all values from the hierarchy\n    let allValues: T[];\n    if (!values || values.length === 0) {\n      const hierarchyValues = new Set<T>();\n      // Add all keys and values from the hierarchy\n      Object.keys(hierarchy).forEach((key) => hierarchyValues.add(key as T));\n      Object.values(hierarchy).forEach((value) => hierarchyValues.add(value as T));\n      allValues = Array.from(hierarchyValues);\n    } else {\n      allValues = [...values];\n    }\n\n    const valueMap = new Map<T, ILiteralValueBuilder<T>>(allValues.map((name) => [name, { name }]));\n\n    if (hierarchy) {\n      for (const [valueName, parentName] of Object.entries(hierarchy)) {\n        const value = valueMap.get(valueName as T);\n        if (!value) {\n          errors.addMessage(`${valueName}: invalid literal value.`);\n          continue;\n        }\n\n        const parent = valueMap.get(parentName as T);\n        if (!parent) {\n          errors.addMessage(`${valueName}: parent ${parentName} is not a valid literal value.`);\n          continue;\n        }\n\n        let ancestor = parent.parent;\n        let circular = false;\n        const ancestors: T[] = [];\n\n        while (ancestor) {\n          /* c8 ignore next 1 - defensive coding: complex circular reference detection intermittently missed */\n          ancestors.push(ancestor.name);\n          /* c8 ignore next 1 - defensive coding: ancestor.parent === value is very difficult to reach */\n          if (ancestor.parent === parent || ancestor.parent === value) {\n            /* c8 ignore next 3 - defensive coding: circular reference error reporting intermittently missed */\n            errors.addMessage(`${valueName}: Circular reference detected: ${ancestors.join('->')}`);\n            circular = true;\n            break;\n          }\n          ancestor = ancestor.parent;\n        }\n\n        /* c8 ignore next 2 - defensive coding: circular reference handling intermittently missed */\n        if (circular) {\n          continue;\n        }\n\n        value.parent = parent;\n        if (parent.children) {\n          parent.children.push(value.name);\n        } else {\n          parent.children = [value.name];\n        }\n      }\n    }\n\n    return errors.returnOrReport(succeed(valueMap));\n  }\n}\n"]}

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

@@ -23,15 +23,17 @@ export interface IQualifierType extends ICollectible<QualifierTypeName, Qualifie
     /**
      * Validates a condition value for this qualifier type.
      * @param value - The string value to validate.
-     * @returns `Success` with the {@link QualifierConditionValue | validated value} if the value
-     * is valid for use in a condition, `Failure` with error details otherwise.
+     * @returns `Success` with the {@link QualifierConditionValue | validated value}
+     * if the value is valid for use in a condition, `Failure` with error details
+     * otherwise.
      */
     isValidConditionValue(value: string): value is QualifierConditionValue;
     /**
      * Validates a context value for this qualifier type.
      * @param value - The string value to validate.
-     * @returns `Success` with the {@link QualifierContextValue | validated value} if the value
-     * is valid for use in a runtime context, `Failure` with error details otherwise.
+     * @returns `Success` with the {@link QualifierContextValue | validated value}
+     * if the value is valid for use in a runtime context, `Failure` with error
+     * details otherwise.
      */
     isValidContextValue(value: string): value is QualifierContextValue;
     /**
@@ -42,24 +44,26 @@ export interface IQualifierType extends ICollectible<QualifierTypeName, Qualifie
      */
     validateCondition(value: string, operator?: ConditionOperator): Result<QualifierConditionValue>;
     /**
-     * Validates that a value is valid for use in a runtime context for qualifiers of this type.
+     * Validates that a value is valid for use in a runtime context for qualifiers
+     * of this type.
      * @param value - The string value to validate.
-     * @returns `Success` with the {@link QualifierContextValue | validated value} if the value
-     * is valid for use in a runtime context, `Failure` with error details otherwise.
+     * @returns `Success` with the {@link QualifierContextValue | validated value}
+     * if the value is valid for use in a runtime context, `Failure` with error
+     * details otherwise.
      */
     validateContextValue(value: string): Result<QualifierContextValue>;
     /**
-     * Determines the extent to which a condition matches a context value for this qualifier type.
+     * Determines the extent to which a condition matches a context value for this
+     * qualifier type.
      * @param condition - The condition value to evaluate.
      * @param context - The context value to evaluate.
      * @param operator - The operator to use in evaluating the match.
-     * @returns a {@link QualifierMatchScore | score} indicating the extent to which the condition
-     * matches the context value.
+     * @returns a {@link QualifierMatchScore | score} indicating the extent to which
+     * the condition matches the context value.
      */
     matches(condition: QualifierConditionValue, context: QualifierContextValue, operator: ConditionOperator): QualifierMatchScore;
     /**
-     * Sets the index for this qualifier type.  Once set, index is
-     * immutable.
+     * Sets the index for this qualifier type. Once set, index is immutable.
      */
     setIndex(index: number): Result<QualifierTypeIndex>;
 }
@@ -157,8 +161,8 @@ export declare abstract class QualifierType implements IQualifierType {
      * @param condition - The {@link QualifierConditionValue | condition value} to match.
      * @param context - The {@link QualifierContextValue | context value} to match.
      * @param operator - The {@link ConditionOperator | operator} to use in the match.
-     * @returns a {@link QualifierMatchScore | score} indicating the extent to which the condition
-     * matches the context value.
+     * @returns a {@link QualifierMatchScore | score} indicating the extent to which
+     * the condition matches the context value.
      * @public
      */
     protected abstract _matchOne(condition: QualifierConditionValue, context: QualifierContextValue, operator: ConditionOperator): QualifierMatchScore;
@@ -167,14 +171,14 @@ export declare abstract class QualifierType implements IQualifierType {
      * @param condition - The {@link QualifierConditionValue | condition value} to match.
      * @param context - The comma-separated list of {@link QualifierContextValue | context values} to match.
      * @param operator - The {@link ConditionOperator | operator} to use in the match.
-     * @returns a {@link QualifierMatchScore | score} indicating the extent to which the condition
-     * matches the context value.
+     * @returns a {@link QualifierMatchScore | score} indicating the extent to which
+     * the condition matches the context value.
      * @public
      */
     protected _matchList(condition: QualifierConditionValue, context: QualifierContextValue[], operator: ConditionOperator): QualifierMatchScore;
     /**
-     * Splits a comma-separated {@link QualifierContextValue | context value} into an array of
-     * individual values.
+     * Splits a comma-separated {@link QualifierContextValue | context value} into an
+     * array of individual values.
      * @param value - The value to split.
      * @returns an array of individual context values.
      * @public

package/lib/packlets/qualifier-types/qualifierType.d.ts.map

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