@fgv/ts-res 5.0.1-8 → 5.0.1

package/dist/packlets/conditions/conditionSet.js

@@ -0,0 +1,247 @@
+/*
+ * 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, Collections, Hash, mapResults, succeed } from '@fgv/ts-utils';
+import { Condition } from './condition';
+import { Convert as CommonConvert, Validate } from '../common';
+import * as ConditionsConvert from './convert';
+/**
+ * Represents a set of {@link Conditions.Condition | conditions} that must all be met in some runtime
+ * context for a resource instance to be valid.
+ * @public
+ */
+export class ConditionSet {
+    /**
+     * The key for this condition set.
+     */
+    get key() {
+        return this._collectible.key;
+    }
+    /**
+     * The number of conditions in this condition set.
+     */
+    get size() {
+        return this.conditions.length;
+    }
+    /**
+     * The index for this condition set.
+     */
+    get index() {
+        return this._collectible.index;
+    }
+    /**
+     * Constructor for a {@link Conditions.ConditionSet | ConditionSet} object.
+     * @param params - {@link Conditions.IValidatedConditionSetDecl | Validated declaration}
+     * used to create the condition set.
+     */
+    constructor(params) {
+        var _a, _b;
+        const qualifiers = new Map();
+        for (const condition of params.conditions) {
+            /* c8 ignore next 9 - there's a test for this but coverage is having a bad day */
+            if (qualifiers.has(condition.qualifier.name)) {
+                const existing = (_b = (_a = qualifiers.get(condition.qualifier.name)) === null || _a === void 0 ? void 0 : _a.toString()) !== null && _b !== void 0 ? _b : 'unknown';
+                throw new Error(`${condition.qualifier.name}: Duplicate conditions ${existing} and ${condition.toString()} are not supported.`);
+            }
+            qualifiers.set(condition.qualifier.name, condition);
+        }
+        this.conditions = Array.from(params.conditions).sort(Condition.compare).reverse();
+        this._collectible = new Collections.Collectible({
+            key: this.toKey(),
+            index: params.index,
+            indexConverter: CommonConvert.conditionSetIndex
+        });
+    }
+    /**
+     * Creates a new {@link Conditions.ConditionSet | ConditionSet} object.
+     * @param params - {@link Conditions.IValidatedConditionSetDecl | Validated declaration}
+     * used to create the condition set.
+     * @returns `Success` with the new {@link Conditions.ConditionSet | ConditionSet} object if successful,
+     * or `Failure` with an error message if not.
+     * @public
+     */
+    static create(params) {
+        return captureResult(() => new ConditionSet(params));
+    }
+    /**
+     * Compares two {@link Conditions.ConditionSet | ConditionSets} for sorting purposes.
+     * @param cs1 - The first {@link Conditions.ConditionSet | ConditionSet} to compare.
+     * @param cs2 - The second {@link Conditions.ConditionSet | ConditionSet} to compare.
+     * @returns A negative number if `cs1` should come before `cs2`, a positive
+     * number if `cs1` should come after `cs2`, or zero if they are equivalent.
+     * @public
+     */
+    static compare(cs1, cs2) {
+        const len = Math.min(cs1.conditions.length, cs2.conditions.length);
+        for (let i = 0; i < len; i++) {
+            const diff = Condition.compare(cs1.conditions[i], cs2.conditions[i]);
+            if (diff !== 0) {
+                return diff;
+            }
+        }
+        return cs1.conditions.length - cs2.conditions.length;
+    }
+    /**
+     * Sets the global index for this condition set.  Once set, the index cannot be changed.
+     * @param index - The index to set for this condition set.
+     * @returns `Success` with the index if successful, `Failure` otherwise.
+     */
+    setIndex(index) {
+        return this._collectible.setIndex(index);
+    }
+    /**
+     * Determines if this condition set can match a supplied context, even if the context is partial.
+     * Returns true if all conditions in the set can match the context (using canMatchPartialContext).
+     * Returns false otherwise.
+     * @param context - The context to match.
+     * @param options - Options to use when matching.
+     * @returns `true` if all conditions can match the context, `false` otherwise.
+     */
+    canMatchPartialContext(context, options) {
+        return this.conditions.every((c) => c.canMatchPartialContext(context, options));
+    }
+    /**
+     * Gets the {@link ConditionSetKey | key} for a supplied {@link Conditions.IValidatedConditionSetDecl | condition set declaration}.
+     * @param decl - The {@link Conditions.IValidatedConditionSetDecl | condition set declaration} for which to get the key.
+     * @returns `Success` with the condition set key if successful, `Failure` otherwise.
+     * @public
+     */
+    static getKeyForDecl(decl) {
+        return Validate.toConditionSetKey(decl.conditions.map((c) => c.toKey()).join('+'));
+    }
+    /**
+     * Gets a condition set key from a loose condition set declaration.
+     * @param conditionSet - The loose condition set declaration to convert.
+     * @param conditionCollector - The condition collector used for validation.
+     * @returns `Success` with the condition set key if successful, `Failure` otherwise.
+     * @public
+     */
+    static getKeyFromLooseDecl(conditionSet, conditionCollector) {
+        if (!conditionSet) {
+            return succeed(ConditionSet.UnconditionalKey);
+        }
+        // Convert ConditionSetDecl to IConditionSetDecl format
+        let conditionSetDecl;
+        if (Array.isArray(conditionSet)) {
+            // ConditionSetDeclAsArray: array of ILooseConditionDecl
+            conditionSetDecl = { conditions: conditionSet };
+        }
+        else {
+            // ConditionSetDeclAsRecord: Record<string, string | IChildConditionDecl>
+            const conditions = Object.entries(conditionSet).map(([qualifierName, value]) => {
+                if (typeof value === 'string') {
+                    return { qualifierName, value };
+                    /* c8 ignore next 3 - edge case */
+                }
+                else {
+                    return Object.assign({ qualifierName }, value);
+                }
+            });
+            conditionSetDecl = { conditions };
+        }
+        // Validate and convert to IValidatedConditionSetDecl
+        return ConditionsConvert.validatedConditionSetDecl
+            .convert(conditionSetDecl, { conditions: conditionCollector })
+            .onSuccess((validatedDecl) => {
+            // Use proper ConditionSet.getKeyForDecl method to generate the key
+            return ConditionSet.getKeyForDecl(validatedDecl);
+        });
+    }
+    /**
+     * Gets a {@link ConditionSetToken | condition set token} for this condition set,
+     * if possible.
+     * @param terse - If true, the token will be terse, omitting qualifier names where
+     * possible.
+     * @returns `Success` with the {@link ConditionSetToken | condition set token} if successful,
+     * `Failure` with an error message otherwise.
+     * @public
+     */
+    toToken(terse) {
+        return mapResults(this.conditions.map((c) => c.toToken(terse))).onSuccess((tokens) => {
+            return Validate.toConditionSetToken(tokens.join(','));
+        });
+    }
+    /**
+     * Gets the {@link ConditionSetKey | key} for this condition set.
+     * @returns The key for this condition set.
+     */
+    toKey() {
+        return ConditionSet.getKeyForDecl(this).orThrow();
+    }
+    /**
+     * Gets a hash of this condition set.
+     * @returns A hash of this condition
+     * set key.
+     * @public
+     */
+    toHash() {
+        return Hash.Crc32Normalizer.crc32Hash([this.key]).padStart(8, '0');
+    }
+    /**
+     * Gets a human-readable string representation of this condition set.
+     * @returns A string representation of this condition set.
+     */
+    toString() {
+        return this.toKey();
+    }
+    /**
+     * Gets the {@link ResourceJson.Json.ConditionSetDeclAsRecord | condition set declaration as a record} for this condition set.
+     * @param options - {@link ResourceJson.Helpers.IDeclarationOptions | options} for the condition set declaration.
+     * @returns The {@link ResourceJson.Json.ConditionSetDeclAsRecord | condition set declaration as a record} for this condition set.
+     */
+    toConditionSetRecordDecl(options) {
+        const qualifiersToReduce = options === null || options === void 0 ? void 0 : options.qualifiersToReduce;
+        const conditions = qualifiersToReduce
+            ? /* c8 ignore next 1 - coverage intermittently misses the next line */
+                this.conditions.filter((c) => !qualifiersToReduce.has(c.qualifier.name))
+            : this.conditions;
+        return Object.fromEntries(conditions.map((c) => {
+            return [c.qualifier.name, c.toValueOrChildConditionDecl(options)];
+        }));
+    }
+    /**
+     * Gets the {@link ResourceJson.Json.ConditionSetDeclAsArray | condition set declaration as an array} for this condition set.
+     * @param options - {@link ResourceJson.Helpers.IDeclarationOptions | options} for the condition set declaration.
+     * @returns The {@link ResourceJson.Json.ConditionSetDeclAsArray | condition set declaration as an array} for this condition set.
+     */
+    toConditionSetArrayDecl(options) {
+        /* c8 ignore next 1 - defense in depth */
+        const qualifiersToReduce = options === null || options === void 0 ? void 0 : options.qualifiersToReduce;
+        const conditions = qualifiersToReduce
+            ? this.conditions.filter((c) => !qualifiersToReduce.has(c.qualifier.name))
+            : this.conditions;
+        return conditions.map((c) => c.toLooseConditionDecl(options));
+    }
+    /**
+     * Converts this condition set to a compiled condition set representation.
+     * @param options - Optional compilation options controlling the output format.
+     * @returns A compiled condition set object that can be used for serialization or runtime processing.
+     * @public
+     */
+    toCompiled(options) {
+        return Object.assign({ conditions: this.conditions.map((c) => c.index) }, ((options === null || options === void 0 ? void 0 : options.includeMetadata) === true ? { metadata: { key: this.key } } : {}));
+    }
+}
+/**
+ * The key for an unconditional condition set.
+ */
+ConditionSet.UnconditionalKey = Validate.toConditionSetKey('').orThrow();
+//# sourceMappingURL=conditionSet.js.map

