@fgv/ts-res 5.0.1-9 → 5.0.1

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

@@ -0,0 +1,184 @@
+/*
+ * 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 { Collections, fail, succeed } from '@fgv/ts-utils';
+import { Convert, NoMatch, PerfectMatch, Validate } from '../common';
+/**
+ * Abstract base class for qualifier types. Provides default implementations for
+ * the {@link QualifierTypes.IQualifierType | IQualifierType} interface.
+ * @public
+ */
+export class QualifierType {
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.key}
+     */
+    get key() {
+        return this._collectible.key;
+    }
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.index}
+     */
+    get index() {
+        return this._collectible.index;
+    }
+    /**
+     * Constructor for use by derived classes.
+     * @param name - The name of the qualifier type.
+     * @param allowContextList - Flag indicating whether this qualifier type allows a
+     * comma-separated list of runtime values in the context. Defaults to `false`.
+     */
+    constructor({ name, index, allowContextList }) {
+        this.name = Convert.qualifierTypeName.convert(name).orThrow();
+        this.allowContextList = allowContextList === true;
+        this._collectible = new Collections.Collectible({
+            key: this.name,
+            index: index,
+            indexConverter: Convert.qualifierTypeIndex
+        });
+    }
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.isValidContextValue}
+     */
+    isValidContextValue(value) {
+        if (this.isValidConditionValue(value)) {
+            return true;
+        }
+        if (this.allowContextList) {
+            /* c8 ignore next 1 - functional code tested but coverage intermittently missed */
+            return value.split(',').every((v) => this.isValidConditionValue(v.trim()));
+        }
+        /* c8 ignore next 1 - functional code tested but coverage intermittently missed */
+        return false;
+    }
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.isPotentialMatch}
+     */
+    isPotentialMatch(conditionValue, contextValue) {
+        if (this.isValidConditionValue(conditionValue) && this.isValidContextValue(contextValue)) {
+            return this._matchOne(conditionValue, contextValue, 'matches') !== NoMatch;
+        }
+        /* c8 ignore next 2 - functional code tested but coverage intermittently missed */
+        return false;
+    }
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.validateCondition}
+     */
+    validateCondition(value, operator) {
+        operator = operator !== null && operator !== void 0 ? operator : 'matches';
+        /* c8 ignore next 2 - functional error case tested but coverage intermittently missed */
+        if (operator !== 'matches') {
+            return fail(`${operator}: invalid condition operator`);
+            /* c8 ignore next 2 - functional error case tested but coverage intermittently missed */
+        }
+        else if (!this.isValidConditionValue(value)) {
+            return fail(`${value}: invalid condition value for qualifierType ${this.name}`);
+        }
+        return succeed(value);
+    }
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.validateContextValue}
+     */
+    validateContextValue(value) {
+        /* c8 ignore next 2 - functional error case tested but coverage intermittently missed */
+        if (!this.isValidContextValue(value)) {
+            return fail(`${value}: invalid context value for qualifierType ${this.name}`);
+        }
+        return succeed(value);
+    }
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.matches}
+     */
+    matches(condition, context, operator) {
+        if (this.allowContextList) {
+            return this._matchList(condition, QualifierType._splitContext(context), operator);
+        }
+        return this._matchOne(condition, context, operator);
+    }
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.setIndex}
+     */
+    setIndex(index) {
+        return this._collectible.setIndex(index);
+    }
+    /**
+     * {@inheritdoc Validate.isValidQualifierTypeName}
+     */
+    static isValidName(name) {
+        return Validate.isValidQualifierTypeName(name);
+    }
+    /**
+     * {@inheritdoc Validate.isValidQualifierTypeIndex}
+     */
+    static isValidIndex(index) {
+        return Validate.isValidQualifierTypeIndex(index);
+    }
+    /**
+     * Compares two qualifier types by index.
+     * @param t1 - The first qualifier type to compare.
+     * @param t2 - The second qualifier type to compare.
+     * @returns a number indicating the relative order of the two qualifier types.
+     */
+    static compare(t1, t2) {
+        var _a, _b;
+        const i1 = (_a = t1._collectible.index) !== null && _a !== void 0 ? _a : -1;
+        const i2 = (_b = t2._collectible.index) !== null && _b !== void 0 ? _b : -1;
+        let diff = i1 - i2;
+        if (diff === 0) {
+            diff = t1.name.localeCompare(t2.name);
+        }
+        return diff;
+    }
+    /**
+     * Matches a single condition value against a list of context values.
+     * @param condition - The {@link QualifierConditionValue | condition value} to match.
+     * @param context - The comma-separated list of {@link QualifierContextValue | context values} to match.
+     * @param operator - The {@link ConditionOperator | operator} to use in the match.
+     * @returns a {@link QualifierMatchScore | score} indicating the extent to which
+     * the condition matches the context value.
+     * @public
+     */
+    _matchList(condition, context, operator) {
+        const scorePerPosition = 1 / context.length;
+        let baseScore = PerfectMatch - scorePerPosition;
+        for (let i = 0; i < context.length; i++) {
+            const score = this._matchOne(condition, context[i], operator);
+            if (score > NoMatch) {
+                const adjusted = baseScore + scorePerPosition * score;
+                if (Validate.isValidQualifierMatchScore(adjusted)) {
+                    return adjusted;
+                }
+            }
+            baseScore -= scorePerPosition;
+        }
+        return NoMatch;
+    }
+    /**
+     * Splits a comma-separated {@link QualifierContextValue | context value} into an
+     * array of individual values.
+     * @param value - The value to split.
+     * @returns an array of individual context values.
+     * @public
+     */
+    static _splitContext(value) {
+        return value.split(',').map((s) => s.trim());
+    }
+}
+//# sourceMappingURL=qualifierType.js.map

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

