@fgv/ts-res 4.5.0-3 → 5.0.0-10

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

@@ -1,6 +1,8 @@
 import { Result } from '@fgv/ts-utils';
-import { QualifierConditionValue, QualifierContextValue, QualifierMatchScore } from '../common';
+import { QualifierConditionValue, QualifierContextValue, QualifierMatchScore, ConditionOperator } from '../common';
 import { QualifierType } from './qualifierType';
+import { LiteralValueHierarchy, LiteralValueHierarchyDecl } from './literalValueHierarchy';
+import * as Config from './config';
 /**
  * Parameters used to create a new {@link QualifierTypes.TerritoryQualifierType | TerritoryQualifierType} instance.
  * @public
@@ -22,10 +24,20 @@ export interface ITerritoryQualifierTypeCreateParams {
      * Optional array enumerating allowed territories to further constrain the type.
      */
     allowedTerritories?: string[];
+    /**
+     * Flag indicating whether the qualifier type should accept lowercase territory codes.
+     * Defaults to `false`.
+     */
+    acceptLowercase?: boolean;
+    /**
+     * Optional {@link QualifierTypes.LiteralValueHierarchyDecl | hierarchy declaration}
+     * of territory values to use for matching. If not provided, no hierarchy will be used.
+     */
+    hierarchy?: LiteralValueHierarchyDecl<string>;
 }
 /**
  * Qualifier type for territory values. Territories are two-letter ISO-3166-2
- * Alpha-2 country codes.  Canonical territory codes are uppercase, but this
+ * Alpha-2 country codes. Canonical territory codes are uppercase, but this
  * implementation handles incorrect casing.
  * @public
  */
@@ -34,41 +46,65 @@ export declare class TerritoryQualifierType extends QualifierType {
      * Optional array enumerating allowed territories to further constrain the type.
      */
     readonly allowedTerritories?: ReadonlyArray<QualifierConditionValue>;
+    /**
+     * Flag indicating whether the qualifier type should accept lowercase territory codes.
+     * Defaults to `false`.
+     */
+    readonly acceptLowercase: boolean;
+    /**
+     * Optional {@link QualifierTypes.LiteralValueHierarchy | hierarchy} of territory
+     * values to use for matching. If not provided, no hierarchy will be used.
+     */
+    readonly hierarchy?: LiteralValueHierarchy<string>;
     /**
      * Creates a new {@link QualifierTypes.TerritoryQualifierType | TerritoryQualifierType} instance.
      * @public
      */
-    protected constructor({ allowedTerritories, allowContextList, name, index }: ITerritoryQualifierTypeCreateParams);
+    protected constructor({ acceptLowercase, allowedTerritories, allowContextList, name, index, hierarchy }: ITerritoryQualifierTypeCreateParams);
     /**
      * {@inheritdoc QualifierTypes.QualifierType.isValidConditionValue}
      */
     isValidConditionValue(value: string): value is QualifierConditionValue;
     /**
      * Creates a new {@link QualifierTypes.TerritoryQualifierType | TerritoryQualifierType} instance.
-     * @param params - Optional {@link QualifierTypes.ITerritoryQualifierTypeCreateParams | parameters} to use
-     * when creating the instance.
-     * @returns `Success` with the new {@link QualifierTypes.TerritoryQualifierType | TerritoryQualifierType} if successful,
-     * `Failure` with an error message otherwise.
+     * @param params - Optional {@link QualifierTypes.ITerritoryQualifierTypeCreateParams | parameters}
+     * to use when creating the instance.
+     * @returns `Success` with the new {@link QualifierTypes.TerritoryQualifierType | TerritoryQualifierType}
+     * if successful, `Failure` with an error message otherwise.
      * @public
      */
     static create(params?: ITerritoryQualifierTypeCreateParams): Result<TerritoryQualifierType>;
+    /**
+     * Creates a new {@link QualifierTypes.TerritoryQualifierType | TerritoryQualifierType} from a configuration object.
+     * @param config - The {@link QualifierTypes.Config.IQualifierTypeConfig | configuration object} containing
+     * the name, systemType, and optional territory-specific configuration including allowed territories and hierarchy.
+     * @returns `Success` with the new {@link QualifierTypes.TerritoryQualifierType | TerritoryQualifierType}
+     * if successful, `Failure` with an error message otherwise.
+     * @public
+     */
+    static createFromConfig(config: Config.IQualifierTypeConfig<Config.ITerritoryQualifierTypeConfig>): Result<TerritoryQualifierType>;
     /**
      * {@inheritdoc QualifierTypes.QualifierType._matchOne}
      */
-    protected _matchOne(condition: QualifierConditionValue, context: QualifierContextValue): QualifierMatchScore;
+    protected _matchOne(condition: QualifierConditionValue, context: QualifierContextValue, __operator?: ConditionOperator): QualifierMatchScore;
     /**
      * Determines whether a value is a valid condition value for a territory qualifier.
      * @param value - The value to validate.
+     * @param acceptLowercase - Flag indicating whether the qualifier type should accept lowercase territory codes.
+     * Defaults to `false`.
      * @returns `true` if the value is a valid condition value, `false` otherwise.
      * @public
      */
-    static isValidTerritoryConditionValue(value: string): value is QualifierConditionValue;
+    static isValidTerritoryConditionValue(value: string, acceptLowercase?: boolean): value is QualifierConditionValue;
     /**
      * Converts a string value to a territory condition value.
      * @param value - The value to convert.
-     * @returns `Success` with the converted value if successful, `Failure` with an error message otherwise.
+     * @param acceptLowercase - Flag indicating whether the qualifier type should accept lowercase territory codes.
+     * Defaults to `false`.
+     * @returns `Success` with the converted value if successful, `Failure` with an error
+     * message otherwise.
      * @public
      */
-    static toTerritoryConditionValue(value: string): Result<QualifierConditionValue>;
+    static toTerritoryConditionValue(value: string, acceptLowercase?: boolean): Result<QualifierConditionValue>;
 }
 //# sourceMappingURL=territoryQualifierType.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"territoryQualifierType.d.ts","sourceRoot":"","sources":["../../../src/packlets/qualifier-types/territoryQualifierType.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAiB,MAAM,EAA6B,MAAM,eAAe,CAAC;AACjF,OAAO,EAIL,uBAAuB,EACvB,qBAAqB,EACrB,mBAAmB,EAEpB,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAEhD;;;GAGG;AACH,MAAM,WAAW,mCAAmC;IAClD;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAE3B;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC/B;AAED;;;;;GAKG;AACH,qBAAa,sBAAuB,SAAQ,aAAa;IACvD;;OAEG;IACH,SAAgB,kBAAkB,CAAC,EAAE,aAAa,CAAC,uBAAuB,CAAC,CAAC;IAE5E;;;OAGG;IACH,SAAS,aAAa,EACpB,kBAAkB,EAClB,gBAAgB,EAChB,IAAI,EACJ,KAAK,EACN,EAAE,mCAAmC;IAoBtC;;OAEG;IACI,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,uBAAuB;IAY7E;;;;;;;OAOG;WACW,MAAM,CAAC,MAAM,CAAC,EAAE,mCAAmC,GAAG,MAAM,CAAC,sBAAsB,CAAC;IAMlG;;OAEG;IACH,SAAS,CAAC,SAAS,CACjB,SAAS,EAAE,uBAAuB,EAClC,OAAO,EAAE,qBAAqB,GAC7B,mBAAmB;IAOtB;;;;;OAKG;WACW,8BAA8B,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,uBAAuB;IAI7F;;;;;OAKG;WACW,yBAAyB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC,uBAAuB,CAAC;CAMxF"}