package/dist/packlets/conditions/conditionSetCollector.js

@@ -0,0 +1,89 @@
+/*
+ * 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, Collections, mapResults, succeed, ValidatingCollector } from '@fgv/ts-utils';
+import { ConditionSet } from './conditionSet';
+import { validatedConditionSetDecl } from './convert';
+import { Convert as CommonConvert, Validate } from '../common';
+/**
+ * A `ValidatingCollector` for {@link Conditions.ConditionSet | ConditionSets},
+ * which collects condition sets supplied as {@link Conditions.ConditionSet | ConditionSet} or
+ * as {@link Conditions.IConditionSetDecl | IConditionSetDecl} via the methods on the
+ * `validating` property.
+ * @public
+ */
+export class ConditionSetCollector extends ValidatingCollector {
+    /**
+     * Gets the {@link Conditions.ConditionSet | ConditionSet} at the unconditional
+     * condition set index.
+     */
+    get unconditionalConditionSet() {
+        return this.getAt(ConditionSetCollector.UnconditionalIndex).orThrow();
+    }
+    /**
+     * Creates a new {@link Conditions.ConditionSetCollector | ConditionSetCollector}.
+     * @param params - {@link Conditions.IConditionSetCollectorCreateParams | Parameters} used to create
+     * the collector.
+     */
+    constructor(params) {
+        var _a;
+        super({
+            converters: new Collections.KeyValueConverters({
+                key: CommonConvert.conditionSetKey,
+                /* c8 ignore next 1 - there's a test but coverage is having a bad day */
+                value: (from) => this._toConditionSet(from)
+            })
+        });
+        this.conditions = params.conditions;
+        // it's very helpful for debugging if the unconditional condition set is always
+        // in position 0
+        this.validating.add(ConditionSet.create({ conditions: [] }).orThrow()).orThrow();
+        /* c8 ignore next 1 - ? is defense in depth */
+        (_a = params.conditionSets) === null || _a === void 0 ? void 0 : _a.forEach((item) => this.validating.add(item).orThrow());
+    }
+    /**
+     * Creates a new {@link Conditions.ConditionSetCollector | ConditionSetCollector}.
+     * @param params - {@link Conditions.IConditionSetCollectorCreateParams | Parameters} used to create
+     * the collector.
+     * @returns `Success` with the new collector if successful, or `Failure` with an error message
+     * if not.
+     */
+    static create(params) {
+        return captureResult(() => new ConditionSetCollector(params));
+    }
+    _toConditionSet(from) {
+        if (from instanceof ConditionSet) {
+            return succeed(from);
+        }
+        if (Array.isArray(from)) {
+            return mapResults(from.map((item) => this.conditions.validating.getOrAdd(item))).onSuccess((conditions) => ConditionSet.create({ conditions }));
+        }
+        /* c8 ignore next 4 - functional code path tested but coverage intermittently missed */
+        return validatedConditionSetDecl
+            .convert(from, { conditions: this.conditions, conditionSetIndex: this.size })
+            .onSuccess((c) => ConditionSet.create(c));
+    }
+}
+/**
+ * The index of the unconditional condition set.
+ */
+ConditionSetCollector.UnconditionalIndex = Validate.toConditionSetIndex(0).orThrow();
+//# sourceMappingURL=conditionSetCollector.js.map

