@fgv/ts-res 5.1.0-2 → 5.1.0-20

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

@@ -0,0 +1,64 @@
+"use strict";
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Convert = void 0;
+const Convert = __importStar(require("./convert"));
+exports.Convert = Convert;
+__exportStar(require("./json"), exports);
+//# sourceMappingURL=index.js.map

package/lib/packlets/qualifier-types/config/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/packlets/qualifier-types/config/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,mDAAqC;AAI5B,0BAAO;AAFhB,yCAAuB","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 './json';\n\nexport { Convert };\n"]}

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

@@ -0,0 +1,91 @@
+import { JsonObject } from '@fgv/ts-json-base';
+/**
+ * Templated configuration for {@link QualifierTypes.QualifierType | qualifier type} configuration.
+ * @public
+ */
+export interface IQualifierTypeConfig<T = JsonObject> {
+    name: string;
+    systemType: string;
+    configuration?: T;
+}
+/**
+ * Configuration for {@link QualifierTypes.LanguageQualifierType | language qualifier type} configuration.
+ * @public
+ */
+export interface ILanguageQualifierTypeConfig {
+    allowContextList?: boolean;
+}
+/**
+ * Declares a hierarchy of literal values. The keys are the names of the values, and the
+ * values are the names of their parents.
+ * @remarks
+ * The hierarchy is defined as a tree, where each value can have multiple children but
+ * only one parent. The root of the tree has no parent. The hierarchy is used to
+ * determine the relationship between values when matching conditions and contexts.
+ * @public
+ */
+export type LiteralValueHierarchyDecl<T extends string> = Record<T, T>;
+/**
+ * Configuration for {@link QualifierTypes.TerritoryQualifierType | territory qualifier type} configuration.
+ * @public
+ */
+export interface ITerritoryQualifierTypeConfig {
+    allowContextList?: boolean;
+    acceptLowercase?: boolean;
+    allowedTerritories?: string[];
+    /**
+     * Optional {@link QualifierTypes.Config.LiteralValueHierarchyDecl | hierarchy declaration}
+     * of territory values to use for matching. If not provided, no hierarchy will be used.
+     */
+    hierarchy?: LiteralValueHierarchyDecl<string>;
+}
+/**
+ * Configuration for {@link QualifierTypes.LiteralQualifierType | literal qualifier type} configuration.
+ * @public
+ */
+export interface ILiteralQualifierTypeConfig {
+    allowContextList?: boolean;
+    caseSensitive?: boolean;
+    enumeratedValues?: string[];
+    hierarchy?: LiteralValueHierarchyDecl<string>;
+}
+/**
+ * Discriminated configuration for {@link QualifierTypes.LanguageQualifierType | language qualifier type} configuration.
+ * @public
+ */
+export interface ISystemLanguageQualifierTypeConfig extends IQualifierTypeConfig<ILanguageQualifierTypeConfig> {
+    systemType: 'language';
+}
+/**
+ * Discriminated configuration for {@link QualifierTypes.TerritoryQualifierType | territory qualifier type} configuration.
+ * @public
+ */
+export interface ISystemTerritoryQualifierTypeConfig extends IQualifierTypeConfig<ITerritoryQualifierTypeConfig> {
+    systemType: 'territory';
+}
+/**
+ * Discriminated configuration for {@link QualifierTypes.LiteralQualifierType | literal qualifier type} configuration.
+ * @public
+ */
+export interface ISystemLiteralQualifierTypeConfig extends IQualifierTypeConfig<ILiteralQualifierTypeConfig> {
+    systemType: 'literal';
+}
+/**
+ * Discriminated configuration for {@link QualifierTypes.QualifierType | qualifier type} configuration.
+ * @public
+ */
+export type ISystemQualifierTypeConfig = ISystemLanguageQualifierTypeConfig | ISystemTerritoryQualifierTypeConfig | ISystemLiteralQualifierTypeConfig;
+/**
+ * A union of all qualifier type configurations.
+ * @public
+ */
+export type IAnyQualifierTypeConfig = IQualifierTypeConfig | ISystemQualifierTypeConfig;
+/**
+ * Checks if a {@link QualifierTypes.Config.IAnyQualifierTypeConfig | qualifier type configuration} is a
+ * {@link QualifierTypes.Config.ISystemQualifierTypeConfig | system qualifier type configuration}.
+ * @param config - The {@link QualifierTypes.Config.IAnyQualifierTypeConfig | qualifier type configuration} to check.
+ * @returns `true` if the configuration is a system qualifier type configuration, `false` otherwise.
+ * @public
+ */
+export declare function isSystemQualifierTypeConfig(config: IAnyQualifierTypeConfig): config is ISystemQualifierTypeConfig;
+//# sourceMappingURL=json.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"json.d.ts","sourceRoot":"","sources":["../../../../src/packlets/qualifier-types/config/json.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAE/C;;;GAGG;AACH,MAAM,WAAW,oBAAoB,CAAC,CAAC,GAAG,UAAU;IAClD,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,CAAC,CAAC;CACnB;AAED;;;GAGG;AACH,MAAM,WAAW,4BAA4B;IAC3C,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,yBAAyB,CAAC,CAAC,SAAS,MAAM,IAAI,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAEvE;;;GAGG;AACH,MAAM,WAAW,6BAA6B;IAC5C,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAE3B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,kBAAkB,CAAC,EAAE,MAAM,EAAE,CAAC;IAE9B;;;OAGG;IACH,SAAS,CAAC,EAAE,yBAAyB,CAAC,MAAM,CAAC,CAAC;CAC/C;AAED;;;GAGG;AACH,MAAM,WAAW,2BAA2B;IAC1C,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC5B,SAAS,CAAC,EAAE,yBAAyB,CAAC,MAAM,CAAC,CAAC;CAC/C;AAED;;;GAGG;AACH,MAAM,WAAW,kCACf,SAAQ,oBAAoB,CAAC,4BAA4B,CAAC;IAC1D,UAAU,EAAE,UAAU,CAAC;CACxB;AAED;;;GAGG;AACH,MAAM,WAAW,mCACf,SAAQ,oBAAoB,CAAC,6BAA6B,CAAC;IAC3D,UAAU,EAAE,WAAW,CAAC;CACzB;AAED;;;GAGG;AACH,MAAM,WAAW,iCAAkC,SAAQ,oBAAoB,CAAC,2BAA2B,CAAC;IAC1G,UAAU,EAAE,SAAS,CAAC;CACvB;AAED;;;GAGG;AACH,MAAM,MAAM,0BAA0B,GAClC,kCAAkC,GAClC,mCAAmC,GACnC,iCAAiC,CAAC;AAEtC;;;GAGG;AACH,MAAM,MAAM,uBAAuB,GAAG,oBAAoB,GAAG,0BAA0B,CAAC;AAExF;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CACzC,MAAM,EAAE,uBAAuB,GAC9B,MAAM,IAAI,0BAA0B,CAItC"}

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