+{"version":3,"file":"territoryQualifierType.d.ts","sourceRoot":"","sources":["../../../src/packlets/qualifier-types/territoryQualifierType.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAiB,MAAM,EAA6B,MAAM,eAAe,CAAC;AACjF,OAAO,EAIL,uBAAuB,EACvB,qBAAqB,EACrB,mBAAmB,EAEnB,iBAAiB,EAClB,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,qBAAqB,EAAE,yBAAyB,EAAE,MAAM,yBAAyB,CAAC;AAC3F,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AAGnC;;;GAGG;AACH,MAAM,WAAW,mCAAmC;IAClD;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;OAEG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAE3B;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;IAE9B;;;OAGG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAE1B;;;OAGG;IACH,SAAS,CAAC,EAAE,yBAAyB,CAAC,MAAM,CAAC,CAAC;CAC/C;AAED;;;;;GAKG;AACH,qBAAa,sBAAuB,SAAQ,aAAa;IACvD;;OAEG;IACH,SAAgB,kBAAkB,CAAC,EAAE,aAAa,CAAC,uBAAuB,CAAC,CAAC;IAE5E;;;OAGG;IACH,SAAgB,eAAe,EAAE,OAAO,CAAC;IAEzC;;;OAGG;IACH,SAAgB,SAAS,CAAC,EAAE,qBAAqB,CAAC,MAAM,CAAC,CAAC;IAE1D;;;OAGG;IACH,SAAS,aAAa,EACpB,eAAe,EACf,kBAAkB,EAClB,gBAAgB,EAChB,IAAI,EACJ,KAAK,EACL,SAAS,EACV,EAAE,mCAAmC;IA6BtC;;OAEG;IACI,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,uBAAuB;IAY7E;;;;;;;OAOG;WACW,MAAM,CAAC,MAAM,CAAC,EAAE,mCAAmC,GAAG,MAAM,CAAC,sBAAsB,CAAC;IAMlG;;;;;;;OAOG;WACW,gBAAgB,CAC5B,MAAM,EAAE,MAAM,CAAC,oBAAoB,CAAC,MAAM,CAAC,6BAA6B,CAAC,GACxE,MAAM,CAAC,sBAAsB,CAAC;IAWjC;;OAEG;IACH,SAAS,CAAC,SAAS,CACjB,SAAS,EAAE,uBAAuB,EAClC,OAAO,EAAE,qBAAqB,EAC9B,UAAU,CAAC,EAAE,iBAAiB,GAC7B,mBAAmB;IAqBtB;;;;;;;OAOG;WACW,8BAA8B,CAC1C,KAAK,EAAE,MAAM,EACb,eAAe,CAAC,EAAE,OAAO,GACxB,KAAK,IAAI,uBAAuB;IAOnC;;;;;;;;OAQG;WACW,yBAAyB,CACrC,KAAK,EAAE,MAAM,EACb,eAAe,CAAC,EAAE,OAAO,GACxB,MAAM,CAAC,uBAAuB,CAAC;CAMnC"}

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

@@ -25,9 +25,11 @@ exports.TerritoryQualifierType = 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");
 /**
  * Qualifier type for territory values. Territories are two-letter ISO-3166-2
- * Alpha-2 country codes.  Canonical territory codes are uppercase, but this
+ * Alpha-2 country codes. Canonical territory codes are uppercase, but this
  * implementation handles incorrect casing.
  * @public
  */
@@ -36,12 +38,12 @@ class TerritoryQualifierType extends qualifierType_1.QualifierType {
      * Creates a new {@link QualifierTypes.TerritoryQualifierType | TerritoryQualifierType} instance.
      * @public
      */
-    constructor({ allowedTerritories, allowContextList, name, index }) {
+    constructor({ acceptLowercase, allowedTerritories, allowContextList, name, index, hierarchy }) {
         /* c8 ignore next 7 - coverage seems to be missing coalescing branches */
         name = name !== null && name !== void 0 ? name : 'territory';
         const validIndex = index !== undefined ? common_1.Convert.qualifierTypeIndex.convert(index).orThrow() : undefined;
         const validTerritories = allowedTerritories !== undefined
-            ? (0, ts_utils_1.mapResults)(allowedTerritories.map((t) => TerritoryQualifierType.toTerritoryConditionValue(t))).orThrow()
+            ? (0, ts_utils_1.mapResults)(allowedTerritories.map((t) => TerritoryQualifierType.toTerritoryConditionValue(t.toUpperCase()))).orThrow()
             : undefined;
         allowContextList = allowContextList === true;
         super({
@@ -50,13 +52,20 @@ class TerritoryQualifierType extends qualifierType_1.QualifierType {
             index: validIndex
         });
         this.allowedTerritories = validTerritories;
+        this.acceptLowercase = acceptLowercase === true;
+        if (hierarchy) {
+            /* c8 ignore next 5 - defensive coding: allowedTerritories ?? [] fallback enables open values mode */
+            this.hierarchy = literalValueHierarchy_1.LiteralValueHierarchy.create({
+                values: allowedTerritories !== null && allowedTerritories !== void 0 ? allowedTerritories : [],
+                hierarchy: hierarchy
+            }).orThrow();
+        }
     }
     /**
      * {@inheritdoc QualifierTypes.QualifierType.isValidConditionValue}
      */
     isValidConditionValue(value) {
-        const normalized = value.toUpperCase();
-        /* c8 ignore next 6 - definitely tested but coverage is missing it */
+        const normalized = this.acceptLowercase ? value.toUpperCase() : value;
         if (!TerritoryQualifierType.isValidTerritoryConditionValue(normalized)) {
             return false;
         }
@@ -67,10 +76,10 @@ class TerritoryQualifierType extends qualifierType_1.QualifierType {
     }
     /**
      * Creates a new {@link QualifierTypes.TerritoryQualifierType | TerritoryQualifierType} instance.
-     * @param params - Optional {@link QualifierTypes.ITerritoryQualifierTypeCreateParams | parameters} to use
-     * when creating the instance.
-     * @returns `Success` with the new {@link QualifierTypes.TerritoryQualifierType | TerritoryQualifierType} if successful,
-     * `Failure` with an error message otherwise.
+     * @param params - Optional {@link QualifierTypes.ITerritoryQualifierTypeCreateParams | parameters}
+     * to use when creating the instance.
+     * @returns `Success` with the new {@link QualifierTypes.TerritoryQualifierType | TerritoryQualifierType}
+     * if successful, `Failure` with an error message otherwise.
      * @public
      */
     static create(params) {
@@ -78,33 +87,68 @@ class TerritoryQualifierType extends qualifierType_1.QualifierType {
         params = params !== null && params !== void 0 ? params : {};
         return (0, ts_utils_1.captureResult)(() => new TerritoryQualifierType(params));
     }
+    /**
+     * Creates a new {@link QualifierTypes.TerritoryQualifierType | TerritoryQualifierType} from a configuration object.
+     * @param config - The {@link QualifierTypes.Config.IQualifierTypeConfig | configuration object} containing
+     * the name, systemType, and optional territory-specific configuration including allowed territories and hierarchy.
+     * @returns `Success` with the new {@link QualifierTypes.TerritoryQualifierType | TerritoryQualifierType}
+     * if successful, `Failure` with an error message otherwise.
+     * @public
+     */
+    static createFromConfig(config) {
+        var _a;
+        const territoryConfig = (_a = config.configuration) !== null && _a !== void 0 ? _a : {};
+        return (0, ts_json_base_1.sanitizeJsonObject)({
+            name: config.name,
+            allowContextList: territoryConfig.allowContextList === true,
+            allowedTerritories: territoryConfig.allowedTerritories,
+            acceptLowercase: territoryConfig.acceptLowercase === true,
+            hierarchy: territoryConfig.hierarchy
+        }).onSuccess(TerritoryQualifierType.create);
+    }
     /**
      * {@inheritdoc QualifierTypes.QualifierType._matchOne}
      */
-    _matchOne(condition, context) {
-        if (this.isValidConditionValue(condition) && condition.toUpperCase() === context.toUpperCase()) {
-            return common_1.PerfectMatch;
+    _matchOne(condition, context, __operator) {
+        if (this.isValidConditionValue(condition) && this.isValidContextValue(context)) {
+            // Normalize to uppercase for territory codes
+            const normalizedCondition = condition.toUpperCase();
+            const normalizedContext = context.toUpperCase();
+            if (normalizedCondition === normalizedContext) {
+                return common_1.PerfectMatch;
+            }
+            if (this.hierarchy) {
+                return this.hierarchy.match(normalizedCondition, normalizedContext, __operator);
+            }
         }
         return common_1.NoMatch;
     }
     /**
      * Determines whether a value is a valid condition value for a territory qualifier.
      * @param value - The value to validate.
+     * @param acceptLowercase - Flag indicating whether the qualifier type should accept lowercase territory codes.
+     * Defaults to `false`.
      * @returns `true` if the value is a valid condition value, `false` otherwise.
      * @public
      */
-    static isValidTerritoryConditionValue(value) {
-        return common_1.Validate.RegularExpressions.territoryCode.test(value);
+    static isValidTerritoryConditionValue(value, acceptLowercase) {
+        if (acceptLowercase !== true && value !== value.toUpperCase()) {
+            return false;
+        }
+        return common_1.Validate.RegularExpressions.territoryCode.test(value.toUpperCase());
     }
     /**
      * Converts a string value to a territory condition value.
      * @param value - The value to convert.
-     * @returns `Success` with the converted value if successful, `Failure` with an error message otherwise.
+     * @param acceptLowercase - Flag indicating whether the qualifier type should accept lowercase territory codes.
+     * Defaults to `false`.
+     * @returns `Success` with the converted value if successful, `Failure` with an error
+     * message otherwise.
      * @public
      */
-    static toTerritoryConditionValue(value) {
+    static toTerritoryConditionValue(value, acceptLowercase) {
         const normalized = value.toUpperCase();
-        return TerritoryQualifierType.isValidTerritoryConditionValue(normalized)
+        return TerritoryQualifierType.isValidTerritoryConditionValue(normalized, acceptLowercase)
             ? (0, ts_utils_1.succeed)(normalized)
             : (0, ts_utils_1.fail)(`${value}: not a valid territory code`);
     }

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

@@ -1 +1 @@
-{"version":3,"file":"territoryQualifierType.js","sourceRoot":"","sources":["../../../src/packlets/qualifier-types/territoryQualifierType.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;;;AAEH,4CAAiF;AACjF,sCAQmB;AACnB,mDAAgD;AA4BhD;;;;;GAKG;AACH,MAAa,sBAAuB,SAAQ,6BAAa;IAMvD;;;OAGG;IACH,YAAsB,EACpB,kBAAkB,EAClB,gBAAgB,EAChB,IAAI,EACJ,KAAK,EAC+B;QACpC,yEAAyE;QACzE,IAAI,GAAG,IAAI,aAAJ,IAAI,cAAJ,IAAI,GAAI,WAAW,CAAC;QAC3B,MAAM,UAAU,GAAG,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,gBAAO,CAAC,kBAAkB,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;QACzG,MAAM,gBAAgB,GACpB,kBAAkB,KAAK,SAAS;YAC9B,CAAC,CAAC,IAAA,qBAAU,EACR,kBAAkB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,sBAAsB,CAAC,yBAAyB,CAAC,CAAC,CAAC,CAAC,CACnF,CAAC,OAAO,EAAE;YACb,CAAC,CAAC,SAAS,CAAC;QAEhB,gBAAgB,GAAG,gBAAgB,KAAK,IAAI,CAAC;QAC7C,KAAK,CAAC;YACJ,IAAI,EAAE,IAAI;YACV,gBAAgB;YAChB,KAAK,EAAE,UAAU;SAClB,CAAC,CAAC;QACH,IAAI,CAAC,kBAAkB,GAAG,gBAAgB,CAAC;IAC7C,CAAC;IAED;;OAEG;IACI,qBAAqB,CAAC,KAAa;QACxC,MAAM,UAAU,GAAG,KAAK,CAAC,WAAW,EAAE,CAAC;QACvC,qEAAqE;QACrE,IAAI,CAAC,sBAAsB,CAAC,8BAA8B,CAAC,UAAU,CAAC,EAAE,CAAC;YACvE,OAAO,KAAK,CAAC;QACf,CAAC;QACD,IAAI,IAAI,CAAC,kBAAkB,KAAK,SAAS,EAAE,CAAC;YAC1C,OAAO,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;QACtD,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;;OAOG;IACI,MAAM,CAAC,MAAM,CAAC,MAA4C;QAC/D,2EAA2E;QAC3E,MAAM,GAAG,MAAM,aAAN,MAAM,cAAN,MAAM,GAAI,EAAE,CAAC;QACtB,OAAO,IAAA,wBAAa,EAAC,GAAG,EAAE,CAAC,IAAI,sBAAsB,CAAC,MAAM,CAAC,CAAC,CAAC;IACjE,CAAC;IAED;;OAEG;IACO,SAAS,CACjB,SAAkC,EAClC,OAA8B;QAE9B,IAAI,IAAI,CAAC,qBAAqB,CAAC,SAAS,CAAC,IAAI,SAAS,CAAC,WAAW,EAAE,KAAK,OAAO,CAAC,WAAW,EAAE,EAAE,CAAC;YAC/F,OAAO,qBAAY,CAAC;QACtB,CAAC;QACD,OAAO,gBAAO,CAAC;IACjB,CAAC;IAED;;;;;OAKG;IACI,MAAM,CAAC,8BAA8B,CAAC,KAAa;QACxD,OAAO,iBAAQ,CAAC,kBAAkB,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAC/D,CAAC;IAED;;;;;OAKG;IACI,MAAM,CAAC,yBAAyB,CAAC,KAAa;QACnD,MAAM,UAAU,GAAG,KAAK,CAAC,WAAW,EAAE,CAAC;QACvC,OAAO,sBAAsB,CAAC,8BAA8B,CAAC,UAAU,CAAC;YACtE,CAAC,CAAC,IAAA,kBAAO,EAAC,UAAU,CAAC;YACrB,CAAC,CAAC,IAAA,eAAI,EAAC,GAAG,KAAK,8BAA8B,CAAC,CAAC;IACnD,CAAC;CACF;AAnGD,wDAmGC","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, Result, fail, succeed, mapResults } from '@fgv/ts-utils';\nimport {\n  Convert,\n  NoMatch,\n  PerfectMatch,\n  QualifierConditionValue,\n  QualifierContextValue,\n  QualifierMatchScore,\n  Validate\n} from '../common';\nimport { QualifierType } from './qualifierType';\n\n/**\n * Parameters used to create a new {@link QualifierTypes.TerritoryQualifierType | TerritoryQualifierType} instance.\n * @public\n */\nexport interface ITerritoryQualifierTypeCreateParams {\n  /**\n   * {@inheritdoc QualifierTypes.IQualifierTypeCreateParams.name}\n   */\n  name?: string;\n\n  /**\n   * {@inheritdoc QualifierTypes.IQualifierTypeCreateParams.allowContextList}\n   */\n  allowContextList?: boolean;\n\n  /**\n   * {@inheritdoc QualifierTypes.IQualifierTypeCreateParams.index}\n   */\n  index?: number;\n\n  /**\n   * Optional array enumerating allowed territories to further constrain the type.\n   */\n  allowedTerritories?: string[];\n}\n\n/**\n * Qualifier type for territory values. Territories are two-letter ISO-3166-2\n * Alpha-2 country codes.  Canonical territory codes are uppercase, but this\n * implementation handles incorrect casing.\n * @public\n */\nexport class TerritoryQualifierType extends QualifierType {\n  /**\n   * Optional array enumerating allowed territories to further constrain the type.\n   */\n  public readonly allowedTerritories?: ReadonlyArray<QualifierConditionValue>;\n\n  /**\n   * Creates a new {@link QualifierTypes.TerritoryQualifierType | TerritoryQualifierType} instance.\n   * @public\n   */\n  protected constructor({\n    allowedTerritories,\n    allowContextList,\n    name,\n    index\n  }: ITerritoryQualifierTypeCreateParams) {\n    /* c8 ignore next 7 - coverage seems to be missing coalescing branches */\n    name = name ?? 'territory';\n    const validIndex = index !== undefined ? Convert.qualifierTypeIndex.convert(index).orThrow() : undefined;\n    const validTerritories =\n      allowedTerritories !== undefined\n        ? mapResults(\n            allowedTerritories.map((t) => TerritoryQualifierType.toTerritoryConditionValue(t))\n          ).orThrow()\n        : undefined;\n\n    allowContextList = allowContextList === true;\n    super({\n      name: name,\n      allowContextList,\n      index: validIndex\n    });\n    this.allowedTerritories = validTerritories;\n  }\n\n  /**\n   * {@inheritdoc QualifierTypes.QualifierType.isValidConditionValue}\n   */\n  public isValidConditionValue(value: string): value is QualifierConditionValue {\n    const normalized = value.toUpperCase();\n    /* c8 ignore next 6 - definitely tested but coverage is missing it */\n    if (!TerritoryQualifierType.isValidTerritoryConditionValue(normalized)) {\n      return false;\n    }\n    if (this.allowedTerritories !== undefined) {\n      return this.allowedTerritories.includes(normalized);\n    }\n    return true;\n  }\n\n  /**\n   * Creates a new {@link QualifierTypes.TerritoryQualifierType | TerritoryQualifierType} instance.\n   * @param params - Optional {@link QualifierTypes.ITerritoryQualifierTypeCreateParams | parameters} to use\n   * when creating the instance.\n   * @returns `Success` with the new {@link QualifierTypes.TerritoryQualifierType | TerritoryQualifierType} if successful,\n   * `Failure` with an error message otherwise.\n   * @public\n   */\n  public static create(params?: ITerritoryQualifierTypeCreateParams): Result<TerritoryQualifierType> {\n    /* c8 ignore next 1 - coverage having problems with conditional branches */\n    params = params ?? {};\n    return captureResult(() => new TerritoryQualifierType(params));\n  }\n\n  /**\n   * {@inheritdoc QualifierTypes.QualifierType._matchOne}\n   */\n  protected _matchOne(\n    condition: QualifierConditionValue,\n    context: QualifierContextValue\n  ): QualifierMatchScore {\n    if (this.isValidConditionValue(condition) && condition.toUpperCase() === context.toUpperCase()) {\n      return PerfectMatch;\n    }\n    return NoMatch;\n  }\n\n  /**\n   * Determines whether a value is a valid condition value for a territory qualifier.\n   * @param value - The value to validate.\n   * @returns `true` if the value is a valid condition value, `false` otherwise.\n   * @public\n   */\n  public static isValidTerritoryConditionValue(value: string): value is QualifierConditionValue {\n    return Validate.RegularExpressions.territoryCode.test(value);\n  }\n\n  /**\n   * Converts a string value to a territory condition value.\n   * @param value - The value to convert.\n   * @returns `Success` with the converted value if successful, `Failure` with an error message otherwise.\n   * @public\n   */\n  public static toTerritoryConditionValue(value: string): Result<QualifierConditionValue> {\n    const normalized = value.toUpperCase();\n    return TerritoryQualifierType.isValidTerritoryConditionValue(normalized)\n      ? succeed(normalized)\n      : fail(`${value}: not a valid territory code`);\n  }\n}\n"]}
+{"version":3,"file":"territoryQualifierType.js","sourceRoot":"","sources":["../../../src/packlets/qualifier-types/territoryQualifierType.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;;;AAEH,4CAAiF;AACjF,sCASmB;AACnB,mDAAgD;AAChD,mEAA2F;AAE3F,oDAAuD;AAwCvD;;;;;GAKG;AACH,MAAa,sBAAuB,SAAQ,6BAAa;IAkBvD;;;OAGG;IACH,YAAsB,EACpB,eAAe,EACf,kBAAkB,EAClB,gBAAgB,EAChB,IAAI,EACJ,KAAK,EACL,SAAS,EAC2B;QACpC,yEAAyE;QACzE,IAAI,GAAG,IAAI,aAAJ,IAAI,cAAJ,IAAI,GAAI,WAAW,CAAC;QAC3B,MAAM,UAAU,GAAG,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,gBAAO,CAAC,kBAAkB,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,OAAO,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;QACzG,MAAM,gBAAgB,GACpB,kBAAkB,KAAK,SAAS;YAC9B,CAAC,CAAC,IAAA,qBAAU,EACR,kBAAkB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,sBAAsB,CAAC,yBAAyB,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC,CACjG,CAAC,OAAO,EAAE;YACb,CAAC,CAAC,SAAS,CAAC;QAEhB,gBAAgB,GAAG,gBAAgB,KAAK,IAAI,CAAC;QAC7C,KAAK,CAAC;YACJ,IAAI,EAAE,IAAI;YACV,gBAAgB;YAChB,KAAK,EAAE,UAAU;SAClB,CAAC,CAAC;QACH,IAAI,CAAC,kBAAkB,GAAG,gBAAgB,CAAC;QAC3C,IAAI,CAAC,eAAe,GAAG,eAAe,KAAK,IAAI,CAAC;QAEhD,IAAI,SAAS,EAAE,CAAC;YACd,qGAAqG;YACrG,IAAI,CAAC,SAAS,GAAG,6CAAqB,CAAC,MAAM,CAAC;gBAC5C,MAAM,EAAE,kBAAkB,aAAlB,kBAAkB,cAAlB,kBAAkB,GAAI,EAAE;gBAChC,SAAS,EAAE,SAAS;aACrB,CAAC,CAAC,OAAO,EAAE,CAAC;QACf,CAAC;IACH,CAAC;IAED;;OAEG;IACI,qBAAqB,CAAC,KAAa;QACxC,MAAM,UAAU,GAAG,IAAI,CAAC,eAAe,CAAC,CAAC,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC;QAEtE,IAAI,CAAC,sBAAsB,CAAC,8BAA8B,CAAC,UAAU,CAAC,EAAE,CAAC;YACvE,OAAO,KAAK,CAAC;QACf,CAAC;QACD,IAAI,IAAI,CAAC,kBAAkB,KAAK,SAAS,EAAE,CAAC;YAC1C,OAAO,IAAI,CAAC,kBAAkB,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;QACtD,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;;;OAOG;IACI,MAAM,CAAC,MAAM,CAAC,MAA4C;QAC/D,2EAA2E;QAC3E,MAAM,GAAG,MAAM,aAAN,MAAM,cAAN,MAAM,GAAI,EAAE,CAAC;QACtB,OAAO,IAAA,wBAAa,EAAC,GAAG,EAAE,CAAC,IAAI,sBAAsB,CAAC,MAAM,CAAC,CAAC,CAAC;IACjE,CAAC;IAED;;;;;;;OAOG;IACI,MAAM,CAAC,gBAAgB,CAC5B,MAAyE;;QAEzE,MAAM,eAAe,GAAG,MAAA,MAAM,CAAC,aAAa,mCAAI,EAAE,CAAC;QACnD,OAAO,IAAA,iCAAkB,EAAsC;YAC7D,IAAI,EAAE,MAAM,CAAC,IAAI;YACjB,gBAAgB,EAAE,eAAe,CAAC,gBAAgB,KAAK,IAAI;YAC3D,kBAAkB,EAAE,eAAe,CAAC,kBAAkB;YACtD,eAAe,EAAE,eAAe,CAAC,eAAe,KAAK,IAAI;YACzD,SAAS,EAAE,eAAe,CAAC,SAAS;SACrC,CAAC,CAAC,SAAS,CAAC,sBAAsB,CAAC,MAAM,CAAC,CAAC;IAC9C,CAAC;IAED;;OAEG;IACO,SAAS,CACjB,SAAkC,EAClC,OAA8B,EAC9B,UAA8B;QAE9B,IAAI,IAAI,CAAC,qBAAqB,CAAC,SAAS,CAAC,IAAI,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAAC,EAAE,CAAC;YAC/E,6CAA6C;YAC7C,MAAM,mBAAmB,GAAG,SAAS,CAAC,WAAW,EAAE,CAAC;YACpD,MAAM,iBAAiB,GAAG,OAAO,CAAC,WAAW,EAA2B,CAAC;YAEzE,IAAI,mBAAmB,KAAK,iBAAiB,EAAE,CAAC;gBAC9C,OAAO,qBAAY,CAAC;YACtB,CAAC;YAED,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;gBACnB,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CACzB,mBAA8C,EAC9C,iBAA0C,EAC1C,UAAU,CACX,CAAC;YACJ,CAAC;QACH,CAAC;QACD,OAAO,gBAAO,CAAC;IACjB,CAAC;IAED;;;;;;;OAOG;IACI,MAAM,CAAC,8BAA8B,CAC1C,KAAa,EACb,eAAyB;QAEzB,IAAI,eAAe,KAAK,IAAI,IAAI,KAAK,KAAK,KAAK,CAAC,WAAW,EAAE,EAAE,CAAC;YAC9D,OAAO,KAAK,CAAC;QACf,CAAC;QACD,OAAO,iBAAQ,CAAC,kBAAkB,CAAC,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC,CAAC;IAC7E,CAAC;IAED;;;;;;;;OAQG;IACI,MAAM,CAAC,yBAAyB,CACrC,KAAa,EACb,eAAyB;QAEzB,MAAM,UAAU,GAAG,KAAK,CAAC,WAAW,EAAE,CAAC;QACvC,OAAO,sBAAsB,CAAC,8BAA8B,CAAC,UAAU,EAAE,eAAe,CAAC;YACvF,CAAC,CAAC,IAAA,kBAAO,EAAC,UAAU,CAAC;YACrB,CAAC,CAAC,IAAA,eAAI,EAAC,GAAG,KAAK,8BAA8B,CAAC,CAAC;IACnD,CAAC;CACF;AA5KD,wDA4KC","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, Result, fail, succeed, mapResults } from '@fgv/ts-utils';\nimport {\n  Convert,\n  NoMatch,\n  PerfectMatch,\n  QualifierConditionValue,\n  QualifierContextValue,\n  QualifierMatchScore,\n  Validate,\n  ConditionOperator\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 * Parameters used to create a new {@link QualifierTypes.TerritoryQualifierType | TerritoryQualifierType} instance.\n * @public\n */\nexport interface ITerritoryQualifierTypeCreateParams {\n  /**\n   * {@inheritdoc QualifierTypes.IQualifierTypeCreateParams.name}\n   */\n  name?: string;\n\n  /**\n   * {@inheritdoc QualifierTypes.IQualifierTypeCreateParams.allowContextList}\n   */\n  allowContextList?: boolean;\n\n  /**\n   * {@inheritdoc QualifierTypes.IQualifierTypeCreateParams.index}\n   */\n  index?: number;\n\n  /**\n   * Optional array enumerating allowed territories to further constrain the type.\n   */\n  allowedTerritories?: string[];\n\n  /**\n   * Flag indicating whether the qualifier type should accept lowercase territory codes.\n   * Defaults to `false`.\n   */\n  acceptLowercase?: boolean;\n\n  /**\n   * Optional {@link QualifierTypes.LiteralValueHierarchyDecl | hierarchy declaration}\n   * of territory values to use for matching. If not provided, no hierarchy will be used.\n   */\n  hierarchy?: LiteralValueHierarchyDecl<string>;\n}\n\n/**\n * Qualifier type for territory values. Territories are two-letter ISO-3166-2\n * Alpha-2 country codes. Canonical territory codes are uppercase, but this\n * implementation handles incorrect casing.\n * @public\n */\nexport class TerritoryQualifierType extends QualifierType {\n  /**\n   * Optional array enumerating allowed territories to further constrain the type.\n   */\n  public readonly allowedTerritories?: ReadonlyArray<QualifierConditionValue>;\n\n  /**\n   * Flag indicating whether the qualifier type should accept lowercase territory codes.\n   * Defaults to `false`.\n   */\n  public readonly acceptLowercase: boolean;\n\n  /**\n   * Optional {@link QualifierTypes.LiteralValueHierarchy | hierarchy} of territory\n   * values to use for matching. If not provided, no hierarchy will be used.\n   */\n  public readonly hierarchy?: LiteralValueHierarchy<string>;\n\n  /**\n   * Creates a new {@link QualifierTypes.TerritoryQualifierType | TerritoryQualifierType} instance.\n   * @public\n   */\n  protected constructor({\n    acceptLowercase,\n    allowedTerritories,\n    allowContextList,\n    name,\n    index,\n    hierarchy\n  }: ITerritoryQualifierTypeCreateParams) {\n    /* c8 ignore next 7 - coverage seems to be missing coalescing branches */\n    name = name ?? 'territory';\n    const validIndex = index !== undefined ? Convert.qualifierTypeIndex.convert(index).orThrow() : undefined;\n    const validTerritories =\n      allowedTerritories !== undefined\n        ? mapResults(\n            allowedTerritories.map((t) => TerritoryQualifierType.toTerritoryConditionValue(t.toUpperCase()))\n          ).orThrow()\n        : undefined;\n\n    allowContextList = allowContextList === true;\n    super({\n      name: name,\n      allowContextList,\n      index: validIndex\n    });\n    this.allowedTerritories = validTerritories;\n    this.acceptLowercase = acceptLowercase === true;\n\n    if (hierarchy) {\n      /* c8 ignore next 5 - defensive coding: allowedTerritories ?? [] fallback enables open values mode */\n      this.hierarchy = LiteralValueHierarchy.create({\n        values: allowedTerritories ?? [],\n        hierarchy: hierarchy\n      }).orThrow();\n    }\n  }\n\n  /**\n   * {@inheritdoc QualifierTypes.QualifierType.isValidConditionValue}\n   */\n  public isValidConditionValue(value: string): value is QualifierConditionValue {\n    const normalized = this.acceptLowercase ? value.toUpperCase() : value;\n\n    if (!TerritoryQualifierType.isValidTerritoryConditionValue(normalized)) {\n      return false;\n    }\n    if (this.allowedTerritories !== undefined) {\n      return this.allowedTerritories.includes(normalized);\n    }\n    return true;\n  }\n\n  /**\n   * Creates a new {@link QualifierTypes.TerritoryQualifierType | TerritoryQualifierType} instance.\n   * @param params - Optional {@link QualifierTypes.ITerritoryQualifierTypeCreateParams | parameters}\n   * to use when creating the instance.\n   * @returns `Success` with the new {@link QualifierTypes.TerritoryQualifierType | TerritoryQualifierType}\n   * if successful, `Failure` with an error message otherwise.\n   * @public\n   */\n  public static create(params?: ITerritoryQualifierTypeCreateParams): Result<TerritoryQualifierType> {\n    /* c8 ignore next 1 - coverage having problems with conditional branches */\n    params = params ?? {};\n    return captureResult(() => new TerritoryQualifierType(params));\n  }\n\n  /**\n   * Creates a new {@link QualifierTypes.TerritoryQualifierType | TerritoryQualifierType} from a configuration object.\n   * @param config - The {@link QualifierTypes.Config.IQualifierTypeConfig | configuration object} containing\n   * the name, systemType, and optional territory-specific configuration including allowed territories and hierarchy.\n   * @returns `Success` with the new {@link QualifierTypes.TerritoryQualifierType | TerritoryQualifierType}\n   * if successful, `Failure` with an error message otherwise.\n   * @public\n   */\n  public static createFromConfig(\n    config: Config.IQualifierTypeConfig<Config.ITerritoryQualifierTypeConfig>\n  ): Result<TerritoryQualifierType> {\n    const territoryConfig = config.configuration ?? {};\n    return sanitizeJsonObject<ITerritoryQualifierTypeCreateParams>({\n      name: config.name,\n      allowContextList: territoryConfig.allowContextList === true,\n      allowedTerritories: territoryConfig.allowedTerritories,\n      acceptLowercase: territoryConfig.acceptLowercase === true,\n      hierarchy: territoryConfig.hierarchy\n    }).onSuccess(TerritoryQualifierType.create);\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.isValidConditionValue(condition) && this.isValidContextValue(context)) {\n      // Normalize to uppercase for territory codes\n      const normalizedCondition = condition.toUpperCase();\n      const normalizedContext = context.toUpperCase() as QualifierContextValue;\n\n      if (normalizedCondition === normalizedContext) {\n        return PerfectMatch;\n      }\n\n      if (this.hierarchy) {\n        return this.hierarchy.match(\n          normalizedCondition as QualifierConditionValue,\n          normalizedContext as QualifierContextValue,\n          __operator\n        );\n      }\n    }\n    return NoMatch;\n  }\n\n  /**\n   * Determines whether a value is a valid condition value for a territory qualifier.\n   * @param value - The value to validate.\n   * @param acceptLowercase - Flag indicating whether the qualifier type should accept lowercase territory codes.\n   * Defaults to `false`.\n   * @returns `true` if the value is a valid condition value, `false` otherwise.\n   * @public\n   */\n  public static isValidTerritoryConditionValue(\n    value: string,\n    acceptLowercase?: boolean\n  ): value is QualifierConditionValue {\n    if (acceptLowercase !== true && value !== value.toUpperCase()) {\n      return false;\n    }\n    return Validate.RegularExpressions.territoryCode.test(value.toUpperCase());\n  }\n\n  /**\n   * Converts a string value to a territory condition value.\n   * @param value - The value to convert.\n   * @param acceptLowercase - Flag indicating whether the qualifier type should accept lowercase territory codes.\n   * Defaults to `false`.\n   * @returns `Success` with the converted value if successful, `Failure` with an error\n   * message otherwise.\n   * @public\n   */\n  public static toTerritoryConditionValue(\n    value: string,\n    acceptLowercase?: boolean\n  ): Result<QualifierConditionValue> {\n    const normalized = value.toUpperCase();\n    return TerritoryQualifierType.isValidTerritoryConditionValue(normalized, acceptLowercase)\n      ? succeed(normalized)\n      : fail(`${value}: not a valid territory code`);\n  }\n}\n"]}

package/lib/packlets/qualifiers/convert/decls.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decls.d.ts","sourceRoot":"","sources":["../../../../src/packlets/qualifiers/convert/decls.ts"],"names":[],"mappings":"AAuBA,OAAO,EAAE,cAAc,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAC;AAE3E,OAAO,EAAE,8BAA8B,EAAE,MAAM,uBAAuB,CAAC;AAIvE;;;GAGG;AACH,eAAO,MAAM,aAAa,kEAMxB,CAAC;AAEH;;;GAGG;AACH,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,cAAc,EAAE,8BAA8B,CAAC;IACxD,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,0FA6BjC,CAAC"}
+{"version":3,"file":"decls.d.ts","sourceRoot":"","sources":["../../../../src/packlets/qualifiers/convert/decls.ts"],"names":[],"mappings":"AAuBA,OAAO,EAAE,cAAc,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAC;AAE3E,OAAO,EAAE,8BAA8B,EAAE,MAAM,uBAAuB,CAAC;AAIvE;;;GAGG;AACH,eAAO,MAAM,aAAa,kEAOxB,CAAC;AAEH;;;GAGG;AACH,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,cAAc,EAAE,8BAA8B,CAAC;IACxD,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,0FAgCjC,CAAC"}

package/lib/packlets/qualifiers/convert/decls.js

@@ -34,7 +34,8 @@ exports.qualifierDecl = ts_utils_1.Converters.strictObject({
     typeName: ts_utils_1.Converters.string,
     defaultPriority: ts_utils_1.Converters.number,
     token: ts_utils_1.Converters.string.optional(),
-    tokenIsOptional: ts_utils_1.Converters.boolean.optional()
+    tokenIsOptional: ts_utils_1.Converters.boolean.optional(),
+    defaultValue: ts_utils_1.Converters.string.optional()
 });
 /**
  * Converter which constructs a {@link Qualifiers.IValidatedQualifierDecl | validated qualifier declaration}
@@ -51,20 +52,21 @@ exports.validatedQualifierDecl = ts_utils_1.Converters.generic((from, __self, co
         ? common_1.Validate.toQualifierIndex(context.qualifierIndex)
         : (0, ts_utils_1.succeed)(undefined);
     return exports.qualifierDecl.convert(from).onSuccess((decl) => {
-        var _a;
-        const token = (_a = decl.token) !== null && _a !== void 0 ? _a : decl.name;
-        return (0, ts_utils_1.populateObject)({
-            name: () => common_1.Validate.toQualifierName(decl.name),
-            token: () => common_1.Validate.toQualifierName(token),
-            tokenIsOptional: () => (0, ts_utils_1.succeed)(decl.tokenIsOptional === true),
-            type: () => context.qualifierTypes.validating.get(decl.typeName),
-            defaultPriority: () => common_1.Validate.toConditionPriority(decl.defaultPriority),
-            index: () => validatedIndexResult
-        }).onSuccess((validated) => {
-            if (context.qualifierIndex !== undefined) {
-                context.qualifierIndex++;
-            }
-            return (0, ts_utils_1.succeed)(validated);
+        return context.qualifierTypes.validating.get(decl.typeName).asResult.onSuccess((type) => {
+            return (0, ts_utils_1.populateObject)({
+                name: () => common_1.Validate.toQualifierName(decl.name),
+                token: () => { var _a; return common_1.Validate.toQualifierName((_a = decl.token) !== null && _a !== void 0 ? _a : decl.name); },
+                tokenIsOptional: () => (0, ts_utils_1.succeed)(decl.tokenIsOptional === true),
+                type: () => (0, ts_utils_1.succeed)(type),
+                defaultPriority: () => common_1.Validate.toConditionPriority(decl.defaultPriority),
+                defaultValue: () => decl.defaultValue ? type.validateContextValue(decl.defaultValue) : (0, ts_utils_1.succeed)(undefined),
+                index: () => validatedIndexResult
+            }).onSuccess((validated) => {
+                if (context.qualifierIndex !== undefined) {
+                    context.qualifierIndex++;
+                }
+                return (0, ts_utils_1.succeed)(validated);
+            });
         });
     });
 });

package/lib/packlets/qualifiers/convert/decls.js.map

@@ -1 +1 @@
-{"version":3,"file":"decls.js","sourceRoot":"","sources":["../../../../src/packlets/qualifiers/convert/decls.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;;;AAEH,4CAAkF;AAElF,yCAAwC;AAGxC,2CAA2C;AAE3C;;;GAGG;AACU,QAAA,aAAa,GAAG,qBAAU,CAAC,YAAY,CAAiB;IACnE,IAAI,EAAE,qBAAU,CAAC,MAAM;IACvB,QAAQ,EAAE,qBAAU,CAAC,MAAM;IAC3B,eAAe,EAAE,qBAAU,CAAC,MAAM;IAClC,KAAK,EAAE,qBAAU,CAAC,MAAM,CAAC,QAAQ,EAAE;IACnC,eAAe,EAAE,qBAAU,CAAC,OAAO,CAAC,QAAQ,EAAE;CAC/C,CAAC,CAAC;AAWH;;;;;GAKG;AACU,QAAA,sBAAsB,GAAG,qBAAU,CAAC,OAAO,CAGtD,CAAC,IAAa,EAAE,MAAM,EAAE,OAAsC,EAAmC,EAAE;IACnG,6EAA6E;IAC7E,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;QAC1B,OAAO,IAAA,eAAI,EAAC,qDAAqD,CAAC,CAAC;IACrE,CAAC;IACD,MAAM,oBAAoB,GACxB,OAAO,CAAC,cAAc,KAAK,SAAS;QAClC,CAAC,CAAC,iBAAQ,CAAC,gBAAgB,CAAC,OAAO,CAAC,cAAc,CAAC;QACnD,CAAC,CAAC,IAAA,kBAAO,EAAC,SAAS,CAAC,CAAC;IAEzB,OAAO,qBAAa,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,CAAC,IAAI,EAAE,EAAE;;QACpD,MAAM,KAAK,GAAG,MAAA,IAAI,CAAC,KAAK,mCAAI,IAAI,CAAC,IAAI,CAAC;QACtC,OAAO,IAAA,yBAAc,EAA0B;YAC7C,IAAI,EAAE,GAAG,EAAE,CAAC,iBAAQ,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC;YAC/C,KAAK,EAAE,GAAG,EAAE,CAAC,iBAAQ,CAAC,eAAe,CAAC,KAAK,CAAC;YAC5C,eAAe,EAAE,GAAG,EAAE,CAAC,IAAA,kBAAO,EAAC,IAAI,CAAC,eAAe,KAAK,IAAI,CAAC;YAC7D,IAAI,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,cAAc,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC;YAChE,eAAe,EAAE,GAAG,EAAE,CAAC,iBAAQ,CAAC,mBAAmB,CAAC,IAAI,CAAC,eAAe,CAAC;YACzE,KAAK,EAAE,GAAG,EAAE,CAAC,oBAAoB;SAClC,CAAC,CAAC,SAAS,CAAC,CAAC,SAAS,EAAE,EAAE;YACzB,IAAI,OAAO,CAAC,cAAc,KAAK,SAAS,EAAE,CAAC;gBACzC,OAAO,CAAC,cAAc,EAAE,CAAC;YAC3B,CAAC;YACD,OAAO,IAAA,kBAAO,EAAC,SAAS,CAAC,CAAC;QAC5B,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC","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 { Converters, populateObject, Result, fail, succeed } from '@fgv/ts-utils';\nimport { IQualifierDecl, IValidatedQualifierDecl } from '../qualifierDecl';\nimport { Validate } from '../../common';\nimport { ReadOnlyQualifierTypeCollector } from '../../qualifier-types';\n\n/* eslint-disable @rushstack/typedef-var */\n\n/**\n * Converter for a {@link Qualifiers.IQualifierDecl | qualifier declaration}.\n * @public\n */\nexport const qualifierDecl = Converters.strictObject<IQualifierDecl>({\n  name: Converters.string,\n  typeName: Converters.string,\n  defaultPriority: Converters.number,\n  token: Converters.string.optional(),\n  tokenIsOptional: Converters.boolean.optional()\n});\n\n/**\n * Context necessary to convert a {@link Qualifiers.IValidatedQualifierDecl | validated qualifier declaration}.\n * @public\n */\nexport interface IQualifierDeclConvertContext {\n  readonly qualifierTypes: ReadOnlyQualifierTypeCollector;\n  qualifierIndex?: number;\n}\n\n/**\n * Converter which constructs a {@link Qualifiers.IValidatedQualifierDecl | validated qualifier declaration}\n * from a {@link Qualifiers.IQualifierDecl | qualifier declaration}, instantiating qualifier types by name\n * from a supplied {@link Qualifiers.Convert.IQualifierDeclConvertContext | conversion context}.\n * @public\n */\nexport const validatedQualifierDecl = Converters.generic<\n  IValidatedQualifierDecl,\n  IQualifierDeclConvertContext\n>((from: unknown, __self, context?: IQualifierDeclConvertContext): Result<IValidatedQualifierDecl> => {\n  /* c8 ignore next 7  - this is tested but code coverage is losing its mind */\n  if (context === undefined) {\n    return fail('validatedQualifierDecl converter requires a context');\n  }\n  const validatedIndexResult =\n    context.qualifierIndex !== undefined\n      ? Validate.toQualifierIndex(context.qualifierIndex)\n      : succeed(undefined);\n\n  return qualifierDecl.convert(from).onSuccess((decl) => {\n    const token = decl.token ?? decl.name;\n    return populateObject<IValidatedQualifierDecl>({\n      name: () => Validate.toQualifierName(decl.name),\n      token: () => Validate.toQualifierName(token),\n      tokenIsOptional: () => succeed(decl.tokenIsOptional === true),\n      type: () => context.qualifierTypes.validating.get(decl.typeName),\n      defaultPriority: () => Validate.toConditionPriority(decl.defaultPriority),\n      index: () => validatedIndexResult\n    }).onSuccess((validated) => {\n      if (context.qualifierIndex !== undefined) {\n        context.qualifierIndex++;\n      }\n      return succeed(validated);\n    });\n  });\n});\n"]}
+{"version":3,"file":"decls.js","sourceRoot":"","sources":["../../../../src/packlets/qualifiers/convert/decls.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;;;AAEH,4CAAkF;AAElF,yCAAwC;AAGxC,2CAA2C;AAE3C;;;GAGG;AACU,QAAA,aAAa,GAAG,qBAAU,CAAC,YAAY,CAAiB;IACnE,IAAI,EAAE,qBAAU,CAAC,MAAM;IACvB,QAAQ,EAAE,qBAAU,CAAC,MAAM;IAC3B,eAAe,EAAE,qBAAU,CAAC,MAAM;IAClC,KAAK,EAAE,qBAAU,CAAC,MAAM,CAAC,QAAQ,EAAE;IACnC,eAAe,EAAE,qBAAU,CAAC,OAAO,CAAC,QAAQ,EAAE;IAC9C,YAAY,EAAE,qBAAU,CAAC,MAAM,CAAC,QAAQ,EAAE;CAC3C,CAAC,CAAC;AAWH;;;;;GAKG;AACU,QAAA,sBAAsB,GAAG,qBAAU,CAAC,OAAO,CAGtD,CAAC,IAAa,EAAE,MAAM,EAAE,OAAsC,EAAmC,EAAE;IACnG,6EAA6E;IAC7E,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;QAC1B,OAAO,IAAA,eAAI,EAAC,qDAAqD,CAAC,CAAC;IACrE,CAAC;IACD,MAAM,oBAAoB,GACxB,OAAO,CAAC,cAAc,KAAK,SAAS;QAClC,CAAC,CAAC,iBAAQ,CAAC,gBAAgB,CAAC,OAAO,CAAC,cAAc,CAAC;QACnD,CAAC,CAAC,IAAA,kBAAO,EAAC,SAAS,CAAC,CAAC;IAEzB,OAAO,qBAAa,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,SAAS,CAAC,CAAC,IAAI,EAAE,EAAE;QACpD,OAAO,OAAO,CAAC,cAAc,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC,IAAI,EAAE,EAAE;YACtF,OAAO,IAAA,yBAAc,EAA0B;gBAC7C,IAAI,EAAE,GAAG,EAAE,CAAC,iBAAQ,CAAC,eAAe,CAAC,IAAI,CAAC,IAAI,CAAC;gBAC/C,KAAK,EAAE,GAAG,EAAE,WAAC,OAAA,iBAAQ,CAAC,eAAe,CAAC,MAAA,IAAI,CAAC,KAAK,mCAAI,IAAI,CAAC,IAAI,CAAC,CAAA,EAAA;gBAC9D,eAAe,EAAE,GAAG,EAAE,CAAC,IAAA,kBAAO,EAAC,IAAI,CAAC,eAAe,KAAK,IAAI,CAAC;gBAC7D,IAAI,EAAE,GAAG,EAAE,CAAC,IAAA,kBAAO,EAAC,IAAI,CAAC;gBACzB,eAAe,EAAE,GAAG,EAAE,CAAC,iBAAQ,CAAC,mBAAmB,CAAC,IAAI,CAAC,eAAe,CAAC;gBACzE,YAAY,EAAE,GAAG,EAAE,CACjB,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,IAAA,kBAAO,EAAC,SAAS,CAAC;gBACvF,KAAK,EAAE,GAAG,EAAE,CAAC,oBAAoB;aAClC,CAAC,CAAC,SAAS,CAAC,CAAC,SAAS,EAAE,EAAE;gBACzB,IAAI,OAAO,CAAC,cAAc,KAAK,SAAS,EAAE,CAAC;oBACzC,OAAO,CAAC,cAAc,EAAE,CAAC;gBAC3B,CAAC;gBACD,OAAO,IAAA,kBAAO,EAAC,SAAS,CAAC,CAAC;YAC5B,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC","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 { Converters, populateObject, Result, fail, succeed } from '@fgv/ts-utils';\nimport { IQualifierDecl, IValidatedQualifierDecl } from '../qualifierDecl';\nimport { Validate } from '../../common';\nimport { ReadOnlyQualifierTypeCollector } from '../../qualifier-types';\n\n/* eslint-disable @rushstack/typedef-var */\n\n/**\n * Converter for a {@link Qualifiers.IQualifierDecl | qualifier declaration}.\n * @public\n */\nexport const qualifierDecl = Converters.strictObject<IQualifierDecl>({\n  name: Converters.string,\n  typeName: Converters.string,\n  defaultPriority: Converters.number,\n  token: Converters.string.optional(),\n  tokenIsOptional: Converters.boolean.optional(),\n  defaultValue: Converters.string.optional()\n});\n\n/**\n * Context necessary to convert a {@link Qualifiers.IValidatedQualifierDecl | validated qualifier declaration}.\n * @public\n */\nexport interface IQualifierDeclConvertContext {\n  readonly qualifierTypes: ReadOnlyQualifierTypeCollector;\n  qualifierIndex?: number;\n}\n\n/**\n * Converter which constructs a {@link Qualifiers.IValidatedQualifierDecl | validated qualifier declaration}\n * from a {@link Qualifiers.IQualifierDecl | qualifier declaration}, instantiating qualifier types by name\n * from a supplied {@link Qualifiers.Convert.IQualifierDeclConvertContext | conversion context}.\n * @public\n */\nexport const validatedQualifierDecl = Converters.generic<\n  IValidatedQualifierDecl,\n  IQualifierDeclConvertContext\n>((from: unknown, __self, context?: IQualifierDeclConvertContext): Result<IValidatedQualifierDecl> => {\n  /* c8 ignore next 7  - this is tested but code coverage is losing its mind */\n  if (context === undefined) {\n    return fail('validatedQualifierDecl converter requires a context');\n  }\n  const validatedIndexResult =\n    context.qualifierIndex !== undefined\n      ? Validate.toQualifierIndex(context.qualifierIndex)\n      : succeed(undefined);\n\n  return qualifierDecl.convert(from).onSuccess((decl) => {\n    return context.qualifierTypes.validating.get(decl.typeName).asResult.onSuccess((type) => {\n      return populateObject<IValidatedQualifierDecl>({\n        name: () => Validate.toQualifierName(decl.name),\n        token: () => Validate.toQualifierName(decl.token ?? decl.name),\n        tokenIsOptional: () => succeed(decl.tokenIsOptional === true),\n        type: () => succeed(type),\n        defaultPriority: () => Validate.toConditionPriority(decl.defaultPriority),\n        defaultValue: () =>\n          decl.defaultValue ? type.validateContextValue(decl.defaultValue) : succeed(undefined),\n        index: () => validatedIndexResult\n      }).onSuccess((validated) => {\n        if (context.qualifierIndex !== undefined) {\n          context.qualifierIndex++;\n        }\n        return succeed(validated);\n      });\n    });\n  });\n});\n"]}

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

@@ -2,5 +2,7 @@ import * as Convert from './convert';
 export * from './qualifier';
 export * from './qualifierDecl';
 export * from './qualifierCollector';
+export * from './qualifierDefaultValueDecls';
+export * from './qualifierDefaultValueToken';
 export { Convert };
 //# sourceMappingURL=index.d.ts.map

package/lib/packlets/qualifiers/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/packlets/qualifiers/index.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC;AAErC,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC;AAErC,OAAO,EAAE,OAAO,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/packlets/qualifiers/index.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC;AAErC,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC;AACrC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,8BAA8B,CAAC;AAE7C,OAAO,EAAE,OAAO,EAAE,CAAC"}

package/lib/packlets/qualifiers/index.js

@@ -63,4 +63,6 @@ exports.Convert = Convert;
 __exportStar(require("./qualifier"), exports);
 __exportStar(require("./qualifierDecl"), exports);
 __exportStar(require("./qualifierCollector"), exports);
+__exportStar(require("./qualifierDefaultValueDecls"), exports);
+__exportStar(require("./qualifierDefaultValueToken"), exports);
 //# sourceMappingURL=index.js.map

package/lib/packlets/qualifiers/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/packlets/qualifiers/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,mDAAqC;AAM5B,0BAAO;AAJhB,8CAA4B;AAC5B,kDAAgC;AAChC,uDAAqC","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 * as Convert from './convert';\n\nexport * from './qualifier';\nexport * from './qualifierDecl';\nexport * from './qualifierCollector';\n\nexport { Convert };\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/packlets/qualifiers/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,mDAAqC;AAQ5B,0BAAO;AANhB,8CAA4B;AAC5B,kDAAgC;AAChC,uDAAqC;AACrC,+DAA6C;AAC7C,+DAA6C","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 * as Convert from './convert';\n\nexport * from './qualifier';\nexport * from './qualifierDecl';\nexport * from './qualifierCollector';\nexport * from './qualifierDefaultValueDecls';\nexport * from './qualifierDefaultValueToken';\n\nexport { Convert };\n"]}

package/lib/packlets/qualifiers/qualifier.d.ts

@@ -1,5 +1,5 @@
 import { Collections, ICollectible, Result } from '@fgv/ts-utils';
-import { ConditionPriority, QualifierIndex, QualifierName } from '../common';
+import { ConditionPriority, QualifierIndex, QualifierName, QualifierContextValue, QualifierConditionValue, ConditionOperator } from '../common';
 import { QualifierType } from '../qualifier-types';
 import { IValidatedQualifierDecl } from './qualifierDecl';
 /**
@@ -25,6 +25,10 @@ export declare class Qualifier implements IValidatedQualifierDecl, ICollectible<
      * Indicates whether the token is optional in the name or path of a resource being imported.
      */
     readonly tokenIsOptional: boolean;
+    /**
+     * Optional default value for the qualifier.
+     */
+    readonly defaultValue?: QualifierContextValue;
     /**
      * The index of the qualifier.
      */
@@ -47,7 +51,7 @@ export declare class Qualifier implements IValidatedQualifierDecl, ICollectible<
      * @param defaultPriority - The default {@link ConditionPriority | priority} of conditions
      * @public
      */
-    protected constructor({ name, token, type, defaultPriority, tokenIsOptional, index }: IValidatedQualifierDecl);
+    protected constructor({ name, token, type, defaultPriority, tokenIsOptional, defaultValue, index }: IValidatedQualifierDecl);
     /**
      * Creates a new instance of a {@link Qualifiers.Qualifier | Qualifier} from the
      * supplied {@link Qualifiers.IValidatedQualifierDecl | validated declaration}.
@@ -64,5 +68,21 @@ export declare class Qualifier implements IValidatedQualifierDecl, ICollectible<
      * @returns `Success` with the index if successful, `Failure` with an error message otherwise.
      */
     setIndex(index: QualifierIndex): Result<QualifierIndex>;
+    /**
+     * {@inheritdoc QualifierTypes.QualifierType.isValidContextValue}
+     */
+    isValidContextValue(value: string): value is QualifierContextValue;
+    /**
+     * {@inheritdoc QualifierTypes.QualifierType.isValidConditionValue}
+     */
+    isValidConditionValue(value: string): value is QualifierConditionValue;
+    /**
+     * {@inheritdoc QualifierTypes.QualifierType.validateCondition}
+     */
+    validateCondition(value: string, operator?: ConditionOperator): Result<QualifierConditionValue>;
+    /**
+     * {@inheritdoc QualifierTypes.QualifierType.validateContextValue}
+     */
+    validateContextValue(value: string): Result<QualifierContextValue>;
 }
 //# sourceMappingURL=qualifier.d.ts.map

package/lib/packlets/qualifiers/qualifier.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"qualifier.d.ts","sourceRoot":"","sources":["../../../src/packlets/qualifiers/qualifier.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAiB,WAAW,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACjF,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,aAAa,EAA4B,MAAM,WAAW,CAAC;AACvG,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAC;AAE1D;;;;GAIG;AACH,qBAAa,SAAU,YAAW,uBAAuB,EAAE,YAAY,CAAC,aAAa,EAAE,cAAc,CAAC;IACpG;;OAEG;IACH,SAAgB,IAAI,EAAE,aAAa,CAAC;IAEpC;;;OAGG;IACH,SAAgB,KAAK,EAAE,aAAa,CAAC;IAErC;;OAEG;IACH,SAAgB,IAAI,EAAE,aAAa,CAAC;IAEpC;;OAEG;IACH,SAAgB,eAAe,EAAE,OAAO,CAAC;IAEzC;;OAEG;IACH,IAAW,KAAK,IAAI,cAAc,GAAG,SAAS,CAE7C;IAED;;OAEG;IACH,IAAW,GAAG,IAAI,aAAa,CAE9B;IAED;;;OAGG;IACH,SAAgB,eAAe,EAAE,iBAAiB,CAAC;IAEnD,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,WAAW,CAAC,WAAW,CAAC,aAAa,EAAE,cAAc,CAAC,CAAC;IAExF;;;;;;;OAOG;IACH,SAAS,aAAa,EACpB,IAAI,EACJ,KAAK,EACL,IAAI,EACJ,eAAe,EACf,eAAe,EACf,KAAK,EACN,EAAE,uBAAuB;IAa1B;;;;;;;;OAQG;WACW,MAAM,CAAC,IAAI,EAAE,uBAAuB,GAAG,MAAM,CAAC,SAAS,CAAC;IAItE;;;;OAIG;IACI,QAAQ,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM,CAAC,cAAc,CAAC;CAG/D"}
+{"version":3,"file":"qualifier.d.ts","sourceRoot":"","sources":["../../../src/packlets/qualifiers/qualifier.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAiB,WAAW,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,eAAe,CAAC;AACjF,OAAO,EACL,iBAAiB,EACjB,cAAc,EACd,aAAa,EAEb,qBAAqB,EACrB,uBAAuB,EACvB,iBAAiB,EAClB,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,EAAE,uBAAuB,EAAE,MAAM,iBAAiB,CAAC;AAE1D;;;;GAIG;AACH,qBAAa,SAAU,YAAW,uBAAuB,EAAE,YAAY,CAAC,aAAa,EAAE,cAAc,CAAC;IACpG;;OAEG;IACH,SAAgB,IAAI,EAAE,aAAa,CAAC;IAEpC;;;OAGG;IACH,SAAgB,KAAK,EAAE,aAAa,CAAC;IAErC;;OAEG;IACH,SAAgB,IAAI,EAAE,aAAa,CAAC;IAEpC;;OAEG;IACH,SAAgB,eAAe,EAAE,OAAO,CAAC;IAEzC;;OAEG;IACH,SAAgB,YAAY,CAAC,EAAE,qBAAqB,CAAC;IAErD;;OAEG;IACH,IAAW,KAAK,IAAI,cAAc,GAAG,SAAS,CAE7C;IAED;;OAEG;IACH,IAAW,GAAG,IAAI,aAAa,CAE9B;IAED;;;OAGG;IACH,SAAgB,eAAe,EAAE,iBAAiB,CAAC;IAEnD,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,WAAW,CAAC,WAAW,CAAC,aAAa,EAAE,cAAc,CAAC,CAAC;IAExF;;;;;;;OAOG;IACH,SAAS,aAAa,EACpB,IAAI,EACJ,KAAK,EACL,IAAI,EACJ,eAAe,EACf,eAAe,EACf,YAAY,EACZ,KAAK,EACN,EAAE,uBAAuB;IAc1B;;;;;;;;OAQG;WACW,MAAM,CAAC,IAAI,EAAE,uBAAuB,GAAG,MAAM,CAAC,SAAS,CAAC;IAItE;;;;OAIG;IACI,QAAQ,CAAC,KAAK,EAAE,cAAc,GAAG,MAAM,CAAC,cAAc,CAAC;IAI9D;;OAEG;IACI,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,qBAAqB;IAIzE;;OAEG;IACI,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,uBAAuB;IAI7E;;OAEG;IACI,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,iBAAiB,GAAG,MAAM,CAAC,uBAAuB,CAAC;IAItG;;OAEG;IACI,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC,qBAAqB,CAAC;CAG1E"}

package/lib/packlets/qualifiers/qualifier.js

@@ -50,12 +50,13 @@ class Qualifier {
      * @param defaultPriority - The default {@link ConditionPriority | priority} of conditions
      * @public
      */
-    constructor({ name, token, type, defaultPriority, tokenIsOptional, index }) {
+    constructor({ name, token, type, defaultPriority, tokenIsOptional, defaultValue, index }) {
         this.name = name;
         this.token = token;
         this.type = type;
         this.defaultPriority = defaultPriority;
         this.tokenIsOptional = tokenIsOptional;
+        this.defaultValue = defaultValue;
         this._collectible = new ts_utils_1.Collections.Collectible({
             key: name,
             index,
@@ -82,6 +83,30 @@ class Qualifier {
     setIndex(index) {
         return this._collectible.setIndex(index);
     }
+    /**
+     * {@inheritdoc QualifierTypes.QualifierType.isValidContextValue}
+     */
+    isValidContextValue(value) {
+        return this.type.isValidContextValue(value);
+    }
+    /**
+     * {@inheritdoc QualifierTypes.QualifierType.isValidConditionValue}
+     */
+    isValidConditionValue(value) {
+        return this.type.isValidConditionValue(value);
+    }
+    /**
+     * {@inheritdoc QualifierTypes.QualifierType.validateCondition}
+     */
+    validateCondition(value, operator) {
+        return this.type.validateCondition(value, operator);
+    }
+    /**
+     * {@inheritdoc QualifierTypes.QualifierType.validateContextValue}
+     */
+    validateContextValue(value) {
+        return this.type.validateContextValue(value);
+    }
 }
 exports.Qualifier = Qualifier;
 //# sourceMappingURL=qualifier.js.map

package/lib/packlets/qualifiers/qualifier.js.map

@@ -1 +1 @@
-{"version":3,"file":"qualifier.js","sourceRoot":"","sources":["../../../src/packlets/qualifiers/qualifier.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;;;AAEH,4CAAiF;AACjF,sCAAuG;AAIvG;;;;GAIG;AACH,MAAa,SAAS;IAsBpB;;OAEG;IACH,IAAW,KAAK;QACd,OAAO,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC;IACjC,CAAC;IAED;;OAEG;IACH,IAAW,GAAG;QACZ,OAAO,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC;IAC/B,CAAC;IAUD;;;;;;;OAOG;IACH,YAAsB,EACpB,IAAI,EACJ,KAAK,EACL,IAAI,EACJ,eAAe,EACf,eAAe,EACf,KAAK,EACmB;QACxB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,eAAe,GAAG,eAAe,CAAC;QACvC,IAAI,CAAC,eAAe,GAAG,eAAe,CAAC;QACvC,IAAI,CAAC,YAAY,GAAG,IAAI,sBAAW,CAAC,WAAW,CAAgC;YAC7E,GAAG,EAAE,IAAI;YACT,KAAK;YACL,cAAc,EAAE,gBAAa,CAAC,cAAc;SAC7C,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;OAQG;IACI,MAAM,CAAC,MAAM,CAAC,IAA6B;QAChD,OAAO,IAAA,wBAAa,EAAC,GAAG,EAAE,CAAC,IAAI,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;IAClD,CAAC;IAED;;;;OAIG;IACI,QAAQ,CAAC,KAAqB;QACnC,OAAO,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC3C,CAAC;CACF;AA7FD,8BA6FC","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, Collections, ICollectible, Result } from '@fgv/ts-utils';\nimport { ConditionPriority, QualifierIndex, QualifierName, Convert as CommonConvert } from '../common';\nimport { QualifierType } from '../qualifier-types';\nimport { IValidatedQualifierDecl } from './qualifierDecl';\n\n/**\n * Represents a qualifier that can be used to identify the context in\n * which a resource is used.\n * @public\n */\nexport class Qualifier implements IValidatedQualifierDecl, ICollectible<QualifierName, QualifierIndex> {\n  /**\n   * The name of the qualifier.\n   */\n  public readonly name: QualifierName;\n\n  /**\n   * The token used to identify the qualifier in the name or\n   * path of a resource being imported.\n   */\n  public readonly token: QualifierName;\n\n  /**\n   * The {@link QualifierTypes.QualifierType | type} of the qualifier.\n   */\n  public readonly type: QualifierType;\n\n  /**\n   * Indicates whether the token is optional in the name or path of a resource being imported.\n   */\n  public readonly tokenIsOptional: boolean;\n\n  /**\n   * The index of the qualifier.\n   */\n  public get index(): QualifierIndex | undefined {\n    return this._collectible.index;\n  }\n\n  /**\n   * The collector key for this qualifier.\n   */\n  public get key(): QualifierName {\n    return this._collectible.key;\n  }\n\n  /**\n   * The default {@link ConditionPriority | priority} of conditions\n   * that depend on this qualifier.\n   */\n  public readonly defaultPriority: ConditionPriority;\n\n  protected readonly _collectible: Collections.Collectible<QualifierName, QualifierIndex>;\n\n  /**\n   * Constructs a new instance of a {@link Qualifiers.Qualifier | Qualifier} from the\n   * supplied {@link Qualifiers.IValidatedQualifierDecl | validated declaration}.\n   * @param name - The name of the qualifier.\n   * @param type - The {@link QualifierTypes.QualifierType | type} of the qualifier.\n   * @param defaultPriority - The default {@link ConditionPriority | priority} of conditions\n   * @public\n   */\n  protected constructor({\n    name,\n    token,\n    type,\n    defaultPriority,\n    tokenIsOptional,\n    index\n  }: IValidatedQualifierDecl) {\n    this.name = name;\n    this.token = token;\n    this.type = type;\n    this.defaultPriority = defaultPriority;\n    this.tokenIsOptional = tokenIsOptional;\n    this._collectible = new Collections.Collectible<QualifierName, QualifierIndex>({\n      key: name,\n      index,\n      indexConverter: CommonConvert.qualifierIndex\n    });\n  }\n\n  /**\n   * Creates a new instance of a {@link Qualifiers.Qualifier | Qualifier} from the\n   * supplied {@link Qualifiers.IValidatedQualifierDecl | validated declaration}.\n   * @param decl - The {@link Qualifiers.IValidatedQualifierDecl | validated declaration}\n   * for the new instance.\n   * @returns `Success` with the new {@link Qualifiers.Qualifier | Qualifier} if successful,\n   * `Failure` with an error message otherwise.\n   * @public\n   */\n  public static create(decl: IValidatedQualifierDecl): Result<Qualifier> {\n    return captureResult(() => new Qualifier(decl));\n  }\n\n  /**\n   * Sets the index of this qualifier.  Once set, the index cannot be changed.\n   * @param index - The index to set.\n   * @returns `Success` with the index if successful, `Failure` with an error message otherwise.\n   */\n  public setIndex(index: QualifierIndex): Result<QualifierIndex> {\n    return this._collectible.setIndex(index);\n  }\n}\n"]}
+{"version":3,"file":"qualifier.js","sourceRoot":"","sources":["../../../src/packlets/qualifiers/qualifier.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;;;AAEH,4CAAiF;AACjF,sCAQmB;AAInB;;;;GAIG;AACH,MAAa,SAAS;IA2BpB;;OAEG;IACH,IAAW,KAAK;QACd,OAAO,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC;IACjC,CAAC;IAED;;OAEG;IACH,IAAW,GAAG;QACZ,OAAO,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC;IAC/B,CAAC;IAUD;;;;;;;OAOG;IACH,YAAsB,EACpB,IAAI,EACJ,KAAK,EACL,IAAI,EACJ,eAAe,EACf,eAAe,EACf,YAAY,EACZ,KAAK,EACmB;QACxB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,eAAe,GAAG,eAAe,CAAC;QACvC,IAAI,CAAC,eAAe,GAAG,eAAe,CAAC;QACvC,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;QACjC,IAAI,CAAC,YAAY,GAAG,IAAI,sBAAW,CAAC,WAAW,CAAgC;YAC7E,GAAG,EAAE,IAAI;YACT,KAAK;YACL,cAAc,EAAE,gBAAa,CAAC,cAAc;SAC7C,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;OAQG;IACI,MAAM,CAAC,MAAM,CAAC,IAA6B;QAChD,OAAO,IAAA,wBAAa,EAAC,GAAG,EAAE,CAAC,IAAI,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;IAClD,CAAC;IAED;;;;OAIG;IACI,QAAQ,CAAC,KAAqB;QACnC,OAAO,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC3C,CAAC;IAED;;OAEG;IACI,mBAAmB,CAAC,KAAa;QACtC,OAAO,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC;IAC9C,CAAC;IAED;;OAEG;IACI,qBAAqB,CAAC,KAAa;QACxC,OAAO,IAAI,CAAC,IAAI,CAAC,qBAAqB,CAAC,KAAK,CAAC,CAAC;IAChD,CAAC;IAED;;OAEG;IACI,iBAAiB,CAAC,KAAa,EAAE,QAA4B;QAClE,OAAO,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IACtD,CAAC;IAED;;OAEG;IACI,oBAAoB,CAAC,KAAa;QACvC,OAAO,IAAI,CAAC,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC;IAC/C,CAAC;CACF;AAhID,8BAgIC","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, Collections, ICollectible, Result } from '@fgv/ts-utils';\nimport {\n  ConditionPriority,\n  QualifierIndex,\n  QualifierName,\n  Convert as CommonConvert,\n  QualifierContextValue,\n  QualifierConditionValue,\n  ConditionOperator\n} from '../common';\nimport { QualifierType } from '../qualifier-types';\nimport { IValidatedQualifierDecl } from './qualifierDecl';\n\n/**\n * Represents a qualifier that can be used to identify the context in\n * which a resource is used.\n * @public\n */\nexport class Qualifier implements IValidatedQualifierDecl, ICollectible<QualifierName, QualifierIndex> {\n  /**\n   * The name of the qualifier.\n   */\n  public readonly name: QualifierName;\n\n  /**\n   * The token used to identify the qualifier in the name or\n   * path of a resource being imported.\n   */\n  public readonly token: QualifierName;\n\n  /**\n   * The {@link QualifierTypes.QualifierType | type} of the qualifier.\n   */\n  public readonly type: QualifierType;\n\n  /**\n   * Indicates whether the token is optional in the name or path of a resource being imported.\n   */\n  public readonly tokenIsOptional: boolean;\n\n  /**\n   * Optional default value for the qualifier.\n   */\n  public readonly defaultValue?: QualifierContextValue;\n\n  /**\n   * The index of the qualifier.\n   */\n  public get index(): QualifierIndex | undefined {\n    return this._collectible.index;\n  }\n\n  /**\n   * The collector key for this qualifier.\n   */\n  public get key(): QualifierName {\n    return this._collectible.key;\n  }\n\n  /**\n   * The default {@link ConditionPriority | priority} of conditions\n   * that depend on this qualifier.\n   */\n  public readonly defaultPriority: ConditionPriority;\n\n  protected readonly _collectible: Collections.Collectible<QualifierName, QualifierIndex>;\n\n  /**\n   * Constructs a new instance of a {@link Qualifiers.Qualifier | Qualifier} from the\n   * supplied {@link Qualifiers.IValidatedQualifierDecl | validated declaration}.\n   * @param name - The name of the qualifier.\n   * @param type - The {@link QualifierTypes.QualifierType | type} of the qualifier.\n   * @param defaultPriority - The default {@link ConditionPriority | priority} of conditions\n   * @public\n   */\n  protected constructor({\n    name,\n    token,\n    type,\n    defaultPriority,\n    tokenIsOptional,\n    defaultValue,\n    index\n  }: IValidatedQualifierDecl) {\n    this.name = name;\n    this.token = token;\n    this.type = type;\n    this.defaultPriority = defaultPriority;\n    this.tokenIsOptional = tokenIsOptional;\n    this.defaultValue = defaultValue;\n    this._collectible = new Collections.Collectible<QualifierName, QualifierIndex>({\n      key: name,\n      index,\n      indexConverter: CommonConvert.qualifierIndex\n    });\n  }\n\n  /**\n   * Creates a new instance of a {@link Qualifiers.Qualifier | Qualifier} from the\n   * supplied {@link Qualifiers.IValidatedQualifierDecl | validated declaration}.\n   * @param decl - The {@link Qualifiers.IValidatedQualifierDecl | validated declaration}\n   * for the new instance.\n   * @returns `Success` with the new {@link Qualifiers.Qualifier | Qualifier} if successful,\n   * `Failure` with an error message otherwise.\n   * @public\n   */\n  public static create(decl: IValidatedQualifierDecl): Result<Qualifier> {\n    return captureResult(() => new Qualifier(decl));\n  }\n\n  /**\n   * Sets the index of this qualifier.  Once set, the index cannot be changed.\n   * @param index - The index to set.\n   * @returns `Success` with the index if successful, `Failure` with an error message otherwise.\n   */\n  public setIndex(index: QualifierIndex): Result<QualifierIndex> {\n    return this._collectible.setIndex(index);\n  }\n\n  /**\n   * {@inheritdoc QualifierTypes.QualifierType.isValidContextValue}\n   */\n  public isValidContextValue(value: string): value is QualifierContextValue {\n    return this.type.isValidContextValue(value);\n  }\n\n  /**\n   * {@inheritdoc QualifierTypes.QualifierType.isValidConditionValue}\n   */\n  public isValidConditionValue(value: string): value is QualifierConditionValue {\n    return this.type.isValidConditionValue(value);\n  }\n\n  /**\n   * {@inheritdoc QualifierTypes.QualifierType.validateCondition}\n   */\n  public validateCondition(value: string, operator?: ConditionOperator): Result<QualifierConditionValue> {\n    return this.type.validateCondition(value, operator);\n  }\n\n  /**\n   * {@inheritdoc QualifierTypes.QualifierType.validateContextValue}\n   */\n  public validateContextValue(value: string): Result<QualifierContextValue> {\n    return this.type.validateContextValue(value);\n  }\n}\n"]}

package/lib/packlets/qualifiers/qualifierCollector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"qualifierCollector.d.ts","sourceRoot":"","sources":["../../../src/packlets/qualifiers/qualifierCollector.ts"],"names":[],"mappings":"AAuBA,OAAO,EAEL,WAAW,EAEX,MAAM,EAIN,6BAA6B,EAC9B,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,cAAc,EAA2B,MAAM,iBAAiB,CAAC;AAC1E,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC,OAAO,EAAE,8BAA8B,EAAE,MAAM,oBAAoB,CAAC;AAEpE;;;GAGG;AACH,MAAM,WAAW,2BAA4B,SAAQ,WAAW,CAAC,4BAA4B,CAAC,SAAS,CAAC;IACtG;;OAEG;IACH,QAAQ,CAAC,cAAc,EAAE,8BAA8B,CAAC;IAExD;;;;OAIG;IACH,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC;IAEzD;;;;OAIG;IACH,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC;CAC9C;AAED;;;GAGG;AACH,MAAM,WAAW,+BAA+B;IAC9C;;;OAGG;IACH,cAAc,EAAE,8BAA8B,CAAC;IAE/C;;;OAGG;IACH,UAAU,CAAC,EAAE,cAAc,EAAE,CAAC;CAC/B;AAED;;;;;GAKG;AACH,qBAAa,kBACX,SAAQ,6BAA6B,CAAC,SAAS,EAAE,cAAc,CAC/D,YAAW,2BAA2B;IAEtC;;OAEG;IACI,cAAc,EAAE,8BAA8B,CAAC;IAEtD;;;;OAIG;IACH,SAAS,aAAa,MAAM,EAAE,+BAA+B;IAa7D;;;;OAIG;WACW,MAAM,CAAC,MAAM,EAAE,+BAA+B,GAAG,MAAM,CAAC,kBAAkB,CAAC;IAIzF;;OAEG;IACI,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAAC,SAAS,CAAC;IAW/D;;OAEG;IACI,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO;IAYnD;;;OAGG;IACI,UAAU,IAAI,2BAA2B;IAIhD;;;;;;;OAOG;IACH,SAAS,CAAC,iBAAiB,CAAC,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,cAAc,GAAG,MAAM,CAAC,SAAS,CAAC;CAqB1G"}
+{"version":3,"file":"qualifierCollector.d.ts","sourceRoot":"","sources":["../../../src/packlets/qualifiers/qualifierCollector.ts"],"names":[],"mappings":"AAuBA,OAAO,EAEL,WAAW,EAEX,MAAM,EAIN,6BAA6B,EAC9B,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,cAAc,EAA2B,MAAM,iBAAiB,CAAC;AAC1E,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAC1C,OAAO,EAAE,SAAS,EAAE,MAAM,aAAa,CAAC;AAExC,OAAO,EAAE,8BAA8B,EAAE,MAAM,oBAAoB,CAAC;AAEpE;;;GAGG;AACH,MAAM,WAAW,2BAA4B,SAAQ,WAAW,CAAC,4BAA4B,CAAC,SAAS,CAAC;IACtG;;OAEG;IACH,QAAQ,CAAC,cAAc,EAAE,8BAA8B,CAAC;IAExD;;;;OAIG;IACH,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC;IAEzD;;;;OAIG;IACH,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC;CAC9C;AAED;;;GAGG;AACH,MAAM,WAAW,+BAA+B;IAC9C;;;OAGG;IACH,cAAc,EAAE,8BAA8B,CAAC;IAE/C;;;OAGG;IACH,UAAU,CAAC,EAAE,cAAc,EAAE,CAAC;CAC/B;AAED;;;;;GAKG;AACH,qBAAa,kBACX,SAAQ,6BAA6B,CAAC,SAAS,EAAE,cAAc,CAC/D,YAAW,2BAA2B;IAEtC;;OAEG;IACI,cAAc,EAAE,8BAA8B,CAAC;IAEtD;;;;OAIG;IACH,SAAS,aAAa,MAAM,EAAE,+BAA+B;IAa7D;;;;OAIG;WACW,MAAM,CAAC,MAAM,EAAE,+BAA+B,GAAG,MAAM,CAAC,kBAAkB,CAAC;IAIzF;;OAEG;IACI,gBAAgB,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,CAAC,SAAS,CAAC;IAW/D;;OAEG;IACI,cAAc,CAAC,WAAW,EAAE,MAAM,GAAG,OAAO;IAcnD;;;OAGG;IACI,UAAU,IAAI,2BAA2B;IAIhD;;;;;;;OAOG;IACH,SAAS,CAAC,iBAAiB,CAAC,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,cAAc,GAAG,MAAM,CAAC,SAAS,CAAC;CAsB1G"}

package/lib/packlets/qualifiers/qualifierCollector.js

@@ -109,10 +109,12 @@ class QualifierCollector extends ts_utils_1.ValidatingConvertingCollector {
      * {@inheritdoc Qualifiers.IReadOnlyQualifierCollector.hasNameOrToken}
      */
     hasNameOrToken(nameOrToken) {
+        /* c8 ignore next 3 - functional code path tested but coverage intermittently missed */
         if (this.validating.has(nameOrToken)) {
             return true;
         }
         for (const q of this.values()) {
+            /* c8 ignore next 3 - functional code path tested but coverage intermittently missed */
             if (q.token === nameOrToken) {
                 return true;
             }
@@ -142,6 +144,7 @@ class QualifierCollector extends ts_utils_1.ValidatingConvertingCollector {
         return convert_1.validatedQualifierDecl
             .convert(decl, convertContext)
             .onSuccess((validated) => {
+            /* c8 ignore next 9 - coverage intermittently misses this block */
             if (this.hasNameOrToken(validated.token)) {
                 return (0, ts_utils_1.fail)(`Qualifier token '${validated.token}' is not unique or collides with name`);
             }