@fgv/ts-res 5.0.1-1 → 5.0.1-10

package/dist/packlets/qualifiers/qualifier.js

@@ -0,0 +1,108 @@
+/*
+ * 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 } from '@fgv/ts-utils';
+import { Convert as CommonConvert } from '../common';
+/**
+ * Represents a qualifier that can be used to identify the context in
+ * which a resource is used.
+ * @public
+ */
+export class Qualifier {
+    /**
+     * The index of the qualifier.
+     */
+    get index() {
+        return this._collectible.index;
+    }
+    /**
+     * The collector key for this qualifier.
+     */
+    get key() {
+        return this._collectible.key;
+    }
+    /**
+     * Constructs a new instance of a {@link Qualifiers.Qualifier | Qualifier} from the
+     * supplied {@link Qualifiers.IValidatedQualifierDecl | validated declaration}.
+     * @param name - The name of the qualifier.
+     * @param type - The {@link QualifierTypes.QualifierType | type} of the qualifier.
+     * @param defaultPriority - The default {@link ConditionPriority | priority} of conditions
+     * @public
+     */
+    constructor({ name, token, type, defaultPriority, tokenIsOptional, defaultValue, index }) {
+        this.name = name;
+        this.token = token;
+        this.type = type;
+        this.defaultPriority = defaultPriority;
+        this.tokenIsOptional = tokenIsOptional;
+        this.defaultValue = defaultValue;
+        this._collectible = new Collections.Collectible({
+            key: name,
+            index,
+            indexConverter: CommonConvert.qualifierIndex
+        });
+    }
+    /**
+     * Creates a new instance of a {@link Qualifiers.Qualifier | Qualifier} from the
+     * supplied {@link Qualifiers.IValidatedQualifierDecl | validated declaration}.
+     * @param decl - The {@link Qualifiers.IValidatedQualifierDecl | validated declaration}
+     * for the new instance.
+     * @returns `Success` with the new {@link Qualifiers.Qualifier | Qualifier} if successful,
+     * `Failure` with an error message otherwise.
+     * @public
+     */
+    static create(decl) {
+        return captureResult(() => new Qualifier(decl));
+    }
+    /**
+     * Sets the index of this qualifier.  Once set, the index cannot be changed.
+     * @param index - The index to set.
+     * @returns `Success` with the index if successful, `Failure` with an error message otherwise.
+     */
+    setIndex(index) {
+        return this._collectible.setIndex(index);
+    }
+    /**
+     * {@inheritdoc QualifierTypes.QualifierType.isValidContextValue}
+     */
+    isValidContextValue(value) {
+        return this.type.isValidContextValue(value);
+    }
+    /**
+     * {@inheritdoc QualifierTypes.QualifierType.isValidConditionValue}
+     */
+    isValidConditionValue(value) {
+        return this.type.isValidConditionValue(value);
+    }
+    /**
+     * {@inheritdoc QualifierTypes.QualifierType.validateCondition}
+     */
+    validateCondition(value, operator) {
+        return this.type.validateCondition(value, operator);
+    }
+    /**
+     * {@inheritdoc QualifierTypes.QualifierType.validateContextValue}
+     */
+    validateContextValue(value) {
+        return this.type.validateContextValue(value);
+    }
+}
+//# sourceMappingURL=qualifier.js.map

package/dist/packlets/qualifiers/qualifierCollector.js

