@fgv/ts-res 5.0.1-9 → 5.0.1

package/dist/packlets/qualifier-types/index.js

@@ -0,0 +1,32 @@
+/*
+ * 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.
+ */
+import * as Config from './config';
+import * as Convert from './convert';
+export * from './qualifierType';
+export * from './languageQualifierType';
+export * from './literalQualifierType';
+export * from './literalValueHierarchy';
+export * from './territoryQualifierType';
+export * from './qualifierTypeCollector';
+export * from './helpers';
+export { Config, Convert };
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,142 @@
+/*
+ * 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.
+ */
+import { captureResult, succeed } from '@fgv/ts-utils';
+import { Bcp47 } from '@fgv/ts-bcp47';
+import { Convert, NoMatch, Validate } from '../common';
+import { QualifierType } from './qualifierType';
+import * as Config from './config';
+import { sanitizeJsonObject } from '@fgv/ts-json-base';
+/**
+ * {@link QualifierTypes.QualifierType | Qualifier type} which matches BCP-47 language tags
+ * applying {@link https://github.com/ErikFortune/fgv/tree/main/libraries/ts-bcp47#tag-matching | similarity matching}.
+ * Accepts a list of language tags in the context by default.
+ * @public
+ */
+export class LanguageQualifierType extends 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`.
+     * @public
+     */
+    constructor({ name, allowContextList, index }) {
+        allowContextList = allowContextList !== false;
+        /* c8 ignore next 2 - coverage intermittently drops these two lines even though they're tested */
+        name = name !== null && name !== void 0 ? name : 'language';
+        const validated = index ? { index: Convert.qualifierTypeIndex.convert(index).orThrow() } : {};
+        super(Object.assign({ name,
+            allowContextList }, validated));
+        /**
+         * {@inheritdoc QualifierTypes.IQualifierType.systemTypeName}
+         */
+        this.systemTypeName = Convert.qualifierTypeName.convert('language').orThrow();
+    }
+    /**
+     * Creates a new instance of a {@link QualifierTypes.LanguageQualifierType | language qualifier type}.
+     * @param params - Optional {@link QualifierTypes.ILanguageQualifierTypeCreateParams | parameters}
+     * to use when creating the new instance.
+     * @returns `Success` with the new {@link QualifierTypes.LanguageQualifierType | language qualifier type}
+     * if successful, `Failure` otherwise.
+     */
+    static create(params) {
+        /* c8 ignore next 1 - coverage seems to intermittently miss the branch even though it's tested */
+        params = params !== null && params !== void 0 ? params : {};
+        return captureResult(() => new LanguageQualifierType(params));
+    }
+    /**
+     * Creates a new {@link QualifierTypes.LanguageQualifierType | LanguageQualifierType} from a configuration object.
+     * @param config - The {@link QualifierTypes.Config.IQualifierTypeConfig | configuration object} containing
+     * the name, systemType, and optional language-specific configuration.
+     * @returns `Success` with the new {@link QualifierTypes.LanguageQualifierType | LanguageQualifierType}
+     * if successful, `Failure` with an error message otherwise.
+     * @public
+     */
+    static createFromConfig(config) {
+        var _a;
+        return sanitizeJsonObject({
+            name: config.name,
+            allowContextList: ((_a = config.configuration) === null || _a === void 0 ? void 0 : _a.allowContextList) === true
+        }).onSuccess(LanguageQualifierType.create);
+    }
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.isValidConditionValue}
+     */
+    isValidConditionValue(value) {
+        return Bcp47.tag(value)
+            .onSuccess((tag) => succeed(tag.isValid))
+            .orDefault(false);
+    }
+    /**
+     * Gets a {@link QualifierTypes.Config.ISystemLanguageQualifierTypeConfig | strongly typed configuration object}
+     * for this qualifier type.
+     * @returns `Success` with the configuration if successful, `Failure` with an error message otherwise.
+     */
+    getConfiguration() {
+        return this.getConfigurationJson().onSuccess((json) => Config.Convert.systemLanguageQualifierTypeConfig.convert(json));
+    }
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.getConfigurationJson}
+     */
+    getConfigurationJson() {
+        return succeed({
+            name: this.name,
+            systemType: 'language',
+            configuration: {
+                allowContextList: this.allowContextList
+            }
+        });
+    }
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.validateConfigurationJson}
+     */
+    validateConfigurationJson(from) {
+        return Config.Convert.systemLanguageQualifierTypeConfig.convert(from);
+    }
+    /**
+     * Validates a {@link QualifierTypes.Config.ISystemLanguageQualifierTypeConfig | strongly typed configuration object}
+     * for this qualifier type.
+     * @param from - The unknown data to validate as a configuration object.
+     * @returns `Success` with the validated configuration if successful, `Failure` with an error message otherwise.
+     */
+    validateConfiguration(from) {
+        return Config.Convert.systemLanguageQualifierTypeConfig.convert(from);
+    }
+    /**
+     * Matches a single language condition against a single language context value using
+     * {@link https://github.com/ErikFortune/fgv/tree/main/libraries/ts-bcp47#tag-matching | similarity matching}.
+     * @param condition - The language condition value to match.
+     * @param context - The language context value to match against.
+     * @param operator - The operator to use for the match. Must be 'matches'.
+     * @returns The match score, or `noMatch` if the match fails.
+     */
+    _matchOne(condition, context, operator) {
+        if (operator === 'matches') {
+            const similarity = Bcp47.similarity(condition, context).orDefault(Bcp47.tagSimilarity.none);
+            if (similarity > 0.0 && Validate.isValidQualifierMatchScore(similarity)) {
+                return similarity;
+            }
+        }
+        return NoMatch;
+    }
+}
+//# sourceMappingURL=languageQualifierType.js.map

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

@@ -0,0 +1,200 @@
+/*
+ * 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.
+ */
+import { captureResult, mapResults, fail, succeed } from '@fgv/ts-utils';
+import { Convert, NoMatch, PerfectMatch, Validate } from '../common';
+import { QualifierType } from './qualifierType';
+import { LiteralValueHierarchy } from './literalValueHierarchy';
+import * as Config from './config';
+import { sanitizeJsonObject } from '@fgv/ts-json-base';
+/**
+ * A {@link QualifierTypes.QualifierType | qualifier} that matches a literal value,
+ * optionally case-sensitive or matching against an ordered list of values at runtime.
+ * @public
+ */
+export class LiteralQualifierType extends 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`.
+     * @public
+     */
+    constructor({ name, caseSensitive, allowContextList, enumeratedValues, hierarchy, index }) {
+        allowContextList = allowContextList !== false;
+        super({
+            name: name !== null && name !== void 0 ? name : 'literal',
+            allowContextList,
+            index: index !== undefined ? Convert.qualifierTypeIndex.convert(index).orThrow() : undefined
+        });
+        /**
+         * {@inheritdoc QualifierTypes.IQualifierType.systemTypeName}
+         */
+        this.systemTypeName = Convert.qualifierTypeName.convert('literal').orThrow();
+        this.caseSensitive = caseSensitive === true;
+        this.enumeratedValues = enumeratedValues
+            ? mapResults(Array.from(enumeratedValues).map(LiteralQualifierType.toLiteralConditionValue)).orThrow()
+            : undefined;
+        if (hierarchy) {
+            /* c8 ignore next 5 - defensive coding: enumeratedValues ?? [] fallback enables open values mode */
+            this.hierarchy = LiteralValueHierarchy.create({
+                values: enumeratedValues !== null && enumeratedValues !== void 0 ? enumeratedValues : [],
+                hierarchy: hierarchy
+            }).orThrow();
+        }
+    }
+    /**
+     * Determines whether a value is a valid condition value for a literal qualifier.
+     * The {@link QualifierTypes.LiteralQualifierType | LiteralQualifierType} accepts
+     * any identifier as a valid condition value.
+     * @param value - The value to validate.
+     * @returns `true` if the value is a valid condition value, `false` otherwise.
+     */
+    isValidConditionValue(value) {
+        if (this.enumeratedValues) {
+            if (this.caseSensitive) {
+                return this.enumeratedValues.includes(value);
+            }
+            return this.enumeratedValues.some((v) => v.toLowerCase() === value.toLowerCase());
+        }
+        return LiteralQualifierType.isValidLiteralConditionValue(value);
+    }
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.isPotentialMatch}
+     */
+    isPotentialMatch(conditionValue, contextValue) {
+        if (this.isValidConditionValue(conditionValue) && this.isValidContextValue(contextValue)) {
+            if (this._matchOne(conditionValue, contextValue, 'matches') !== NoMatch) {
+                return true;
+            }
+            if (this.hierarchy) {
+                return this.hierarchy.isAncestor(conditionValue, contextValue);
+            }
+        }
+        return false;
+    }
+    /**
+     * Gets a {@link QualifierTypes.Config.ISystemLiteralQualifierTypeConfig | strongly typed configuration object}
+     * for this qualifier type.
+     * @returns `Success` with the configuration if successful, `Failure` with an error message otherwise.
+     */
+    getConfiguration() {
+        return this.getConfigurationJson().onSuccess((json) => Config.Convert.systemLiteralQualifierTypeConfig.convert(json));
+    }
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.getConfigurationJson}
+     */
+    getConfigurationJson() {
+        const hierarchy = this.hierarchy ? { hierarchy: this.hierarchy.asRecord() } : {};
+        const enumeratedValues = this.enumeratedValues
+            ? { enumeratedValues: [...this.enumeratedValues] }
+            : {};
+        return succeed({
+            name: this.name,
+            systemType: 'literal',
+            configuration: Object.assign(Object.assign({ allowContextList: this.allowContextList, caseSensitive: this.caseSensitive }, enumeratedValues), hierarchy)
+        });
+    }
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.validateConfigurationJson}
+     */
+    validateConfigurationJson(from) {
+        return Config.Convert.systemLiteralQualifierTypeConfig.convert(from);
+    }
+    /**
+     * Validates a {@link QualifierTypes.Config.ISystemLiteralQualifierTypeConfig | strongly typed configuration object}
+     * for this qualifier type.
+     * @param from - The unknown data to validate as a configuration object.
+     * @returns `Success` with the validated configuration if successful, `Failure` with an error message otherwise.
+     */
+    validateConfiguration(from) {
+        return Config.Convert.systemLiteralQualifierTypeConfig.convert(from);
+    }
+    /**
+     * {@inheritdoc QualifierTypes.QualifierType._matchOne}
+     */
+    _matchOne(condition, context, __operator) {
+        if (this.hierarchy) {
+            return this.hierarchy.match(condition, context, __operator);
+        }
+        if (this.caseSensitive) {
+            return condition === context ? PerfectMatch : NoMatch;
+        }
+        else {
+            return condition.toLowerCase() === context.toLowerCase() ? PerfectMatch : NoMatch;
+        }
+    }
+    /**
+     * Creates a new {@link QualifierTypes.LiteralQualifierType | LiteralQualifierType}.
+     * @param params - Optional {@link QualifierTypes.ILiteralQualifierTypeCreateParams | parameters}
+     * to use when creating the new instance.
+     * @returns `Success` with the new {@link QualifierTypes.LiteralQualifierType | LiteralQualifierType}
+     * if successful, `Failure` with an error message otherwise.
+     * @public
+     */
+    static create(params) {
+        return captureResult(() => new LiteralQualifierType(params !== null && params !== void 0 ? params : {}));
+    }
+    /**
+     * Creates a new {@link QualifierTypes.LiteralQualifierType | LiteralQualifierType} from a configuration object.
+     * @param config - The {@link QualifierTypes.Config.IQualifierTypeConfig | configuration object} containing
+     * the name, systemType, and optional literal-specific configuration including case sensitivity,
+     * enumerated values, and hierarchy information.
+     * @returns `Success` with the new {@link QualifierTypes.LiteralQualifierType | LiteralQualifierType}
+     * if successful, `Failure` with an error message otherwise.
+     * @public
+     */
+    static createFromConfig(config) {
+        var _a;
+        const literalConfig = (_a = config.configuration) !== null && _a !== void 0 ? _a : {};
+        return sanitizeJsonObject({
+            name: config.name,
+            allowContextList: literalConfig.allowContextList === true,
+            caseSensitive: literalConfig.caseSensitive,
+            enumeratedValues: literalConfig.enumeratedValues,
+            hierarchy: literalConfig.hierarchy
+        }).onSuccess(LiteralQualifierType.create);
+    }
+    /**
+     * Checks if the given value is a valid literal condition value.
+     * @param from - The value to validate.
+     * @returns `true` if the value is a valid literal condition value, otherwise `false`.
+     * @public
+     */
+    static isValidLiteralConditionValue(from) {
+        return Validate.RegularExpressions.identifier.test(from);
+    }
+    /**
+     * Converts a string to a {@link QualifierConditionValue | literal condition value}.
+     * @param from - The string to convert.
+     * @returns `Success` with the converted value if valid, or `Failure` with an error
+     * message if not.
+     * @public
+     */
+    static toLiteralConditionValue(from) {
+        return LiteralQualifierType.isValidLiteralConditionValue(from)
+            ? succeed(from)
+            : fail(`${from}: invalid literal condition value.`);
+    }
+}
+//# sourceMappingURL=literalQualifierType.js.map

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