@@ -0,0 +1,35 @@
+"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.isSystemQualifierTypeConfig = isSystemQualifierTypeConfig;
+/**
+ * Checks if a {@link QualifierTypes.Config.IAnyQualifierTypeConfig | qualifier type configuration} is a
+ * {@link QualifierTypes.Config.ISystemQualifierTypeConfig | system qualifier type configuration}.
+ * @param config - The {@link QualifierTypes.Config.IAnyQualifierTypeConfig | qualifier type configuration} to check.
+ * @returns `true` if the configuration is a system qualifier type configuration, `false` otherwise.
+ * @public
+ */
+function isSystemQualifierTypeConfig(config) {
+    return (config.systemType === 'language' || config.systemType === 'territory' || config.systemType === 'literal');
+}
+//# sourceMappingURL=json.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"json.js","sourceRoot":"","sources":["../../../../src/packlets/qualifier-types/config/json.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;;AA6GH,kEAMC;AAbD;;;;;;GAMG;AACH,SAAgB,2BAA2B,CACzC,MAA+B;IAE/B,OAAO,CACL,MAAM,CAAC,UAAU,KAAK,UAAU,IAAI,MAAM,CAAC,UAAU,KAAK,WAAW,IAAI,MAAM,CAAC,UAAU,KAAK,SAAS,CACzG,CAAC;AACJ,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 { JsonObject } from '@fgv/ts-json-base';\n\n/**\n * Templated configuration for {@link QualifierTypes.QualifierType | qualifier type} configuration.\n * @public\n */\nexport interface IQualifierTypeConfig<T = JsonObject> {\n  name: string;\n  systemType: string;\n  configuration?: T;\n}\n\n/**\n * Configuration for {@link QualifierTypes.LanguageQualifierType | language qualifier type} configuration.\n * @public\n */\nexport interface ILanguageQualifierTypeConfig {\n  allowContextList?: boolean;\n}\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> = Record<T, T>;\n\n/**\n * Configuration for {@link QualifierTypes.TerritoryQualifierType | territory qualifier type} configuration.\n * @public\n */\nexport interface ITerritoryQualifierTypeConfig {\n  allowContextList?: boolean;\n\n  acceptLowercase?: boolean;\n  allowedTerritories?: string[];\n\n  /**\n   * Optional {@link QualifierTypes.Config.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 * Configuration for {@link QualifierTypes.LiteralQualifierType | literal qualifier type} configuration.\n * @public\n */\nexport interface ILiteralQualifierTypeConfig {\n  allowContextList?: boolean;\n  caseSensitive?: boolean;\n  enumeratedValues?: string[];\n  hierarchy?: LiteralValueHierarchyDecl<string>;\n}\n\n/**\n * Discriminated configuration for {@link QualifierTypes.LanguageQualifierType | language qualifier type} configuration.\n * @public\n */\nexport interface ISystemLanguageQualifierTypeConfig\n  extends IQualifierTypeConfig<ILanguageQualifierTypeConfig> {\n  systemType: 'language';\n}\n\n/**\n * Discriminated configuration for {@link QualifierTypes.TerritoryQualifierType | territory qualifier type} configuration.\n * @public\n */\nexport interface ISystemTerritoryQualifierTypeConfig\n  extends IQualifierTypeConfig<ITerritoryQualifierTypeConfig> {\n  systemType: 'territory';\n}\n\n/**\n * Discriminated configuration for {@link QualifierTypes.LiteralQualifierType | literal qualifier type} configuration.\n * @public\n */\nexport interface ISystemLiteralQualifierTypeConfig extends IQualifierTypeConfig<ILiteralQualifierTypeConfig> {\n  systemType: 'literal';\n}\n\n/**\n * Discriminated configuration for {@link QualifierTypes.QualifierType | qualifier type} configuration.\n * @public\n */\nexport type ISystemQualifierTypeConfig =\n  | ISystemLanguageQualifierTypeConfig\n  | ISystemTerritoryQualifierTypeConfig\n  | ISystemLiteralQualifierTypeConfig;\n\n/**\n * A union of all qualifier type configurations.\n * @public\n */\nexport type IAnyQualifierTypeConfig = IQualifierTypeConfig | ISystemQualifierTypeConfig;\n\n/**\n * Checks if a {@link QualifierTypes.Config.IAnyQualifierTypeConfig | qualifier type configuration} is a\n * {@link QualifierTypes.Config.ISystemQualifierTypeConfig | system qualifier type configuration}.\n * @param config - The {@link QualifierTypes.Config.IAnyQualifierTypeConfig | qualifier type configuration} to check.\n * @returns `true` if the configuration is a system qualifier type configuration, `false` otherwise.\n * @public\n */\nexport function isSystemQualifierTypeConfig(\n  config: IAnyQualifierTypeConfig\n): config is ISystemQualifierTypeConfig {\n  return (\n    config.systemType === 'language' || config.systemType === 'territory' || config.systemType === 'literal'\n  );\n}\n"]}

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