@@ -0,0 +1,66 @@
+/*
+ * 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 Common from '../common';
+import { Collections, ValidatingConvertingCollector, captureResult, fail, succeed } from '@fgv/ts-utils';
+import { QualifierType } from './qualifierType';
+/**
+ * Collector for {@link QualifierTypes.QualifierType | QualifierType} objects.
+ * @public
+ */
+export class QualifierTypeCollector extends ValidatingConvertingCollector {
+    /**
+     * Constructor for a {@link QualifierTypes.QualifierTypeCollector | QualifierTypeCollector} object.
+     * @param params - Optional {@link QualifierTypes.IQualifierTypeCollectorCreateParams | parameters}
+     * used to construct the collector.
+     */
+    constructor({ qualifierTypes }) {
+        super({
+            converters: new Collections.KeyValueConverters({
+                key: Common.Convert.qualifierTypeName,
+                value: QualifierTypeCollector._toQualifierType
+            }),
+            factory: QualifierTypeCollector._qualifierTypeFactory
+        });
+        /* c8 ignore next 1 - coverage seems to intermittently miss the branch */
+        qualifierTypes === null || qualifierTypes === void 0 ? void 0 : qualifierTypes.forEach((qt) => {
+            this.add(qt).orThrow();
+        });
+    }
+    /**
+     * Creates a new {@link QualifierTypes.QualifierTypeCollector | QualifierTypeCollector} object.
+     * @param params - Optional {@link QualifierTypes.IQualifierTypeCollectorCreateParams | parameters}
+     * used to create the collector.
+     * @returns `Success` with the new collector if successful, or `Failure` if not.
+     */
+    static create(params) {
+        /* c8 ignore next 1 - coverage seems to miss the branch intermittently */
+        params = params !== null && params !== void 0 ? params : {};
+        return captureResult(() => new QualifierTypeCollector(params));
+    }
+    static _qualifierTypeFactory(key, index, value) {
+        return succeed(value);
+    }
+    static _toQualifierType(from) {
+        return from instanceof QualifierType ? succeed(from) : fail('not a QualifierType');
+    }
+}
+//# sourceMappingURL=qualifierTypeCollector.js.map