package/dist/packlets/conditions/conditionSetDecls.js

@@ -0,0 +1,23 @@
+/*
+ * 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 {};
+//# sourceMappingURL=conditionSetDecls.js.map

package/dist/packlets/conditions/conditionToken.js

@@ -0,0 +1,147 @@
+/*
+ * 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 { mapResults, fail, succeed } from '@fgv/ts-utils';
+import { Helpers as CommonHelpers } from '../common';
+/**
+ * Helper class to parse and validate condition tokens.
+ * @public
+ */
+export class ConditionTokens {
+    /**
+     * Constructs a new {@link Conditions.ConditionTokens | ConditionTokens } instance.
+     * @param qualifiers - the {@link Qualifiers.IReadOnlyQualifierCollector | qualifier collector} to use
+     */
+    constructor(qualifiers) {
+        this.qualifiers = qualifiers;
+    }
+    /**i
+     * Parses a {@link ConditionToken | condition token} string and validates the parts
+     * against the qualifiers present in the {@link Conditions.ConditionTokens.qualifiers | qualifier collector}.
+     * @param token - the token string to parse.
+     * @returns `Success` with the {@link Conditions.IValidatedConditionDecl | validated condition declaration}
+     * if successful, `Failure` with an error message if not.
+     */
+    parseConditionToken(token) {
+        return ConditionTokens.parseConditionToken(token, this.qualifiers);
+    }
+    /**
+     * Parses a {@link ConditionSetToken | condition set token} string and validates the parts
+     * against the qualifiers present in the {@link Conditions.ConditionTokens.qualifiers | qualifier collector}.
+     * @param token - the token string to parse.
+     * @returns `Success` with the array of {@link Conditions.IValidatedConditionDecl | validated condition declarations}
+     * if successful, `Failure` with an error message if not.
+     */
+    parseConditionSetToken(token) {
+        return ConditionTokens.parseConditionSetToken(token, this.qualifiers);
+    }
+    /**
+     * Validates the {@link Helpers.IConditionTokenParts | parts} of a {@link ConditionToken | condition token}.
+     * @param parts - the parts to validate
+     * @returns `Success` with the validated declaration if successful, `Failure` with an error message if not.
+     */
+    validateConditionTokenParts(parts) {
+        return ConditionTokens.validateConditionTokenParts(parts, this.qualifiers);
+    }
+    /**
+     * Given a value, finds a single token-optional qualifier that matches the value.
+     * Fails if no qualifiers match, or if more than one qualifier matches.
+     * @param value - the value to match.
+     * @returns `Success` with the matching qualifier if successful, `Failure` with an error message if not.
+     */
+    findQualifierForValue(value) {
+        return ConditionTokens.findQualifierForValue(value, this.qualifiers);
+    }
+    /**
+     * Parses a {@link ConditionToken | condition token} and validates it against the qualifiers
+     * present in the supplied {@link Qualifiers.IReadOnlyQualifierCollector | qualifier collector}.
+     * @param token - the token string to parse.
+     * @param qualifiers - the {@link Qualifiers.IReadOnlyQualifierCollector | qualifier collector} to use
+     * @returns `Success` with a {@link Conditions.IValidatedConditionDecl | validated condition declaration} if successful,
+     * `Failure` with an error message if not.
+     */
+    static parseConditionToken(token, qualifiers) {
+        return CommonHelpers.parseConditionTokenParts(token).onSuccess((parts) => {
+            return ConditionTokens.validateConditionTokenParts(parts, qualifiers);
+        });
+    }
+    /**
+     * Parses a {@link ConditionSetToken | condition set token} and validates it against the qualifiers
+     * present in the supplied {@link Qualifiers.IReadOnlyQualifierCollector | qualifier collector}.
+     * @param token - the token string to parse.
+     * @param qualifiers - the {@link Qualifiers.IReadOnlyQualifierCollector | qualifier collector} to use
+     * @returns `Success` with an array of {@link Conditions.IValidatedConditionDecl | validated condition declarations}
+     * if successful, `Failure` with an error message if not
+     */
+    static parseConditionSetToken(token, qualifiers) {
+        return CommonHelpers.parseConditionSetTokenParts(token).onSuccess((parts) => {
+            return mapResults(parts.map((part) => ConditionTokens.validateConditionTokenParts(part, qualifiers)));
+        });
+    }
+    /**
+     * Validates the parts of a condition token against the qualifiers present in the supplied
+     * {@link Qualifiers.IReadOnlyQualifierCollector | qualifier collector}.
+     * @param parts - the {@link Helpers.IConditionTokenParts | condition token parts} to validate.
+     * @param qualifiers - the {@link Qualifiers.IReadOnlyQualifierCollector | qualifier collector} used to
+     * validate qualifier names and values.
+     * @returns `Success` with a {@link Conditions.IValidatedConditionDecl | validated condition declaration} if successful,
+     * `Failure` with an error message if not.
+     */
+    static validateConditionTokenParts(parts, qualifiers) {
+        const qualifierLookup = parts.qualifier === undefined
+            ? ConditionTokens.findQualifierForValue(parts.value, qualifiers)
+            : qualifiers.getByNameOrToken(parts.qualifier);
+        return qualifierLookup.onSuccess((qualifier) => {
+            return qualifier.type
+                .validateCondition(parts.value)
+                .onSuccess((value) => {
+                const operator = 'matches';
+                const priority = qualifier.defaultPriority;
+                return succeed({ qualifier, value, operator, priority });
+            })
+                .withDetail('failure', 'success');
+        });
+    }
+    /**
+     * Given a value and a set of qualifiers, finds a single token-optional qualifier that matches the value.
+     * Fails if no qualifiers match, or if more than one qualifier matches.
+     * @param value - the value to match.
+     * @param qualifiers - the qualifiers to match against.
+     * @returns `Success` with the matching qualifier if successful, `Failure` with an error message if not.
+     */
+    static findQualifierForValue(value, qualifiers) {
+        const matched = [];
+        for (const qualifier of qualifiers.values()) {
+            if (qualifier.tokenIsOptional && qualifier.validateCondition(value).isSuccess()) {
+                matched.push(qualifier);
+            }
+        }
+        if (matched.length === 0) {
+            return fail(`${value}: does not match any qualifier`);
+        }
+        /* c8 ignore next 3 - functional code path tested but coverage intermittently missed */
+        if (matched.length > 1) {
+            return fail(`${value}: matches multiple qualifiers (${matched.map((q) => q.name).join(', ')})`);
+        }
+        return succeed(matched[0]);
+    }
+}
+//# sourceMappingURL=conditionToken.js.map