@@ -0,0 +1,236 @@
+/*
+ * 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.
+ */
+import { captureResult, MessageAggregator, succeed, fail } from '@fgv/ts-utils';
+import { NoMatch, PerfectMatch, Convert as CommonConverters } from '../common';
+/**
+ * A class that implements a hierarchy of literal values. The hierarchy is defined as a
+ * tree, where each value can have multiple children but only one parent. The root of the
+ * tree has no parent. The hierarchy is used to determine the relationship between values
+ * when matching conditions and contexts.
+ *
+ * @remarks
+ * The hierarchy can be created in two modes:
+ * - **Constrained mode**: When enumerated values are provided, only those values are allowed
+ *   in the hierarchy and matching operations.
+ * - **Open values mode**: When no enumerated values are provided, all values referenced in
+ *   the hierarchy are automatically collected and used. This allows for flexible hierarchies
+ *   where any value can be used in matching operations.
+ * @public
+ */
+export class LiteralValueHierarchy {
+    constructor(params) {
+        const result = LiteralValueHierarchy._buildValuesFromHierarchy(params);
+        this.values = result.orThrow();
+        this.isOpenValues = !params.values || params.values.length === 0;
+    }
+    /**
+     * Creates a new {@link QualifierTypes.LiteralValueHierarchy | LiteralValueHierarchy} instance.
+     * @param params - The {@link QualifierTypes.ILiteralValueHierarchyCreateParams | parameters}
+     * used to create the hierarchy.
+     * @returns `Success` with the new hierarchy or `Failure` with an error message.
+     */
+    static create(params) {
+        return captureResult(() => new LiteralValueHierarchy(params));
+    }
+    /**
+     * Checks if a value exists in the hierarchy.
+     * @param value - The value to check.
+     * @returns `true` if the value exists in the hierarchy, `false` otherwise.
+     */
+    hasValue(value) {
+        return this.values.has(value);
+    }
+    /**
+     * Gets all root values (values with no parent) in the hierarchy.
+     * @returns `Success` with an array of root values.
+     */
+    getRoots() {
+        return succeed(Array.from(this.values.values())
+            .filter((v) => !v.parent)
+            .map((v) => v.name));
+    }
+    /**
+     * Gets all ancestors of a value in the hierarchy.
+     * @param value - The value to get ancestors for.
+     * @returns `Success` with an array of ancestor values, ordered from immediate parent
+     * to root, or `Failure` if the value is not in the hierarchy.
+     */
+    getAncestors(value) {
+        const current = this.values.get(value);
+        /* c8 ignore next 3 - functional error case tested but coverage intermittently missed */
+        if (!current) {
+            return fail(`${value}: not found in hierarchy`);
+        }
+        const ancestors = [];
+        let ancestor = current.parent;
+        while (ancestor) {
+            ancestors.push(ancestor.name);
+            ancestor = ancestor.parent;
+        }
+        return succeed(ancestors);
+    }
+    /**
+     * Determines if a value is an ancestor of a possible ancestor value.
+     * @param value - The value to check.
+     * @param possibleAncestor - The possible ancestor value.
+     * @returns `true` if the value is an ancestor of the possible ancestor, `false` otherwise.
+     */
+    isAncestor(value, possibleAncestor) {
+        const ancestors = this.getAncestors(value);
+        if (ancestors.isSuccess()) {
+            return ancestors.value.includes(possibleAncestor);
+        }
+        /* c8 ignore next 2 - edge case: ancestor validation fallback */
+        return false;
+    }
+    /**
+     * Gets all descendants of a value in the hierarchy.
+     * @param value - The value to get descendants for.
+     * @returns `Success` with an array of descendant values, or `Failure` if the value
+     * is not in the hierarchy.
+     */
+    getDescendants(value) {
+        const current = this.values.get(value);
+        if (!current) {
+            return fail(`${value}: not found in hierarchy`);
+        }
+        const descendants = [];
+        if (current.children) {
+            for (const childName of current.children) {
+                descendants.push(childName);
+                const childDescendants = this.getDescendants(childName);
+                if (childDescendants.isSuccess()) {
+                    descendants.push(...childDescendants.value);
+                }
+            }
+        }
+        return succeed(descendants);
+    }
+    match(condition, context, __operator) {
+        var _a;
+        // For open hierarchies, skip validation and allow any values
+        if (!this.isOpenValues) {
+            // Validate that both condition and context exist in the hierarchy
+            /* c8 ignore next 3 - functional error case tested but coverage intermittently missed */
+            if (!this.values.has(condition)) {
+                return NoMatch;
+            }
+            /* c8 ignore next 3 - functional error case tested but coverage intermittently missed */
+            if (!this.values.has(context)) {
+                return NoMatch;
+            }
+        }
+        if (condition === context) {
+            return PerfectMatch;
+        }
+        // For open hierarchies, if values aren't in the hierarchy, treat as no match
+        // but don't fail validation
+        const values = this.values;
+        /* c8 ignore next 1 - ? is defense in depth */
+        let value = (_a = values.get(context)) === null || _a === void 0 ? void 0 : _a.parent;
+        /* c8 ignore next 2 - functional error case tested but coverage intermittently missed */
+        if (!value) {
+            return NoMatch;
+        }
+        let score = PerfectMatch;
+        while (value) {
+            score *= 0.9;
+            if (value.name === condition) {
+                return CommonConverters.qualifierMatchScore.convert(score).orDefault(NoMatch);
+            }
+            value = value.parent;
+        }
+        return NoMatch;
+    }
+    static _buildValuesFromHierarchy(params) {
+        var _a;
+        const errors = new MessageAggregator();
+        const values = params.values;
+        /* c8 ignore next 1 - defense in depth */
+        const hierarchy = (_a = params.hierarchy) !== null && _a !== void 0 ? _a : {};
+        // If no values are provided, collect all values from the hierarchy
+        let allValues;
+        if (!values || values.length === 0) {
+            const hierarchyValues = new Set();
+            // Add all keys and values from the hierarchy
+            Object.keys(hierarchy).forEach((key) => hierarchyValues.add(key));
+            Object.values(hierarchy).forEach((value) => hierarchyValues.add(value));
+            allValues = Array.from(hierarchyValues);
+        }
+        else {
+            allValues = [...values];
+        }
+        const valueMap = new Map(allValues.map((name) => [name, { name }]));
+        if (hierarchy) {
+            for (const [valueName, parentName] of Object.entries(hierarchy)) {
+                const value = valueMap.get(valueName);
+                if (!value) {
+                    errors.addMessage(`${valueName}: invalid literal value.`);
+                    continue;
+                }
+                const parent = valueMap.get(parentName);
+                if (!parent) {
+                    errors.addMessage(`${valueName}: parent ${parentName} is invalid literal value.`);
+                    continue;
+                }
+                let ancestor = parent.parent;
+                let circular = false;
+                const ancestors = [];
+                while (ancestor) {
+                    /* c8 ignore next 1 - defensive coding: complex circular reference detection intermittently missed */
+                    ancestors.push(ancestor.name);
+                    /* c8 ignore next 1 - defensive coding: ancestor.parent === value is very difficult to reach */
+                    if (ancestor.parent === parent || ancestor.parent === value) {
+                        /* c8 ignore next 4 - defensive coding: circular reference error reporting intermittently missed */
+                        errors.addMessage(`${valueName}: Circular reference detected: ${ancestors.join('->')}`);
+                        circular = true;
+                        break;
+                    }
+                    ancestor = ancestor.parent;
+                }
+                /* c8 ignore next 3 - defensive coding: circular reference handling intermittently missed */
+                if (circular) {
+                    continue;
+                }
+                value.parent = parent;
+                if (parent.children) {
+                    parent.children.push(value.name);
+                }
+                else {
+                    parent.children = [value.name];
+                }
+            }
+        }
+        return errors.returnOrReport(succeed(valueMap));
+    }
+    /**
+     * Converts the hierarchy to a record of parent-child relationships.
+     * @returns A record of parent-child relationships.
+     */
+    asRecord() {
+        const entries = Array.from(this.values.values())
+            .filter((v) => v.parent !== undefined)
+            .map((v) => [v.name, v.parent.name]);
+        return Object.fromEntries(entries);
+    }
+}
+//# sourceMappingURL=literalValueHierarchy.js.map