package/dist/packlets/qualifier-types/territoryQualifierType.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, fail, succeed, mapResults } 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';
+/**
+ * Qualifier type for territory values. Territories are two-letter ISO-3166-2
+ * Alpha-2 country codes. Canonical territory codes are uppercase, but this
+ * implementation handles incorrect casing.
+ * @public
+ */
+export class TerritoryQualifierType extends QualifierType {
+    /**
+     * Creates a new {@link QualifierTypes.TerritoryQualifierType | TerritoryQualifierType} instance.
+     * @public
+     */
+    constructor({ acceptLowercase, allowedTerritories, allowContextList, name, index, hierarchy }) {
+        /* c8 ignore next 7 - coverage seems to be missing coalescing branches */
+        name = name !== null && name !== void 0 ? name : 'territory';
+        const validIndex = index !== undefined ? Convert.qualifierTypeIndex.convert(index).orThrow() : undefined;
+        const validTerritories = allowedTerritories !== undefined
+            ? mapResults(allowedTerritories.map((t) => TerritoryQualifierType.toTerritoryConditionValue(t.toUpperCase()))).orThrow()
+            : undefined;
+        allowContextList = allowContextList === true;
+        super({
+            name: name,
+            allowContextList,
+            index: validIndex
+        });
+        /**
+         * {@inheritdoc QualifierTypes.IQualifierType.systemTypeName}
+         */
+        this.systemTypeName = Convert.qualifierTypeName
+            .convert('territory')
+            .orThrow();
+        this.allowedTerritories = validTerritories;
+        this.acceptLowercase = acceptLowercase === true;
+        if (hierarchy) {
+            /* c8 ignore next 5 - defensive coding: allowedTerritories ?? [] fallback enables open values mode */
+            this.hierarchy = LiteralValueHierarchy.create({
+                values: allowedTerritories !== null && allowedTerritories !== void 0 ? allowedTerritories : [],
+                hierarchy: hierarchy
+            }).orThrow();
+        }
+    }
+    /**
+     * {@inheritdoc QualifierTypes.QualifierType.isValidConditionValue}
+     */
+    isValidConditionValue(value) {
+        const normalized = this.acceptLowercase ? value.toUpperCase() : value;
+        /* c8 ignore next 6 - edge case: invalid territory values and allowed territory filtering rarely hit */
+        if (!TerritoryQualifierType.isValidTerritoryConditionValue(normalized)) {
+            return false;
+        }
+        if (this.allowedTerritories !== undefined) {
+            return this.allowedTerritories.includes(normalized);
+        }
+        return true;
+    }
+    /**
+     * Creates a new {@link QualifierTypes.TerritoryQualifierType | TerritoryQualifierType} instance.
+     * @param params - Optional {@link QualifierTypes.ITerritoryQualifierTypeCreateParams | parameters}
+     * to use when creating the instance.
+     * @returns `Success` with the new {@link QualifierTypes.TerritoryQualifierType | TerritoryQualifierType}
+     * if successful, `Failure` with an error message otherwise.
+     * @public
+     */
+    static create(params) {
+        /* c8 ignore next 1 - coverage having problems with conditional branches */
+        params = params !== null && params !== void 0 ? params : {};
+        return captureResult(() => new TerritoryQualifierType(params));
+    }
+    /**
+     * Creates a new {@link QualifierTypes.TerritoryQualifierType | TerritoryQualifierType} from a configuration object.
+     * @param config - The {@link QualifierTypes.Config.IQualifierTypeConfig | configuration object} containing
+     * the name, systemType, and optional territory-specific configuration including allowed territories and hierarchy.
+     * @returns `Success` with the new {@link QualifierTypes.TerritoryQualifierType | TerritoryQualifierType}
+     * if successful, `Failure` with an error message otherwise.
+     * @public
+     */
+    static createFromConfig(config) {
+        var _a;
+        const territoryConfig = (_a = config.configuration) !== null && _a !== void 0 ? _a : {};
+        return sanitizeJsonObject({
+            name: config.name,
+            allowContextList: territoryConfig.allowContextList === true,
+            allowedTerritories: territoryConfig.allowedTerritories,
+            acceptLowercase: territoryConfig.acceptLowercase === true,
+            hierarchy: territoryConfig.hierarchy
+        }).onSuccess(TerritoryQualifierType.create);
+    }
+    /**
+     * Gets the {@link QualifierTypes.Config.ISystemTerritoryQualifierTypeConfig | strongly typed configuration}
+     * 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.systemTerritoryQualifierTypeConfig.convert(json));
+    }
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.getConfigurationJson}
+     */
+    getConfigurationJson() {
+        const hierarchy = this.hierarchy ? { hierarchy: this.hierarchy.asRecord() } : {};
+        const allowedTerritories = this.allowedTerritories
+            ? { allowedTerritories: [...this.allowedTerritories] }
+            : {};
+        return succeed({
+            name: this.name,
+            systemType: 'territory',
+            configuration: Object.assign(Object.assign({ allowContextList: this.allowContextList, acceptLowercase: this.acceptLowercase }, allowedTerritories), hierarchy)
+        });
+    }
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.validateConfigurationJson}
+     */
+    validateConfigurationJson(from) {
+        return Config.Convert.systemTerritoryQualifierTypeConfig.convert(from);
+    }
+    /**
+     * Validates a {@link QualifierTypes.Config.ISystemTerritoryQualifierTypeConfig | 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 this.validateConfigurationJson(from).onSuccess((json) => Config.Convert.systemTerritoryQualifierTypeConfig.convert(json));
+    }
+    /**
+     * {@inheritdoc QualifierTypes.QualifierType._matchOne}
+     */
+    _matchOne(condition, context, __operator) {
+        if (this.isValidConditionValue(condition) && this.isValidContextValue(context)) {
+            // Normalize to uppercase for territory codes
+            const normalizedCondition = condition.toUpperCase();
+            const normalizedContext = context.toUpperCase();
+            if (normalizedCondition === normalizedContext) {
+                return PerfectMatch;
+            }
+            /* c8 ignore next 8 - edge case: hierarchy matching and fallback logic rarely used */
+            if (this.hierarchy) {
+                return this.hierarchy.match(normalizedCondition, normalizedContext, __operator);
+            }
+        }
+        return NoMatch;
+    }
+    /**
+     * Determines whether a value is a valid condition value for a territory qualifier.
+     * @param value - The value to validate.
+     * @param acceptLowercase - Flag indicating whether the qualifier type should accept lowercase territory codes.
+     * Defaults to `false`.
+     * @returns `true` if the value is a valid condition value, `false` otherwise.
+     * @public
+     */
+    static isValidTerritoryConditionValue(value, acceptLowercase) {
+        /* c8 ignore next 3 - edge case: lowercase validation rarely fails */
+        if (acceptLowercase !== true && value !== value.toUpperCase()) {
+            return false;
+        }
+        return Validate.RegularExpressions.territoryCode.test(value.toUpperCase());
+    }
+    /**
+     * Converts a string value to a territory condition value.
+     * @param value - The value to convert.
+     * @param acceptLowercase - Flag indicating whether the qualifier type should accept lowercase territory codes.
+     * Defaults to `false`.
+     * @returns `Success` with the converted value if successful, `Failure` with an error
+     * message otherwise.
+     * @public
+     */
+    static toTerritoryConditionValue(value, acceptLowercase) {
+        const normalized = value.toUpperCase();
+        return TerritoryQualifierType.isValidTerritoryConditionValue(normalized, acceptLowercase)
+            ? succeed(normalized)
+            : fail(`${value}: invalid territory code`);
+    }
+}
+//# sourceMappingURL=territoryQualifierType.js.map

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