package/dist/packlets/conditions/convert/conditionSetDecls.js

@@ -0,0 +1,51 @@
+/*
+ * 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, mapResults, succeed } from '@fgv/ts-utils';
+import { conditionDecl } from './decls';
+/* eslint-disable @rushstack/typedef-var */
+/**
+ * Converter which converts to a {@link Conditions.IConditionSetDecl | condition set declaration}.
+ * @public
+ */
+export const conditionSetDecl = Converters.strictObject({
+    conditions: Converters.arrayOf(conditionDecl)
+});
+/**
+ * Converter which constructs a {@link Conditions.IValidatedConditionSetDecl | validated condition set declaration}
+ * from a {@link Conditions.IConditionSetDecl | condition set declaration}, instantiating qualifiers by name
+ * from a supplied {@link Conditions.Convert.IConditionSetDeclConvertContext | conversion context}.
+ * @public
+ */
+export const validatedConditionSetDecl = Converters.generic((from, __self, context) => {
+    /* c8 ignore next 3 - coverage is having a bad day */
+    if (!context) {
+        return fail('validatedConditionSetDecl converter requires a context');
+    }
+    return conditionSetDecl.convert(from).onSuccess((decl) => {
+        return mapResults(decl.conditions.map((condition) => context.conditions.validating.getOrAdd(condition))).onSuccess((conditions) => {
+            /* c8 ignore next 1 - coverage having issues */
+            const index = context.conditionSetIndex ? context.conditionSetIndex++ : undefined;
+            return succeed({ conditions, index });
+        });
+    });
+});
+//# sourceMappingURL=conditionSetDecls.js.map

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