@@ -0,0 +1,123 @@
+/*
+ * 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 { captureResult, Collections, failWithDetail, fail, succeed, succeedWithDetail, ValidatingConvertingCollector } from '@fgv/ts-utils';
+import { Qualifier } from './qualifier';
+import { qualifierDecl, validatedQualifierDecl } from './convert';
+/**
+ * Collects {@link Qualifiers.Qualifier | Qualifiers} from {@link Qualifiers.IQualifierDecl | declarations},
+ * with strongly-typed ({@link QualifierName | QualifierName} and {@link QualifierIndex | QualifierIndex}) key
+ * and index.
+ * @public
+ */
+export class QualifierCollector extends ValidatingConvertingCollector {
+    /**
+     * Constructor for a {@link Qualifiers.QualifierCollector | QualifierCollector} object.
+     * @param params - Parameters for creating the collector.
+     * @public
+     */
+    constructor(params) {
+        var _a;
+        super({
+            factory: (k, i, v) => this._qualifierFactory(k, i, v),
+            converters: new Collections.KeyValueConverters({
+                key: Common.Convert.qualifierName,
+                value: qualifierDecl
+            })
+        });
+        this.qualifierTypes = params.qualifierTypes;
+        /* c8 ignore next 1 - coverage misses the branch intermittently */
+        (_a = params.qualifiers) === null || _a === void 0 ? void 0 : _a.forEach((q) => this.validating.add(q.name, q).orThrow());
+    }
+    /**
+     * Creates a new {@link Qualifiers.QualifierCollector | QualifierCollector} object.
+     * @param params - {@link Qualifiers.IQualifierCollectorCreateParams | Parameters} for creating a new {@link Qualifiers.QualifierCollector | QualifierCollector}.
+     * @returns `Success` with the new collector if successful, or `Failure` if not.
+     */
+    static create(params) {
+        return captureResult(() => new QualifierCollector(params));
+    }
+    /**
+     * {@inheritdoc Qualifiers.IReadOnlyQualifierCollector.getByNameOrToken}
+     */
+    getByNameOrToken(nameOrToken) {
+        return this.validating.get(nameOrToken).onFailure((message) => {
+            for (const q of this.values()) {
+                if (q.token === nameOrToken) {
+                    return succeedWithDetail(q, 'success');
+                }
+            }
+            return failWithDetail(`Qualifier token '${nameOrToken}' not found`, 'not-found');
+        });
+    }
+    /**
+     * {@inheritdoc Qualifiers.IReadOnlyQualifierCollector.hasNameOrToken}
+     */
+    hasNameOrToken(nameOrToken) {
+        /* c8 ignore next 3 - functional code path tested but coverage intermittently missed */
+        if (this.validating.has(nameOrToken)) {
+            return true;
+        }
+        for (const q of this.values()) {
+            /* c8 ignore next 3 - functional code path tested but coverage intermittently missed */
+            if (q.token === nameOrToken) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Gets a read-only view of this collector.
+     * @returns A read-only view of this collector.
+     */
+    toReadOnly() {
+        return this;
+    }
+    /**
+     * Factory method for creating a {@link Qualifiers.Qualifier | Qualifier} from a {@link Qualifiers.IQualifierDecl | declaration}.
+     * @param __key - The key for the qualifier.
+     * @param index - The index of the qualifier.
+     * @param decl - The {@link Qualifiers.IQualifierDecl | declaration} for the qualifier.
+     * @returns `Success` with the new {@link Qualifiers.Qualifier | Qualifier} if successful, or `Failure` if not.
+     * @public
+     */
+    _qualifierFactory(__key, index, decl) {
+        const convertContext = {
+            qualifierTypes: this.qualifierTypes,
+            qualifierIndex: index
+        };
+        return validatedQualifierDecl
+            .convert(decl, convertContext)
+            .onSuccess((validated) => {
+            /* c8 ignore next 9 - coverage intermittently misses this block */
+            if (this.hasNameOrToken(validated.token)) {
+                return fail(`Qualifier token '${validated.token}' is not unique or collides with name`);
+            }
+            else if (this.hasNameOrToken(validated.name)) {
+                return fail(`Qualifier name '${validated.name}' is not unique or collides with token`);
+            }
+            return succeed(validated);
+        })
+            .onSuccess(Qualifier.create);
+    }
+}
+//# sourceMappingURL=qualifierCollector.js.map

package/dist/packlets/qualifiers/qualifierDecl.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=qualifierDecl.js.map

package/dist/packlets/qualifiers/qualifierDefaultValueDecls.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=qualifierDefaultValueDecls.js.map

package/dist/packlets/qualifiers/qualifierDefaultValueToken.js

@@ -0,0 +1,175 @@
+/*
+ * 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 qualifier default value tokens.
+ * @public
+ */
+export class QualifierDefaultValueTokens {
+    /**
+     * Constructs a new {@link Qualifiers.QualifierDefaultValueTokens | QualifierDefaultValueTokens } instance.
+     * @param qualifiers - the {@link Qualifiers.IReadOnlyQualifierCollector | qualifier collector} to use
+     */
+    constructor(qualifiers) {
+        this.qualifiers = qualifiers;
+    }
+    /**
+     * Parses a {@link QualifierDefaultValueToken | qualifier default value token} string and validates the parts
+     * against the qualifiers present in the {@link Qualifiers.QualifierDefaultValueTokens.qualifiers | qualifier collector}.
+     * @param token - the token string to parse.
+     * @returns `Success` with the {@link Qualifiers.IValidatedQualifierDefaultValueDecl | validated qualifier default value declaration}
+     * if successful, `Failure` with an error message if not.
+     */
+    parseQualifierDefaultValueToken(token) {
+        return QualifierDefaultValueTokens.parseQualifierDefaultValueToken(token, this.qualifiers);
+    }
+    /**
+     * Parses a {@link QualifierDefaultValuesToken | qualifier default values token} string and validates the parts
+     * against the qualifiers present in the {@link Qualifiers.QualifierDefaultValueTokens.qualifiers | qualifier collector}.
+     * @param token - the token string to parse.
+     * @returns `Success` with the array of {@link Qualifiers.IValidatedQualifierDefaultValueDecl | validated qualifier default value declarations}
+     * if successful, `Failure` with an error message if not.
+     */
+    parseQualifierDefaultValuesToken(token) {
+        return QualifierDefaultValueTokens.parseQualifierDefaultValuesToken(token, this.qualifiers);
+    }
+    /**
+     * Validates the {@link Helpers.IQualifierDefaultValueTokenParts | parts} of a {@link QualifierDefaultValueToken | qualifier default value token}.
+     * @param parts - the parts to validate
+     * @returns `Success` with the validated declaration if successful, `Failure` with an error message if not.
+     */
+    validateQualifierDefaultValueTokenParts(parts) {
+        return QualifierDefaultValueTokens.validateQualifierDefaultValueTokenParts(parts, this.qualifiers);
+    }
+    /**
+     * Converts a {@link QualifierDefaultValuesToken | qualifier default values token} to a validated qualifier default values declaration.
+     * @param token - the qualifier default values token to convert
+     * @returns `Success` with the validated qualifier default values declaration if successful, `Failure` with an error message if not.
+     */
+    qualifierDefaultValuesTokenToDecl(token) {
+        return QualifierDefaultValueTokens.qualifierDefaultValuesTokenToDecl(token, this.qualifiers);
+    }
+    /**
+     * Converts a validated qualifier default values declaration to a {@link QualifierDefaultValuesToken | qualifier default values token}.
+     * @param decl - the validated qualifier default values declaration to convert
+     * @returns `Success` with the qualifier default values token if successful, `Failure` with an error message if not.
+     */
+    declToQualifierDefaultValuesToken(decl) {
+        return QualifierDefaultValueTokens.declToQualifierDefaultValuesToken(decl);
+    }
+    /**
+     * Parses a {@link QualifierDefaultValueToken | qualifier default value 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 Qualifiers.IValidatedQualifierDefaultValueDecl | validated qualifier default value declaration} if successful,
+     * `Failure` with an error message if not.
+     */
+    static parseQualifierDefaultValueToken(token, qualifiers) {
+        return CommonHelpers.parseQualifierDefaultValueTokenParts(token).onSuccess((parts) => {
+            return QualifierDefaultValueTokens.validateQualifierDefaultValueTokenParts(parts, qualifiers);
+        });
+    }
+    /**
+     * Parses a {@link QualifierDefaultValuesToken | qualifier default values 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 Qualifiers.IValidatedQualifierDefaultValueDecl | validated qualifier default value declarations}
+     * if successful, `Failure` with an error message if not
+     */
+    static parseQualifierDefaultValuesToken(token, qualifiers) {
+        return CommonHelpers.parseQualifierDefaultValuesTokenParts(token).onSuccess((parts) => {
+            return mapResults(parts.map((part) => QualifierDefaultValueTokens.validateQualifierDefaultValueTokenParts(part, qualifiers)));
+        });
+    }
+    /**
+     * Validates the parts of a qualifier default value token against the qualifiers present in the supplied
+     * {@link Qualifiers.IReadOnlyQualifierCollector | qualifier collector}.
+     * @param parts - the {@link Helpers.IQualifierDefaultValueTokenParts | qualifier default value token parts} to validate.
+     * @param qualifiers - the {@link Qualifiers.IReadOnlyQualifierCollector | qualifier collector} used to
+     * validate qualifier names and values.
+     * @returns `Success` with a {@link Qualifiers.IValidatedQualifierDefaultValueDecl | validated qualifier default value declaration} if successful,
+     * `Failure` with an error message if not.
+     */
+    static validateQualifierDefaultValueTokenParts(parts, qualifiers) {
+        return qualifiers.getByNameOrToken(parts.qualifier).onSuccess((qualifier) => {
+            // Allow empty values to remove defaults
+            if (parts.value === '') {
+                return succeed({ qualifier, value: '' });
+            }
+            return qualifier.type
+                .validateContextValue(parts.value)
+                .onSuccess((value) => {
+                return succeed({ qualifier, value });
+            })
+                .withDetail('failure', 'success');
+        });
+    }
+    /**
+     * Converts a {@link QualifierDefaultValuesToken | qualifier default values token} to a validated qualifier default values declaration.
+     * @param token - the qualifier default values token to convert
+     * @param qualifiers - the {@link Qualifiers.IReadOnlyQualifierCollector | qualifier collector} to use
+     * @returns `Success` with the validated qualifier default values declaration if successful, `Failure` with an error message if not.
+     */
+    static qualifierDefaultValuesTokenToDecl(token, qualifiers) {
+        return QualifierDefaultValueTokens.parseQualifierDefaultValuesToken(token, qualifiers).onSuccess((qualifierDefaultValues) => {
+            const defaultValues = {};
+            for (const { qualifier, value } of qualifierDefaultValues) {
+                const qualifierName = qualifier.name;
+                const contextValue = value;
+                // Check for duplicate qualifiers
+                if (qualifierName in defaultValues) {
+                    return fail(`${qualifier.name}: duplicate qualifier in default values token`);
+                }
+                // Only add non-empty values (empty values remove defaults)
+                if (contextValue !== '') {
+                    defaultValues[qualifierName] = contextValue;
+                }
+            }
+            return succeed(defaultValues);
+        });
+    }
+    /**
+     * Converts a validated qualifier default values declaration to a {@link QualifierDefaultValuesToken | qualifier default values token}.
+     * @param decl - the validated qualifier default values declaration to convert
+     * @returns `Success` with the qualifier default values token if successful, `Failure` with an error message if not.
+     */
+    static declToQualifierDefaultValuesToken(decl) {
+        const tokens = [];
+        for (const [qualifierName, contextValue] of Object.entries(decl)) {
+            // Build token as "qualifier=value"
+            tokens.push(`${qualifierName}=${contextValue}`);
+        }
+        if (tokens.length === 0) {
+            return succeed('');
+        }
+        const tokenString = tokens.join('|');
+        // Validate the generated token
+        return CommonHelpers.buildQualifierDefaultValuesToken(tokens.map((token) => {
+            const [qualifier, value] = token.split('=');
+            return { qualifier, value };
+        })).onSuccess(() => succeed(tokenString));
+    }
+}
+//# sourceMappingURL=qualifierDefaultValueToken.js.map

package/dist/packlets/resource-json/compiled/common.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=common.js.map

package/dist/packlets/resource-json/compiled/convert.js

@@ -0,0 +1,132 @@
+/*
+ * 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 } from '@fgv/ts-utils';
+import { Converters as JsonConverters } from '@fgv/ts-json-base';
+/* eslint-disable @rushstack/typedef-var */
+/**
+ * Converter for a {@link ResourceJson.Compiled.ICompiledConditionMetadata | compiled condition metadata}.
+ * @public
+ */
+export const compiledConditionMetadata = Converters.strictObject({
+    key: Common.Convert.conditionKey
+});
+/**
+ * Converter for a {@link ResourceJson.Compiled.ICompiledConditionSetMetadata | compiled condition set metadata}.
+ * @public
+ */
+export const compiledConditionSetMetadata = Converters.strictObject({
+    key: Common.Convert.conditionSetKey
+});
+/**
+ * Converter for a {@link ResourceJson.Compiled.ICompiledDecisionMetadata | compiled decision metadata}.
+ * @public
+ */
+export const compiledDecisionMetadata = Converters.strictObject({
+    key: Common.Convert.decisionKey
+});
+/**
+ * Converter for a {@link ResourceJson.Compiled.ICompiledQualifierType | compiled qualifier type}.
+ * @public
+ */
+export const compiledQualifierType = Converters.strictObject({
+    name: Common.Convert.qualifierTypeName
+});
+/**
+ * Converter for a {@link ResourceJson.Compiled.ICompiledQualifier | compiled qualifier}.
+ * @public
+ */
+export const compiledQualifier = Converters.strictObject({
+    name: Common.Convert.qualifierName,
+    type: Common.Convert.qualifierTypeIndex,
+    defaultPriority: Common.Convert.conditionPriority
+});
+/**
+ * Converter for a {@link ResourceJson.Compiled.ICompiledResourceType | compiled resource type}.
+ * @public
+ */
+export const compiledResourceType = Converters.strictObject({
+    name: Common.Convert.resourceTypeName
+});
+/**
+ * Converter for a {@link ResourceJson.Compiled.ICompiledCondition | compiled condition}.
+ * @public
+ */
+export const compiledCondition = Converters.strictObject({
+    qualifierIndex: Common.Convert.qualifierIndex,
+    operator: Common.Convert.conditionOperator.optional(),
+    value: Converters.string,
+    priority: Common.Convert.conditionPriority,
+    scoreAsDefault: Common.Convert.qualifierMatchScore.optional(),
+    metadata: compiledConditionMetadata.optional()
+});
+/**
+ * Converter for a {@link ResourceJson.Compiled.ICompiledConditionSet | compiled condition set}.
+ * @public
+ */
+export const compiledConditionSet = Converters.strictObject({
+    conditions: Converters.arrayOf(Common.Convert.conditionIndex),
+    metadata: compiledConditionSetMetadata.optional()
+});
+/**
+ * Converter for a {@link ResourceJson.Compiled.ICompiledAbstractDecision | compiled abstract decision}.
+ * @public
+ */
+export const compiledAbstractDecision = Converters.strictObject({
+    conditionSets: Converters.arrayOf(Common.Convert.conditionSetIndex),
+    metadata: compiledDecisionMetadata.optional()
+});
+/**
+ * Converter for a {@link ResourceJson.Compiled.ICompiledCandidate | compiled candidate}.
+ * @public
+ */
+export const compiledCandidate = Converters.strictObject({
+    valueIndex: Common.Convert.candidateValueIndex,
+    isPartial: Converters.boolean,
+    mergeMethod: Common.Convert.resourceValueMergeMethod
+});
+/**
+ * Converter for a {@link ResourceJson.Compiled.ICompiledResource | compiled resource}.
+ * @public
+ */
+export const compiledResource = Converters.strictObject({
+    id: Common.Convert.resourceId,
+    type: Common.Convert.resourceTypeIndex,
+    decision: Common.Convert.decisionIndex,
+    candidates: Converters.arrayOf(compiledCandidate)
+});
+/**
+ * Converter for a {@link ResourceJson.Compiled.ICompiledResourceCollection | compiled resource collection}.
+ * This combines all the individual converters into a single converter for the entire resource collection.
+ * @public
+ */
+export const compiledResourceCollection = Converters.strictObject({
+    qualifiers: Converters.arrayOf(compiledQualifier),
+    qualifierTypes: Converters.arrayOf(compiledQualifierType),
+    resourceTypes: Converters.arrayOf(compiledResourceType),
+    conditions: Converters.arrayOf(compiledCondition),
+    conditionSets: Converters.arrayOf(compiledConditionSet),
+    decisions: Converters.arrayOf(compiledAbstractDecision),
+    candidateValues: Converters.arrayOf(JsonConverters.jsonValue),
+    resources: Converters.arrayOf(compiledResource)
+});
+//# sourceMappingURL=convert.js.map

package/dist/packlets/resource-json/compiled/index.js

@@ -0,0 +1,26 @@
+/*
+ * 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 './common';
+export * from './json';
+export { Convert };
+//# sourceMappingURL=index.js.map

package/dist/packlets/resource-json/compiled/json.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=json.js.map