@@ -0,0 +1,70 @@
+/*
+ * 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 { Converters, populateObject, fail, succeed } from '@fgv/ts-utils';
+import { Validate } from '../../common';
+/* eslint-disable @rushstack/typedef-var */
+/**
+ * Converter for a {@link Qualifiers.IQualifierDecl | qualifier declaration}.
+ * @public
+ */
+export const qualifierDecl = Converters.strictObject({
+    name: Converters.string,
+    typeName: Converters.string,
+    defaultPriority: Converters.number,
+    token: Converters.string.optional(),
+    tokenIsOptional: Converters.boolean.optional(),
+    defaultValue: Converters.string.optional()
+});
+/**
+ * Converter which constructs a {@link Qualifiers.IValidatedQualifierDecl | validated qualifier declaration}
+ * from a {@link Qualifiers.IQualifierDecl | qualifier declaration}, instantiating qualifier types by name
+ * from a supplied {@link Qualifiers.Convert.IQualifierDeclConvertContext | conversion context}.
+ * @public
+ */
+export const validatedQualifierDecl = Converters.generic((from, __self, context) => {
+    /* c8 ignore next 7  - this is tested but code coverage is losing its mind */
+    if (context === undefined) {
+        return fail('validatedQualifierDecl converter requires a context');
+    }
+    const validatedIndexResult = context.qualifierIndex !== undefined
+        ? Validate.toQualifierIndex(context.qualifierIndex)
+        : succeed(undefined);
+    return qualifierDecl.convert(from).onSuccess((decl) => {
+        return context.qualifierTypes.validating.get(decl.typeName).asResult.onSuccess((type) => {
+            return populateObject({
+                name: () => Validate.toQualifierName(decl.name),
+                token: () => { var _a; return Validate.toQualifierName((_a = decl.token) !== null && _a !== void 0 ? _a : decl.name); },
+                tokenIsOptional: () => succeed(decl.tokenIsOptional === true),
+                type: () => succeed(type),
+                defaultPriority: () => Validate.toConditionPriority(decl.defaultPriority),
+                defaultValue: () => decl.defaultValue ? type.validateContextValue(decl.defaultValue) : succeed(undefined),
+                index: () => validatedIndexResult
+            }).onSuccess((validated) => {
+                if (context.qualifierIndex !== undefined) {
+                    context.qualifierIndex++;
+                }
+                return succeed(validated);
+            });
+        });
+    });
+});
+//# sourceMappingURL=decls.js.map