@@ -0,0 +1,75 @@
+/*
+ * 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 { Converters, populateObject, fail, succeed } from '@fgv/ts-utils';
+/* eslint-disable @rushstack/typedef-var */
+/**
+ * Converter for a {@link Conditions.IConditionDecl | condition declaration}.
+ * @public
+ */
+export const conditionDecl = Converters.strictObject({
+    qualifierName: Converters.string,
+    value: Converters.string,
+    operator: Common.Convert.conditionOperator.optional(),
+    priority: Converters.number.optional(),
+    scoreAsDefault: Converters.number.optional()
+});
+/**
+ * Converter which constructs a {@link Conditions.IValidatedConditionDecl | validated condition declaration}
+ * from a {@link Conditions.IConditionDecl | condition declaration}, instantiating qualifiers by name
+ * from a supplied {@link Conditions.Convert.IConditionDeclConvertContext | conversion context}.
+ * @public
+ */
+export const validatedConditionDecl = Converters.generic((from, __self, context) => {
+    /* c8 ignore next 3 - coverage is having a bad day */
+    if (!context) {
+        return fail('validatedConditionDecl converter requires a context');
+    }
+    return conditionDecl.convert(from).onSuccess((decl) => {
+        var _a;
+        const operator = (_a = decl.operator) !== null && _a !== void 0 ? _a : 'matches';
+        return context.qualifiers.validating.get(decl.qualifierName).onSuccess((qualifier) => {
+            return populateObject({
+                qualifier: () => succeed(qualifier),
+                value: () => qualifier.validateCondition(decl.value, operator),
+                operator: () => succeed(operator),
+                priority: () => decl.priority
+                    ? Common.Convert.conditionPriority.convert(decl.priority)
+                    : succeed(qualifier.defaultPriority),
+                scoreAsDefault: () => decl.scoreAsDefault
+                    ? Common.Convert.qualifierMatchScore.convert(decl.scoreAsDefault)
+                    : succeed(undefined),
+                index: () => context.conditionIndex
+                    ? Common.Convert.conditionIndex.convert(context.conditionIndex)
+                    : succeed(undefined)
+            })
+                .onSuccess((result) => {
+                if (context.conditionIndex !== undefined) {
+                    context.conditionIndex++;
+                }
+                return succeed(result);
+            })
+                .withDetail('success');
+        });
+    });
+});
+//# sourceMappingURL=decls.js.map

package/dist/packlets/conditions/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 './conditionSetDecls';
+//# sourceMappingURL=index.js.map