@@ -0,0 +1 @@
+{"version":3,"file":"convert.d.ts","sourceRoot":"","sources":["../../../src/packlets/qualifier-types/convert.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAE,SAAS,EAA4B,MAAM,eAAe,CAAC;AACpE,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,8BAA8B,EAAE,MAAM,0BAA0B,CAAC;AAC1E,OAAO,EAAE,kCAAkC,EAAE,MAAM,yBAAyB,CAAC;AAE7E;;;;GAIG;AACH,MAAM,WAAW,4BAA4B;IAC3C,cAAc,EAAE,8BAA8B,CAAC;CAChD;AAED;;;;;GAKG;AAEH,eAAO,MAAM,aAAa,gGAgBzB,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,iCAAiC,CAAC,CAAC,SAAS,MAAM,EAChE,cAAc,EAAE,SAAS,CAAC,CAAC,CAAC,GAC3B,SAAS,CAAC,kCAAkC,CAAC,CAAC,CAAC,CAAC,CAOlD"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"convert.js","sourceRoot":"","sources":["../../../src/packlets/qualifier-types/convert.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;;;AA+CH,8EASC;AAtDD,4CAAoE;AAcpE;;;;;GAKG;AACH,kDAAkD;AACrC,QAAA,aAAa,GAAG,qBAAU,CAAC,OAAO,CAC7C,CACE,IAAa,EACb,MAA8D,EAC9D,OAAsC,EACf,EAAE;IACzB,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO,IAAA,eAAI,EAAC,4CAA4C,CAAC,CAAC;IAC5D,CAAC;IACD,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;QAC7B,OAAO,OAAO,CAAC,cAAc,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACrD,CAAC;SAAM,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;QACpC,OAAO,OAAO,CAAC,cAAc,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC5C,CAAC;IACD,OAAO,IAAA,eAAI,EAAC,qDAAqD,CAAC,CAAC;AACrE,CAAC,CACF,CAAC;AAEF;;;;;GAKG;AACH,SAAgB,iCAAiC,CAC/C,cAA4B;IAE5B,OAAO,qBAAU,CAAC,MAAM,CAAwC;QAC9D,MAAM,EAAE,qBAAU,CAAC,OAAO,CAAC,cAAc,CAAC;QAC1C,SAAS,EAAE,qBAAU,CAAC,QAAQ,CAAC,cAAc,EAAE;YAC7C,YAAY,EAAE,cAAc;SAC7B,CAAC;KACH,CAAC,CAAC;AACL,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 { Converter, Converters, Result, fail } from '@fgv/ts-utils';\nimport { QualifierType } from './qualifierType';\nimport { ReadOnlyQualifierTypeCollector } from './qualifierTypeCollector';\nimport { ILiteralValueHierarchyCreateParams } from './literalValueHierarchy';\n\n/**\n * Context necessary to convert a qualifier name or number to an instantiated\n * {@link QualifierTypes.QualifierType}.\n * @public\n */\nexport interface IQualifierTypeConvertContext {\n  qualifierTypes: ReadOnlyQualifierTypeCollector;\n}\n\n/**\n * Converter for {@link QualifierTypes.QualifierType | QualifierType} objects,\n * retrieves a {@link QualifierTypes.QualifierType | QualifierType} by name or\n * index from a supplied {@link QualifierTypes.Convert.IQualifierTypeConvertContext | conversion context}.\n * @public\n */\n// eslint-disable-next-line @rushstack/typedef-var\nexport const qualifierType = Converters.generic<QualifierType, IQualifierTypeConvertContext>(\n  (\n    from: unknown,\n    __self: Converter<QualifierType, IQualifierTypeConvertContext>,\n    context?: IQualifierTypeConvertContext\n  ): Result<QualifierType> => {\n    if (!context) {\n      return fail('qualifierType converter requires a context');\n    }\n    if (typeof from === 'string') {\n      return context.qualifierTypes.validating.get(from);\n    } else if (typeof from === 'number') {\n      return context.qualifierTypes.getAt(from);\n    }\n    return fail('qualifierType converter requires a string or number');\n  }\n);\n\n/**\n * Gets a converter for {@link QualifierTypes.ILiteralValueHierarchyCreateParams | ILiteralValueHierarchyCreateParams}\n * objects with values validated by a supplied value converter.\n * @param valueConverter - Converter for the literal value type.\n * @public\n */\nexport function literalValueHierarchyCreateParams<T extends string>(\n  valueConverter: Converter<T>\n): Converter<ILiteralValueHierarchyCreateParams<T>> {\n  return Converters.object<ILiteralValueHierarchyCreateParams<T>>({\n    values: Converters.arrayOf(valueConverter),\n    hierarchy: Converters.recordOf(valueConverter, {\n      keyConverter: valueConverter\n    })\n  });\n}\n"]}

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

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/packlets/qualifier-types/helpers.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAQ,MAAM,EAAE,MAAM,eAAe,CAAC;AAC7C,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAE9D;;;;;GAKG;AACH,MAAM,MAAM,mBAAmB,GAAG,qBAAqB,GAAG,sBAAsB,GAAG,oBAAoB,CAAC;AAExG;;;;;;;;;GASG;AACH,wBAAgB,6BAA6B,CAC3C,UAAU,EAAE,MAAM,CAAC,uBAAuB,GACzC,MAAM,CAAC,aAAa,CAAC,CAyBvB;AAED;;;;;;;;;GASG;AACH,wBAAgB,mCAAmC,CACjD,UAAU,EAAE,MAAM,CAAC,0BAA0B,GAC5C,MAAM,CAAC,mBAAmB,CAAC,CAa7B"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.js","sourceRoot":"","sources":["../../../src/packlets/qualifier-types/helpers.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BH,sEA2BC;AAYD,kFAeC;AA/ED,4CAA6C;AAC7C,iDAAmC;AAEnC,mEAAgE;AAChE,qEAAkE;AAClE,iEAA8D;AAU9D;;;;;;;;;GASG;AACH,SAAgB,6BAA6B,CAC3C,UAA0C;;IAE1C,yCAAyC;IACzC,MAAM,WAAW,GAAG,MAAA,UAAU,CAAC,aAAa,mCAAI,EAAE,CAAC;IACnD,QAAQ,UAAU,CAAC,UAAU,EAAE,CAAC;QAC9B,KAAK,UAAU;YACb,OAAO,MAAM,CAAC,OAAO,CAAC,2BAA2B;iBAC9C,OAAO,CAAC,WAAW,CAAC;iBACpB,SAAS,CAAC,CAAC,aAAa,EAAE,EAAE,CAC3B,6CAAqB,CAAC,gBAAgB,iCAAM,UAAU,KAAE,aAAa,IAAG,CACzE,CAAC;QACN,KAAK,WAAW;YACd,OAAO,MAAM,CAAC,OAAO,CAAC,4BAA4B;iBAC/C,OAAO,CAAC,WAAW,CAAC;iBACpB,SAAS,CAAC,CAAC,aAAa,EAAE,EAAE,CAC3B,+CAAsB,CAAC,gBAAgB,iCAAM,UAAU,KAAE,aAAa,IAAG,CAC1E,CAAC;QACN,KAAK,SAAS;YACZ,OAAO,MAAM,CAAC,OAAO,CAAC,0BAA0B;iBAC7C,OAAO,CAAC,WAAW,CAAC;iBACpB,SAAS,CAAC,CAAC,aAAa,EAAE,EAAE,CAC3B,2CAAoB,CAAC,gBAAgB,iCAAM,UAAU,KAAE,aAAa,IAAG,CACxE,CAAC;IACR,CAAC;IACD,yCAAyC;IACzC,OAAO,IAAA,eAAI,EAAC,2BAA2B,UAAU,CAAC,UAAU,EAAE,CAAC,CAAC;AAClE,CAAC;AAED;;;;;;;;;GASG;AACH,SAAgB,mCAAmC,CACjD,UAA6C;IAE7C,MAAM,EAAE,UAAU,EAAE,GAAG,UAAU,CAAC;IAClC,QAAQ,UAAU,EAAE,CAAC;QACnB,KAAK,UAAU;YACb,OAAO,6CAAqB,CAAC,gBAAgB,CAAC,UAAU,CAAC,CAAC;QAC5D,KAAK,WAAW;YACd,OAAO,+CAAsB,CAAC,gBAAgB,CAAC,UAAU,CAAC,CAAC;QAC7D,KAAK,SAAS;YACZ,OAAO,2CAAoB,CAAC,gBAAgB,CAAC,UAAU,CAAC,CAAC;IAC7D,CAAC;IACD,0CAA0C;IAC1C,mBAAmB;IACnB,OAAO,IAAA,eAAI,EAAC,GAAG,UAAU,kCAAkC,CAAC,CAAC;AAC/D,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 { fail, Result } from '@fgv/ts-utils';\nimport * as Config from './config';\nimport { QualifierType } from './qualifierType';\nimport { LanguageQualifierType } from './languageQualifierType';\nimport { TerritoryQualifierType } from './territoryQualifierType';\nimport { LiteralQualifierType } from './literalQualifierType';\n\n/**\n * A discriminated union of all system qualifier types.\n * This allows TypeScript to properly discriminate between specific qualifier type implementations\n * and access their specific methods like getConfiguration().\n * @public\n */\nexport type SystemQualifierType = LanguageQualifierType | TerritoryQualifierType | LiteralQualifierType;\n\n/**\n * Creates a {@link QualifierTypes.QualifierType | QualifierType} from a configuration object.\n * This factory function determines the appropriate qualifier type based on the systemType\n * and delegates to the appropriate type-specific createFromConfig method.\n * @param typeConfig - The {@link QualifierTypes.Config.IQualifierTypeConfig | configuration object}\n * containing the name, systemType, and optional type-specific configuration.\n * @returns `Success` with the new {@link QualifierTypes.QualifierType | QualifierType}\n * if successful, `Failure` with an error message otherwise.\n * @public\n */\nexport function createQualifierTypeFromConfig(\n  typeConfig: Config.IAnyQualifierTypeConfig\n): Result<QualifierType> {\n  /* c8 ignore next 1 - defense in depth */\n  const childConfig = typeConfig.configuration ?? {};\n  switch (typeConfig.systemType) {\n    case 'language':\n      return Config.Convert.languageQualifierTypeConfig\n        .convert(childConfig)\n        .onSuccess((configuration) =>\n          LanguageQualifierType.createFromConfig({ ...typeConfig, configuration })\n        );\n    case 'territory':\n      return Config.Convert.territoryQualifierTypeConfig\n        .convert(childConfig)\n        .onSuccess((configuration) =>\n          TerritoryQualifierType.createFromConfig({ ...typeConfig, configuration })\n        );\n    case 'literal':\n      return Config.Convert.literalQualifierTypeConfig\n        .convert(childConfig)\n        .onSuccess((configuration) =>\n          LiteralQualifierType.createFromConfig({ ...typeConfig, configuration })\n        );\n  }\n  /* c8 ignore next 1 - defense in depth */\n  return fail(`Unknown qualifier type: ${typeConfig.systemType}`);\n}\n\n/**\n * Creates a {@link QualifierTypes.SystemQualifierType | SystemQualifierType} from a system configuration object.\n * This factory function determines the appropriate qualifier type based on the systemType\n * and delegates to the appropriate type-specific createFromConfig method.\n * @param typeConfig - The {@link QualifierTypes.Config.ISystemQualifierTypeConfig | configuration object}\n * containing the name, systemType, and optional type-specific configuration.\n * @returns `Success` with the new {@link QualifierTypes.SystemQualifierType | SystemQualifierType}\n * if successful, `Failure` with an error message otherwise.\n * @public\n */\nexport function createQualifierTypeFromSystemConfig(\n  typeConfig: Config.ISystemQualifierTypeConfig\n): Result<SystemQualifierType> {\n  const { systemType } = typeConfig;\n  switch (systemType) {\n    case 'language':\n      return LanguageQualifierType.createFromConfig(typeConfig);\n    case 'territory':\n      return TerritoryQualifierType.createFromConfig(typeConfig);\n    case 'literal':\n      return LiteralQualifierType.createFromConfig(typeConfig);\n  }\n  /* c8 ignore next 3 - should not happen */\n  // @ts-expect-error\n  return fail(`${systemType}: Unknown system qualifier type.`);\n}\n"]}

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/packlets/qualifier-types/index.ts"],"names":[],"mappings":"AAsBA,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC;AAErC,cAAc,iBAAiB,CAAC;AAChC,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,WAAW,CAAC;AAE1B,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC"}

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/packlets/qualifier-types/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAEH,iDAAmC;AAW1B,wBAAM;AAVf,mDAAqC;AAUpB,0BAAO;AARxB,kDAAgC;AAChC,0DAAwC;AACxC,yDAAuC;AACvC,0DAAwC;AACxC,2DAAyC;AACzC,2DAAyC;AACzC,4CAA0B","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 Config from './config';\nimport * as Convert from './convert';\n\nexport * from './qualifierType';\nexport * from './languageQualifierType';\nexport * from './literalQualifierType';\nexport * from './literalValueHierarchy';\nexport * from './territoryQualifierType';\nexport * from './qualifierTypeCollector';\nexport * from './helpers';\n\nexport { Config, Convert };\n"]}

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