package/dist/packlets/qualifiers/convert/index.js

@@ -0,0 +1,24 @@
+/*
+ * 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.
+ */
+export * from './decls';
+export * from './qualifier';
+//# sourceMappingURL=index.js.map

package/dist/packlets/qualifiers/convert/qualifier.js

@@ -0,0 +1,40 @@
+/*
+ * 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 { Converters, fail } from '@fgv/ts-utils';
+/**
+ * Converter which choose a qualifier by name or number from a
+ * supplied {@link Qualifiers.Convert.IQualifierConvertContext | conversion context}.
+ * @public
+ */
+export const qualifier = Converters.generic((from, __self, context) => {
+    if (context === undefined) {
+        return fail('qualifier converter requires a context');
+    }
+    if (typeof from === 'string') {
+        return context.qualifiers.validating.get(from);
+    }
+    else if (typeof from === 'number') {
+        return context.qualifiers.getAt(from);
+    }
+    return fail('qualifier converter requires a string or number');
+});
+//# sourceMappingURL=qualifier.js.map

package/dist/packlets/qualifiers/index.js

@@ -0,0 +1,29 @@
+/*
+ * 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 Convert from './convert';
+export * from './qualifier';
+export * from './qualifierDecl';
+export * from './qualifierCollector';
+export * from './qualifierDefaultValueDecls';
+export * from './qualifierDefaultValueToken';
+export { Convert };
+//# sourceMappingURL=index.js.map