@@ -27,14 +27,13 @@ export interface ILanguageQualifierTypeCreateParams extends Partial<IQualifierTy
  */
 export declare class LanguageQualifierType extends QualifierType<JsonCompatibleType<Config.ILanguageQualifierTypeConfig>> {
     /**
-     * {@inheritdoc QualifierTypes.IQualifierType.systemTypeName}
+     * {@inheritDoc QualifierTypes.IQualifierType.systemTypeName}
      */
     readonly systemTypeName: QualifierTypeName;
     /**
      * Creates a new instance of a {@link QualifierTypes.LanguageQualifierType | language qualifier type}.
-     * @param name - Optional name for the qualifier type. Defaults to 'language'.
-     * @param allowContextList - Optional flag indicating whether the context can be a
-     * list of values. Defaults to `true`.
+     * @param params - The {@link QualifierTypes.ILanguageQualifierTypeCreateParams | create parameters}
+     * for this qualifier type.
      * @public
      */
     protected constructor({ name, allowContextList, index }: ILanguageQualifierTypeCreateParams);
@@ -56,7 +55,7 @@ export declare class LanguageQualifierType extends QualifierType<JsonCompatibleT
      */
     static createFromConfig(config: Config.IQualifierTypeConfig<Config.ILanguageQualifierTypeConfig>): Result<LanguageQualifierType>;
     /**
-     * {@inheritdoc QualifierTypes.IQualifierType.isValidConditionValue}
+     * {@inheritDoc QualifierTypes.IQualifierType.isValidConditionValue}
      */
     isValidConditionValue(value: string): value is QualifierConditionValue;
     /**
@@ -66,11 +65,11 @@ export declare class LanguageQualifierType extends QualifierType<JsonCompatibleT
      */
     getConfiguration(): Result<Config.ISystemLanguageQualifierTypeConfig>;
     /**
-     * {@inheritdoc QualifierTypes.IQualifierType.getConfigurationJson}
+     * {@inheritDoc QualifierTypes.IQualifierType.getConfigurationJson}
      */
     getConfigurationJson(): Result<JsonCompatibleType<Config.ISystemLanguageQualifierTypeConfig>>;
     /**
-     * {@inheritdoc QualifierTypes.IQualifierType.validateConfigurationJson}
+     * {@inheritDoc QualifierTypes.IQualifierType.validateConfigurationJson}
      */
     validateConfigurationJson(from: unknown): Result<JsonCompatibleType<Config.ISystemLanguageQualifierTypeConfig>>;
     /**

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

@@ -0,0 +1 @@
+{"version":3,"file":"languageQualifierType.d.ts","sourceRoot":"","sources":["../../../src/packlets/qualifier-types/languageQualifierType.ts"],"names":[],"mappings":"AAsBA,OAAO,EAAE,MAAM,EAA0B,MAAM,eAAe,CAAC;AAE/D,OAAO,EACL,iBAAiB,EAGjB,uBAAuB,EACvB,qBAAqB,EACrB,mBAAmB,EACnB,iBAAiB,EAElB,MAAM,WAAW,CAAC;AACnB,OAAO,EAAE,0BAA0B,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAC5E,OAAO,KAAK,MAAM,MAAM,UAAU,CAAC;AACnC,OAAO,EAAE,kBAAkB,EAAsB,MAAM,mBAAmB,CAAC;AAE3E;;;;GAIG;AACH,MAAM,WAAW,kCAAmC,SAAQ,OAAO,CAAC,0BAA0B,CAAC;IAC7F;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd;;;OAGG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B;AAED;;;;;GAKG;AACH,qBAAa,qBAAsB,SAAQ,aAAa,CACtD,kBAAkB,CAAC,MAAM,CAAC,4BAA4B,CAAC,CACxD;IACC;;OAEG;IACH,SAAgB,cAAc,EAAE,iBAAiB,CAA2D;IAE5G;;;;;OAKG;IACH,SAAS,aAAa,EAAE,IAAI,EAAE,gBAAgB,EAAE,KAAK,EAAE,EAAE,kCAAkC;IAa3F;;;;;;OAMG;WACW,MAAM,CAAC,MAAM,CAAC,EAAE,kCAAkC,GAAG,MAAM,CAAC,qBAAqB,CAAC;IAMhG;;;;;;;OAOG;WACW,gBAAgB,CAC5B,MAAM,EAAE,MAAM,CAAC,oBAAoB,CAAC,MAAM,CAAC,4BAA4B,CAAC,GACvE,MAAM,CAAC,qBAAqB,CAAC;IAOhC;;OAEG;IACI,qBAAqB,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,uBAAuB;IAM7E;;;;OAIG;IACI,gBAAgB,IAAI,MAAM,CAAC,MAAM,CAAC,kCAAkC,CAAC;IAM5E;;OAEG;IACI,oBAAoB,IAAI,MAAM,CAAC,kBAAkB,CAAC,MAAM,CAAC,kCAAkC,CAAC,CAAC;IAUpG;;OAEG;IACI,yBAAyB,CAC9B,IAAI,EAAE,OAAO,GACZ,MAAM,CAAC,kBAAkB,CAAC,MAAM,CAAC,kCAAkC,CAAC,CAAC;IAIxE;;;;;OAKG;IACI,qBAAqB,CAAC,IAAI,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,kCAAkC,CAAC;IAI9F;;;;;;;OAOG;IACH,SAAS,CAAC,SAAS,CACjB,SAAS,EAAE,uBAAuB,EAClC,OAAO,EAAE,qBAAqB,EAC9B,QAAQ,EAAE,iBAAiB,GAC1B,mBAAmB;CASvB"}

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

@@ -70,9 +70,8 @@ const ts_json_base_1 = require("@fgv/ts-json-base");
 class LanguageQualifierType extends qualifierType_1.QualifierType {
     /**
      * Creates a new instance of a {@link QualifierTypes.LanguageQualifierType | language qualifier type}.
-     * @param name - Optional name for the qualifier type. Defaults to 'language'.
-     * @param allowContextList - Optional flag indicating whether the context can be a
-     * list of values. Defaults to `true`.
+     * @param params - The {@link QualifierTypes.ILanguageQualifierTypeCreateParams | create parameters}
+     * for this qualifier type.
      * @public
      */
     constructor({ name, allowContextList, index }) {
@@ -83,7 +82,7 @@ class LanguageQualifierType extends qualifierType_1.QualifierType {
         super(Object.assign({ name,
             allowContextList }, validated));
         /**
-         * {@inheritdoc QualifierTypes.IQualifierType.systemTypeName}
+         * {@inheritDoc QualifierTypes.IQualifierType.systemTypeName}
          */
         this.systemTypeName = common_1.Convert.qualifierTypeName.convert('language').orThrow();
     }
@@ -115,7 +114,7 @@ class LanguageQualifierType extends qualifierType_1.QualifierType {
         }).onSuccess(LanguageQualifierType.create);
     }
     /**
-     * {@inheritdoc QualifierTypes.IQualifierType.isValidConditionValue}
+     * {@inheritDoc QualifierTypes.IQualifierType.isValidConditionValue}
      */
     isValidConditionValue(value) {
         return ts_bcp47_1.Bcp47.tag(value)
@@ -131,7 +130,7 @@ class LanguageQualifierType extends qualifierType_1.QualifierType {
         return this.getConfigurationJson().onSuccess((json) => Config.Convert.systemLanguageQualifierTypeConfig.convert(json));
     }
     /**
-     * {@inheritdoc QualifierTypes.IQualifierType.getConfigurationJson}
+     * {@inheritDoc QualifierTypes.IQualifierType.getConfigurationJson}
      */
     getConfigurationJson() {
         return (0, ts_utils_1.succeed)({
@@ -143,7 +142,7 @@ class LanguageQualifierType extends qualifierType_1.QualifierType {
         });
     }
     /**
-     * {@inheritdoc QualifierTypes.IQualifierType.validateConfigurationJson}
+     * {@inheritDoc QualifierTypes.IQualifierType.validateConfigurationJson}
      */
     validateConfigurationJson(from) {
         return Config.Convert.systemLanguageQualifierTypeConfig.convert(from);

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

@@ -0,0 +1 @@
+{"version":3,"file":"languageQualifierType.js","sourceRoot":"","sources":["../../../src/packlets/qualifier-types/languageQualifierType.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2025 Erik Fortune\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\nimport { Result, captureResult, succeed } from '@fgv/ts-utils';\nimport { Bcp47 } from '@fgv/ts-bcp47';\nimport {\n  ConditionOperator,\n  Convert,\n  NoMatch,\n  QualifierConditionValue,\n  QualifierContextValue,\n  QualifierMatchScore,\n  QualifierTypeName,\n  Validate\n} from '../common';\nimport { IQualifierTypeCreateParams, QualifierType } from './qualifierType';\nimport * as Config from './config';\nimport { JsonCompatibleType, sanitizeJsonObject } from '@fgv/ts-json-base';\n\n/**\n * Interface defining the parameters that can be used to create a new\n * {@link QualifierTypes.LanguageQualifierType | LanguageQualifierType}.\n * @public\n */\nexport interface ILanguageQualifierTypeCreateParams extends Partial<IQualifierTypeCreateParams> {\n  /**\n   * Optional name for the qualifier type. Defaults to 'language'.\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/**\n * {@link QualifierTypes.QualifierType | Qualifier type} which matches BCP-47 language tags\n * applying {@link https://github.com/ErikFortune/fgv/tree/main/libraries/ts-bcp47#tag-matching | similarity matching}.\n * Accepts a list of language tags in the context by default.\n * @public\n */\nexport class LanguageQualifierType extends QualifierType<\n  JsonCompatibleType<Config.ILanguageQualifierTypeConfig>\n> {\n  /**\n   * {@inheritDoc QualifierTypes.IQualifierType.systemTypeName}\n   */\n  public readonly systemTypeName: QualifierTypeName = Convert.qualifierTypeName.convert('language').orThrow();\n\n  /**\n   * Creates a new instance of a {@link QualifierTypes.LanguageQualifierType | language qualifier type}.\n   * @param params - The {@link QualifierTypes.ILanguageQualifierTypeCreateParams | create parameters}\n   * for this qualifier type.\n   * @public\n   */\n  protected constructor({ name, allowContextList, index }: ILanguageQualifierTypeCreateParams) {\n    allowContextList = allowContextList !== false;\n    /* c8 ignore next 2 - coverage intermittently drops these two lines even though they're tested */\n    name = name ?? 'language';\n    const validated = index ? { index: Convert.qualifierTypeIndex.convert(index).orThrow() } : {};\n\n    super({\n      name,\n      allowContextList,\n      ...validated\n    });\n  }\n\n  /**\n   * Creates a new instance of a {@link QualifierTypes.LanguageQualifierType | language qualifier type}.\n   * @param params - Optional {@link QualifierTypes.ILanguageQualifierTypeCreateParams | parameters}\n   * to use when creating the new instance.\n   * @returns `Success` with the new {@link QualifierTypes.LanguageQualifierType | language qualifier type}\n   * if successful, `Failure` otherwise.\n   */\n  public static create(params?: ILanguageQualifierTypeCreateParams): Result<LanguageQualifierType> {\n    /* c8 ignore next 1 - coverage seems to intermittently miss the branch even though it's tested */\n    params = params ?? {};\n    return captureResult(() => new LanguageQualifierType(params));\n  }\n\n  /**\n   * Creates a new {@link QualifierTypes.LanguageQualifierType | LanguageQualifierType} from a configuration object.\n   * @param config - The {@link QualifierTypes.Config.IQualifierTypeConfig | configuration object} containing\n   * the name, systemType, and optional language-specific configuration.\n   * @returns `Success` with the new {@link QualifierTypes.LanguageQualifierType | LanguageQualifierType}\n   * if successful, `Failure` with an error message otherwise.\n   * @public\n   */\n  public static createFromConfig(\n    config: Config.IQualifierTypeConfig<Config.ILanguageQualifierTypeConfig>\n  ): Result<LanguageQualifierType> {\n    return sanitizeJsonObject<ILanguageQualifierTypeCreateParams>({\n      name: config.name,\n      allowContextList: config.configuration?.allowContextList === true\n    }).onSuccess(LanguageQualifierType.create);\n  }\n\n  /**\n   * {@inheritDoc QualifierTypes.IQualifierType.isValidConditionValue}\n   */\n  public isValidConditionValue(value: string): value is QualifierConditionValue {\n    return Bcp47.tag(value)\n      .onSuccess((tag) => succeed(tag.isValid))\n      .orDefault(false);\n  }\n\n  /**\n   * Gets a {@link QualifierTypes.Config.ISystemLanguageQualifierTypeConfig | strongly typed configuration object}\n   * for this qualifier type.\n   * @returns `Success` with the configuration if successful, `Failure` with an error message otherwise.\n   */\n  public getConfiguration(): Result<Config.ISystemLanguageQualifierTypeConfig> {\n    return this.getConfigurationJson().onSuccess((json) =>\n      Config.Convert.systemLanguageQualifierTypeConfig.convert(json)\n    );\n  }\n\n  /**\n   * {@inheritDoc QualifierTypes.IQualifierType.getConfigurationJson}\n   */\n  public getConfigurationJson(): Result<JsonCompatibleType<Config.ISystemLanguageQualifierTypeConfig>> {\n    return succeed({\n      name: this.name,\n      systemType: 'language' as const,\n      configuration: {\n        allowContextList: this.allowContextList\n      }\n    });\n  }\n\n  /**\n   * {@inheritDoc QualifierTypes.IQualifierType.validateConfigurationJson}\n   */\n  public validateConfigurationJson(\n    from: unknown\n  ): Result<JsonCompatibleType<Config.ISystemLanguageQualifierTypeConfig>> {\n    return Config.Convert.systemLanguageQualifierTypeConfig.convert(from);\n  }\n\n  /**\n   * Validates a {@link QualifierTypes.Config.ISystemLanguageQualifierTypeConfig | strongly typed configuration object}\n   * for this qualifier type.\n   * @param from - The unknown data to validate as a configuration object.\n   * @returns `Success` with the validated configuration if successful, `Failure` with an error message otherwise.\n   */\n  public validateConfiguration(from: unknown): Result<Config.ISystemLanguageQualifierTypeConfig> {\n    return Config.Convert.systemLanguageQualifierTypeConfig.convert(from);\n  }\n\n  /**\n   * Matches a single language condition against a single language context value using\n   * {@link https://github.com/ErikFortune/fgv/tree/main/libraries/ts-bcp47#tag-matching | similarity matching}.\n   * @param condition - The language condition value to match.\n   * @param context - The language context value to match against.\n   * @param operator - The operator to use for the match. Must be 'matches'.\n   * @returns The match score, or `noMatch` if the match fails.\n   */\n  protected _matchOne(\n    condition: QualifierConditionValue,\n    context: QualifierContextValue,\n    operator: ConditionOperator\n  ): QualifierMatchScore {\n    if (operator === 'matches') {\n      const similarity = Bcp47.similarity(condition, context).orDefault(Bcp47.tagSimilarity.none);\n      if (similarity > 0.0 && Validate.isValidQualifierMatchScore(similarity)) {\n        return similarity;\n      }\n    }\n    return NoMatch;\n  }\n}\n"]}

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

@@ -46,7 +46,7 @@ export interface ILiteralQualifierTypeCreateParams {
  */
 export declare class LiteralQualifierType extends QualifierType<JsonCompatibleType<Config.ILiteralQualifierTypeConfig>> {
     /**
-     * {@inheritdoc QualifierTypes.IQualifierType.systemTypeName}
+     * {@inheritDoc QualifierTypes.IQualifierType.systemTypeName}
      */
     readonly systemTypeName: QualifierTypeName;
     /**
@@ -64,11 +64,8 @@ export declare class LiteralQualifierType extends QualifierType<JsonCompatibleTy
     readonly hierarchy?: LiteralValueHierarchy<string>;
     /**
      * 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 params - The {@link QualifierTypes.ILiteralQualifierTypeCreateParams | create parameters}
+     * for this qualifier type.
      * @public
      */
     protected constructor({ name, caseSensitive, allowContextList, enumeratedValues, hierarchy, index }: ILiteralQualifierTypeCreateParams);
@@ -81,7 +78,7 @@ export declare class LiteralQualifierType extends QualifierType<JsonCompatibleTy
      */
     isValidConditionValue(value: string): value is QualifierConditionValue;
     /**
-     * {@inheritdoc QualifierTypes.IQualifierType.isPotentialMatch}
+     * {@inheritDoc QualifierTypes.IQualifierType.isPotentialMatch}
      */
     isPotentialMatch(conditionValue: string, contextValue: string): boolean;
     /**
@@ -91,11 +88,11 @@ export declare class LiteralQualifierType extends QualifierType<JsonCompatibleTy
      */
     getConfiguration(): Result<Config.ISystemLiteralQualifierTypeConfig>;
     /**
-     * {@inheritdoc QualifierTypes.IQualifierType.getConfigurationJson}
+     * {@inheritDoc QualifierTypes.IQualifierType.getConfigurationJson}
      */
     getConfigurationJson(): Result<JsonCompatibleType<Config.ISystemLiteralQualifierTypeConfig>>;
     /**
-     * {@inheritdoc QualifierTypes.IQualifierType.validateConfigurationJson}
+     * {@inheritDoc QualifierTypes.IQualifierType.validateConfigurationJson}
      */
     validateConfigurationJson(from: unknown): Result<JsonCompatibleType<Config.ISystemLiteralQualifierTypeConfig>>;
     /**
@@ -106,7 +103,7 @@ export declare class LiteralQualifierType extends QualifierType<JsonCompatibleTy
      */
     validateConfiguration(from: unknown): Result<Config.ISystemLiteralQualifierTypeConfig>;
     /**
-     * {@inheritdoc QualifierTypes.QualifierType._matchOne}
+     * {@inheritDoc QualifierTypes.QualifierType._matchOne}
      */
     protected _matchOne(condition: QualifierConditionValue, context: QualifierContextValue, __operator: ConditionOperator): QualifierMatchScore;
     /**

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

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

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

@@ -69,11 +69,8 @@ const ts_json_base_1 = require("@fgv/ts-json-base");
 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 params - The {@link QualifierTypes.ILiteralQualifierTypeCreateParams | create parameters}
+     * for this qualifier type.
      * @public
      */
     constructor({ name, caseSensitive, allowContextList, enumeratedValues, hierarchy, index }) {
@@ -84,7 +81,7 @@ class LiteralQualifierType extends qualifierType_1.QualifierType {
             index: index !== undefined ? common_1.Convert.qualifierTypeIndex.convert(index).orThrow() : undefined
         });
         /**
-         * {@inheritdoc QualifierTypes.IQualifierType.systemTypeName}
+         * {@inheritDoc QualifierTypes.IQualifierType.systemTypeName}
          */
         this.systemTypeName = common_1.Convert.qualifierTypeName.convert('literal').orThrow();
         this.caseSensitive = caseSensitive === true;
@@ -116,7 +113,7 @@ class LiteralQualifierType extends qualifierType_1.QualifierType {
         return LiteralQualifierType.isValidLiteralConditionValue(value);
     }
     /**
-     * {@inheritdoc QualifierTypes.IQualifierType.isPotentialMatch}
+     * {@inheritDoc QualifierTypes.IQualifierType.isPotentialMatch}
      */
     isPotentialMatch(conditionValue, contextValue) {
         if (this.isValidConditionValue(conditionValue) && this.isValidContextValue(contextValue)) {
@@ -138,7 +135,7 @@ class LiteralQualifierType extends qualifierType_1.QualifierType {
         return this.getConfigurationJson().onSuccess((json) => Config.Convert.systemLiteralQualifierTypeConfig.convert(json));
     }
     /**
-     * {@inheritdoc QualifierTypes.IQualifierType.getConfigurationJson}
+     * {@inheritDoc QualifierTypes.IQualifierType.getConfigurationJson}
      */
     getConfigurationJson() {
         const hierarchy = this.hierarchy ? { hierarchy: this.hierarchy.asRecord() } : {};
@@ -152,7 +149,7 @@ class LiteralQualifierType extends qualifierType_1.QualifierType {
         });
     }
     /**
-     * {@inheritdoc QualifierTypes.IQualifierType.validateConfigurationJson}
+     * {@inheritDoc QualifierTypes.IQualifierType.validateConfigurationJson}
      */
     validateConfigurationJson(from) {
         return Config.Convert.systemLiteralQualifierTypeConfig.convert(from);
@@ -167,7 +164,7 @@ class LiteralQualifierType extends qualifierType_1.QualifierType {
         return Config.Convert.systemLiteralQualifierTypeConfig.convert(from);
     }
     /**
-     * {@inheritdoc QualifierTypes.QualifierType._matchOne}
+     * {@inheritDoc QualifierTypes.QualifierType._matchOne}
      */
     _matchOne(condition, context, __operator) {
         if (this.hierarchy) {

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

@@ -0,0 +1 @@
+{"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  QualifierTypeName,\n  Validate\n} from '../common';\nimport { QualifierType } from './qualifierType';\nimport { LiteralValueHierarchy } from './literalValueHierarchy';\nimport * as Config from './config';\nimport { JsonCompatibleType, JsonObject, 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.Config.LiteralValueHierarchyDecl | hierarchy declaration}\n   * of literal values to use for matching. If not provided, no hierarchy will be used.\n   */\n  hierarchy?: Config.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  JsonCompatibleType<Config.ILiteralQualifierTypeConfig>\n> {\n  /**\n   * {@inheritDoc QualifierTypes.IQualifierType.systemTypeName}\n   */\n  public readonly systemTypeName: QualifierTypeName = Convert.qualifierTypeName.convert('literal').orThrow();\n\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 params - The {@link QualifierTypes.ILiteralQualifierTypeCreateParams | create parameters}\n   * for this qualifier type.\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.IQualifierType.isPotentialMatch}\n   */\n  public isPotentialMatch(conditionValue: string, contextValue: string): boolean {\n    if (this.isValidConditionValue(conditionValue) && this.isValidContextValue(contextValue)) {\n      if (this._matchOne(conditionValue, contextValue, 'matches') !== NoMatch) {\n        return true;\n      }\n      if (this.hierarchy) {\n        return this.hierarchy.isAncestor(conditionValue, contextValue);\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Gets a {@link QualifierTypes.Config.ISystemLiteralQualifierTypeConfig | strongly typed configuration object}\n   * for this qualifier type.\n   * @returns `Success` with the configuration if successful, `Failure` with an error message otherwise.\n   */\n  public getConfiguration(): Result<Config.ISystemLiteralQualifierTypeConfig> {\n    return this.getConfigurationJson().onSuccess((json) =>\n      Config.Convert.systemLiteralQualifierTypeConfig.convert(json)\n    );\n  }\n\n  /**\n   * {@inheritDoc QualifierTypes.IQualifierType.getConfigurationJson}\n   */\n  public getConfigurationJson(): Result<JsonCompatibleType<Config.ISystemLiteralQualifierTypeConfig>> {\n    const hierarchy: JsonObject = this.hierarchy ? { hierarchy: this.hierarchy.asRecord() } : {};\n    const enumeratedValues: JsonObject = this.enumeratedValues\n      ? { enumeratedValues: [...this.enumeratedValues] }\n      : {};\n    return succeed({\n      name: this.name,\n      systemType: 'literal' as const,\n      configuration: {\n        allowContextList: this.allowContextList,\n        caseSensitive: this.caseSensitive,\n        ...enumeratedValues,\n        ...hierarchy\n      }\n    });\n  }\n\n  /**\n   * {@inheritDoc QualifierTypes.IQualifierType.validateConfigurationJson}\n   */\n  public validateConfigurationJson(\n    from: unknown\n  ): Result<JsonCompatibleType<Config.ISystemLiteralQualifierTypeConfig>> {\n    return Config.Convert.systemLiteralQualifierTypeConfig.convert(from);\n  }\n\n  /**\n   * Validates a {@link QualifierTypes.Config.ISystemLiteralQualifierTypeConfig | strongly typed configuration object}\n   * for this qualifier type.\n   * @param from - The unknown data to validate as a configuration object.\n   * @returns `Success` with the validated configuration if successful, `Failure` with an error message otherwise.\n   */\n  public validateConfiguration(from: unknown): Result<Config.ISystemLiteralQualifierTypeConfig> {\n    return Config.Convert.systemLiteralQualifierTypeConfig.convert(from);\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}: invalid literal condition value.`);\n  }\n}\n"]}

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;AACnB,OAAO,EAAE,yBAAyB,EAAE,MAAM,UAAU,CAAC;AAErD;;;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,OAAO,CAAC,yBAAyB,CAAC,CAAC,CAAC,CAAC,CAAC;CACnD;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,UAAU,CAAC,KAAK,EAAE,CAAC,EAAE,gBAAgB,EAAE,CAAC,GAAG,OAAO;IASzD;;;;;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;IAoE3C;;;OAGG;IACI,QAAQ,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;CAM1C"}

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":"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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, 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';\nimport { LiteralValueHierarchyDecl } from './config';\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?: Partial<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 3 - 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   * Determines if a value is an ancestor of a possible ancestor value.\n   * @param value - The value to check.\n   * @param possibleAncestor - The possible ancestor value.\n   * @returns `true` if the value is an ancestor of the possible ancestor, `false` otherwise.\n   */\n  public isAncestor(value: T, possibleAncestor: T): boolean {\n    const ancestors = this.getAncestors(value);\n    if (ancestors.isSuccess()) {\n      return ancestors.value.includes(possibleAncestor);\n    }\n    /* c8 ignore next 2 - edge case: ancestor validation fallback */\n    return false;\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 3 - functional error case tested but coverage intermittently missed */\n      if (!this.values.has(condition as T)) {\n        return NoMatch;\n      }\n      /* c8 ignore next 3 - 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    /* c8 ignore next 1 - defense in depth */\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 invalid 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 4 - 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 3 - 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  /**\n   * Converts the hierarchy to a record of parent-child relationships.\n   * @returns A record of parent-child relationships.\n   */\n  public asRecord(): Record<string, string> {\n    const entries = Array.from(this.values.values())\n      .filter((v) => v.parent !== undefined)\n      .map((v) => [v.name, v.parent!.name]);\n    return Object.fromEntries(entries);\n  }\n}\n"]}