@fgv/ts-res 5.1.0-3 → 5.1.0-31

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/packlets/qualifiers/convert/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC","sourcesContent":["/*\n * Copyright (c) 2025 Erik Fortune\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\nexport * from './decls';\nexport * from './qualifier';\n"]}

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

@@ -0,0 +1 @@
+{"version":3,"file":"qualifier.js","sourceRoot":"","sources":["../../../../src/packlets/qualifiers/convert/qualifier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,UAAU,EAAU,IAAI,EAAE,MAAM,eAAe,CAAC;AAezD;;;;GAIG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,UAAU,CAAC,OAAO,CACzC,CAAC,IAAa,EAAE,MAAM,EAAE,OAAkC,EAAqB,EAAE;IAC/E,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;QAC1B,OAAO,IAAI,CAAC,wCAAwC,CAAC,CAAC;IACxD,CAAC;IACD,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;QAC7B,OAAO,OAAO,CAAC,UAAU,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;IACjD,CAAC;SAAM,IAAI,OAAO,IAAI,KAAK,QAAQ,EAAE,CAAC;QACpC,OAAO,OAAO,CAAC,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IACxC,CAAC;IACD,OAAO,IAAI,CAAC,iDAAiD,CAAC,CAAC;AACjE,CAAC,CACF,CAAC","sourcesContent":["/*\n * Copyright (c) 2025 Erik Fortune\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\nimport { Converters, Result, fail } from '@fgv/ts-utils';\nimport { IReadOnlyQualifierCollector } from '../qualifierCollector';\nimport { Qualifier } from '../qualifier';\n\n/* eslint-disable @rushstack/typedef-var */\n\n/**\n * Context necessary to convert a string or number to a\n * {@link Qualifiers.Qualifier | Qualifier} object.\n * @public\n */\nexport interface IQualifierConvertContext {\n  qualifiers: IReadOnlyQualifierCollector;\n}\n\n/**\n * Converter which choose a qualifier by name or number from a\n * supplied {@link Qualifiers.Convert.IQualifierConvertContext | conversion context}.\n * @public\n */\nexport const qualifier = Converters.generic<Qualifier, IQualifierConvertContext>(\n  (from: unknown, __self, context?: IQualifierConvertContext): Result<Qualifier> => {\n    if (context === undefined) {\n      return fail('qualifier converter requires a context');\n    }\n    if (typeof from === 'string') {\n      return context.qualifiers.validating.get(from);\n    } else if (typeof from === 'number') {\n      return context.qualifiers.getAt(from);\n    }\n    return fail('qualifier converter requires a string or number');\n  }\n);\n"]}

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/packlets/qualifiers/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC;AAErC,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC;AACrC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,8BAA8B,CAAC;AAE7C,OAAO,EAAE,OAAO,EAAE,CAAC","sourcesContent":["/*\n * Copyright (c) 2025 Erik Fortune\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\nimport * as Convert from './convert';\n\nexport * from './qualifier';\nexport * from './qualifierDecl';\nexport * from './qualifierCollector';\nexport * from './qualifierDefaultValueDecls';\nexport * from './qualifierDefaultValueToken';\n\nexport { Convert };\n"]}

package/dist/packlets/qualifiers/qualifier.js

@@ -42,9 +42,8 @@ export class Qualifier {
     /**
      * 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
+     * @param decl - The {@link Qualifiers.IValidatedQualifierDecl | validated declaration}
+     * describing the qualifier to construct.
      * @public
      */
     constructor({ name, token, type, defaultPriority, tokenIsOptional, defaultValue, index }) {
@@ -81,25 +80,25 @@ export class Qualifier {
         return this._collectible.setIndex(index);
     }
     /**
-     * {@inheritdoc QualifierTypes.QualifierType.isValidContextValue}
+     * {@inheritDoc QualifierTypes.QualifierType.isValidContextValue}
      */
     isValidContextValue(value) {
         return this.type.isValidContextValue(value);
     }
     /**
-     * {@inheritdoc QualifierTypes.QualifierType.isValidConditionValue}
+     * {@inheritDoc QualifierTypes.QualifierType.isValidConditionValue}
      */
     isValidConditionValue(value) {
         return this.type.isValidConditionValue(value);
     }
     /**
-     * {@inheritdoc QualifierTypes.QualifierType.validateCondition}
+     * {@inheritDoc QualifierTypes.QualifierType.validateCondition}
      */
     validateCondition(value, operator) {
         return this.type.validateCondition(value, operator);
     }
     /**
-     * {@inheritdoc QualifierTypes.QualifierType.validateContextValue}
+     * {@inheritDoc QualifierTypes.QualifierType.validateContextValue}
      */
     validateContextValue(value) {
         return this.type.validateContextValue(value);

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

@@ -0,0 +1 @@
+{"version":3,"file":"qualifier.js","sourceRoot":"","sources":["../../../src/packlets/qualifiers/qualifier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,EAAE,aAAa,EAAE,WAAW,EAAwB,MAAM,eAAe,CAAC;AACjF,OAAO,EAIL,OAAO,IAAI,aAAa,EAIzB,MAAM,WAAW,CAAC;AAInB;;;;GAIG;AACH,MAAM,OAAO,SAAS;IA2BpB;;OAEG;IACH,IAAW,KAAK;QACd,OAAO,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC;IACjC,CAAC;IAED;;OAEG;IACH,IAAW,GAAG;QACZ,OAAO,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC;IAC/B,CAAC;IAUD;;;;;;OAMG;IACH,YAAsB,EACpB,IAAI,EACJ,KAAK,EACL,IAAI,EACJ,eAAe,EACf,eAAe,EACf,YAAY,EACZ,KAAK,EACmB;QACxB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,eAAe,GAAG,eAAe,CAAC;QACvC,IAAI,CAAC,eAAe,GAAG,eAAe,CAAC;QACvC,IAAI,CAAC,YAAY,GAAG,YAAY,CAAC;QACjC,IAAI,CAAC,YAAY,GAAG,IAAI,WAAW,CAAC,WAAW,CAAgC;YAC7E,GAAG,EAAE,IAAI;YACT,KAAK;YACL,cAAc,EAAE,aAAa,CAAC,cAAc;SAC7C,CAAC,CAAC;IACL,CAAC;IAED;;;;;;;;OAQG;IACI,MAAM,CAAC,MAAM,CAAC,IAA6B;QAChD,OAAO,aAAa,CAAC,GAAG,EAAE,CAAC,IAAI,SAAS,CAAC,IAAI,CAAC,CAAC,CAAC;IAClD,CAAC;IAED;;;;OAIG;IACI,QAAQ,CAAC,KAAqB;QACnC,OAAO,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC3C,CAAC;IAED;;OAEG;IACI,mBAAmB,CAAC,KAAa;QACtC,OAAO,IAAI,CAAC,IAAI,CAAC,mBAAmB,CAAC,KAAK,CAAC,CAAC;IAC9C,CAAC;IAED;;OAEG;IACI,qBAAqB,CAAC,KAAa;QACxC,OAAO,IAAI,CAAC,IAAI,CAAC,qBAAqB,CAAC,KAAK,CAAC,CAAC;IAChD,CAAC;IAED;;OAEG;IACI,iBAAiB,CAAC,KAAa,EAAE,QAA4B;QAClE,OAAO,IAAI,CAAC,IAAI,CAAC,iBAAiB,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;IACtD,CAAC;IAED;;OAEG;IACI,oBAAoB,CAAC,KAAa;QACvC,OAAO,IAAI,CAAC,IAAI,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC;IAC/C,CAAC;CACF","sourcesContent":["/*\n * Copyright (c) 2025 Erik Fortune\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\nimport { captureResult, Collections, ICollectible, Result } from '@fgv/ts-utils';\nimport {\n  ConditionPriority,\n  QualifierIndex,\n  QualifierName,\n  Convert as CommonConvert,\n  QualifierContextValue,\n  QualifierConditionValue,\n  ConditionOperator\n} from '../common';\nimport { QualifierType } from '../qualifier-types';\nimport { IValidatedQualifierDecl } from './qualifierDecl';\n\n/**\n * Represents a qualifier that can be used to identify the context in\n * which a resource is used.\n * @public\n */\nexport class Qualifier implements IValidatedQualifierDecl, ICollectible<QualifierName, QualifierIndex> {\n  /**\n   * The name of the qualifier.\n   */\n  public readonly name: QualifierName;\n\n  /**\n   * The token used to identify the qualifier in the name or\n   * path of a resource being imported.\n   */\n  public readonly token: QualifierName;\n\n  /**\n   * The {@link QualifierTypes.QualifierType | type} of the qualifier.\n   */\n  public readonly type: QualifierType;\n\n  /**\n   * Indicates whether the token is optional in the name or path of a resource being imported.\n   */\n  public readonly tokenIsOptional: boolean;\n\n  /**\n   * Optional default value for the qualifier.\n   */\n  public readonly defaultValue?: QualifierContextValue;\n\n  /**\n   * The index of the qualifier.\n   */\n  public get index(): QualifierIndex | undefined {\n    return this._collectible.index;\n  }\n\n  /**\n   * The collector key for this qualifier.\n   */\n  public get key(): QualifierName {\n    return this._collectible.key;\n  }\n\n  /**\n   * The default {@link ConditionPriority | priority} of conditions\n   * that depend on this qualifier.\n   */\n  public readonly defaultPriority: ConditionPriority;\n\n  protected readonly _collectible: Collections.Collectible<QualifierName, QualifierIndex>;\n\n  /**\n   * Constructs a new instance of a {@link Qualifiers.Qualifier | Qualifier} from the\n   * supplied {@link Qualifiers.IValidatedQualifierDecl | validated declaration}.\n   * @param decl - The {@link Qualifiers.IValidatedQualifierDecl | validated declaration}\n   * describing the qualifier to construct.\n   * @public\n   */\n  protected constructor({\n    name,\n    token,\n    type,\n    defaultPriority,\n    tokenIsOptional,\n    defaultValue,\n    index\n  }: IValidatedQualifierDecl) {\n    this.name = name;\n    this.token = token;\n    this.type = type;\n    this.defaultPriority = defaultPriority;\n    this.tokenIsOptional = tokenIsOptional;\n    this.defaultValue = defaultValue;\n    this._collectible = new Collections.Collectible<QualifierName, QualifierIndex>({\n      key: name,\n      index,\n      indexConverter: CommonConvert.qualifierIndex\n    });\n  }\n\n  /**\n   * Creates a new instance of a {@link Qualifiers.Qualifier | Qualifier} from the\n   * supplied {@link Qualifiers.IValidatedQualifierDecl | validated declaration}.\n   * @param decl - The {@link Qualifiers.IValidatedQualifierDecl | validated declaration}\n   * for the new instance.\n   * @returns `Success` with the new {@link Qualifiers.Qualifier | Qualifier} if successful,\n   * `Failure` with an error message otherwise.\n   * @public\n   */\n  public static create(decl: IValidatedQualifierDecl): Result<Qualifier> {\n    return captureResult(() => new Qualifier(decl));\n  }\n\n  /**\n   * Sets the index of this qualifier.  Once set, the index cannot be changed.\n   * @param index - The index to set.\n   * @returns `Success` with the index if successful, `Failure` with an error message otherwise.\n   */\n  public setIndex(index: QualifierIndex): Result<QualifierIndex> {\n    return this._collectible.setIndex(index);\n  }\n\n  /**\n   * {@inheritDoc QualifierTypes.QualifierType.isValidContextValue}\n   */\n  public isValidContextValue(value: string): value is QualifierContextValue {\n    return this.type.isValidContextValue(value);\n  }\n\n  /**\n   * {@inheritDoc QualifierTypes.QualifierType.isValidConditionValue}\n   */\n  public isValidConditionValue(value: string): value is QualifierConditionValue {\n    return this.type.isValidConditionValue(value);\n  }\n\n  /**\n   * {@inheritDoc QualifierTypes.QualifierType.validateCondition}\n   */\n  public validateCondition(value: string, operator?: ConditionOperator): Result<QualifierConditionValue> {\n    return this.type.validateCondition(value, operator);\n  }\n\n  /**\n   * {@inheritDoc QualifierTypes.QualifierType.validateContextValue}\n   */\n  public validateContextValue(value: string): Result<QualifierContextValue> {\n    return this.type.validateContextValue(value);\n  }\n}\n"]}

package/dist/packlets/qualifiers/qualifierCollector.js

@@ -20,9 +20,20 @@
  * SOFTWARE.
  */
 import * as Common from '../common';
-import { captureResult, Collections, failWithDetail, fail, succeed, succeedWithDetail, ValidatingConvertingCollector } from '@fgv/ts-utils';
+import { captureResult, Collections, Converters, failWithDetail, mapResults, fail, succeed, succeedWithDetail, ValidatingConvertingCollector } from '@fgv/ts-utils';
+import { MaxConditionPriority, MinConditionPriority } from '../common';
 import { Qualifier } from './qualifier';
 import { qualifierDecl, validatedQualifierDecl } from './convert';
+import { LiteralQualifierType, QualifierTypeCollector } from '../qualifier-types';
+/**
+ * Converter for a single entry in the mixed-shape
+ * {@link Qualifiers.IQualifierCollectorCreateParams.qualifiers | qualifiers}
+ * input — either a bare axis-name string or a full
+ * {@link Qualifiers.IQualifierDecl | declaration}. Validates the entry
+ * shape at the public-API boundary rather than deferring to the
+ * internal qualifier factory.
+ */
+const _qualifierEntriesConverter = Converters.arrayOf(Converters.oneOf([Converters.string, qualifierDecl]));
 /**
  * Collects {@link Qualifiers.Qualifier | Qualifiers} from {@link Qualifiers.IQualifierDecl | declarations},
  * with strongly-typed ({@link QualifierName | QualifierName} and {@link QualifierIndex | QualifierIndex}) key
@@ -32,11 +43,12 @@ import { qualifierDecl, validatedQualifierDecl } from './convert';
 export class QualifierCollector extends ValidatingConvertingCollector {
     /**
      * Constructor for a {@link Qualifiers.QualifierCollector | QualifierCollector} object.
-     * @param params - Parameters for creating the collector.
+     * @param qualifierTypes - The {@link QualifierTypes.ReadOnlyQualifierTypeCollector | qualifier types}
+     * used to validate declarations.
+     * @param qualifiers - Optional list of fully-resolved {@link Qualifiers.IQualifierDecl | declarations}.
      * @public
      */
-    constructor(params) {
-        var _a;
+    constructor(qualifierTypes, qualifiers) {
         super({
             factory: (k, i, v) => this._qualifierFactory(k, i, v),
             converters: new Collections.KeyValueConverters({
@@ -44,20 +56,152 @@ export class QualifierCollector extends ValidatingConvertingCollector {
                 value: qualifierDecl
             })
         });
-        this.qualifierTypes = params.qualifierTypes;
+        this.qualifierTypes = 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());
+        qualifiers === null || qualifiers === void 0 ? void 0 : qualifiers.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.
+     *
+     * @remarks
+     * Accepts a mixed array of bare axis-name strings and full
+     * {@link Qualifiers.IQualifierDecl | declarations}. String elements are sugar
+     * for a literal qualifier: the library synthesizes a
+     * {@link QualifierTypes.LiteralQualifierType | LiteralQualifierType} named
+     * after the string and a declaration `{ name, typeName: name, defaultPriority }`.
+     * Synthesized priorities are distributed across the
+     * `[MinConditionPriority..MaxConditionPriority]` range adaptively to the
+     * input length (`step = max(1, floor((Max - Min) / length))`,
+     * `priority = max(Min, Max - index * step)`). Earlier elements get higher
+     * priority — matching the "earlier qualifier wins when multiple match"
+     * mental model — and the formula never overflows the `ConditionPriority`
+     * range regardless of input length.
+     *
+     * `qualifierTypes` may be omitted only when every element of `qualifiers`
+     * is a string. If any element is a declaration, `qualifierTypes` is
+     * required (and must include the referenced typeNames); the error message
+     * names the offending typeName when it is missing.
      */
     static create(params) {
-        return captureResult(() => new QualifierCollector(params));
+        return QualifierCollector._resolveCreateParams(params).onSuccess(({ qualifierTypes, qualifiers }) => {
+            return captureResult(() => new QualifierCollector(qualifierTypes, qualifiers));
+        });
+    }
+    /**
+     * Resolves the public {@link Qualifiers.IQualifierCollectorCreateParams | create params}
+     * into the concrete `(qualifierTypes, qualifiers)` pair the constructor expects.
+     *
+     * @remarks
+     * Validates the mixed-shape `qualifiers` input through
+     * {@link Converters.oneOf} (string vs {@link Qualifiers.IQualifierDecl})
+     * at the public-API boundary, then partitions into bare-string and decl
+     * buckets to drive type synthesis. If any decl is present and
+     * `qualifierTypes` is omitted, fails with an error that names the
+     * offending typeNames.
+     *
+     * @internal
+     */
+    static _resolveCreateParams(params) {
+        const raw = params.qualifiers;
+        if (raw === undefined || raw.length === 0) {
+            if (params.qualifierTypes === undefined) {
+                return succeed({ qualifierTypes: QualifierCollector._emptyQualifierTypes(), qualifiers: undefined });
+            }
+            return succeed({ qualifierTypes: params.qualifierTypes, qualifiers: undefined });
+        }
+        return _qualifierEntriesConverter.convert(raw).onSuccess((entries) => {
+            const stringNames = [];
+            const declTypeNames = [];
+            for (const entry of entries) {
+                if (typeof entry === 'string') {
+                    stringNames.push(entry);
+                }
+                else {
+                    declTypeNames.push(entry.typeName);
+                }
+            }
+            if (declTypeNames.length > 0 && params.qualifierTypes === undefined) {
+                const unique = Array.from(new Set(declTypeNames));
+                return fail(`qualifierTypes must be supplied when qualifiers include declarations; ` +
+                    `missing types for: ${unique.map((n) => `'${n}'`).join(', ')}`);
+            }
+            return QualifierCollector._resolveQualifierTypes(params.qualifierTypes, stringNames).onSuccess((qualifierTypes) => {
+                const decls = QualifierCollector._normalizeQualifierDecls(entries);
+                return succeed({ qualifierTypes, qualifiers: decls });
+            });
+        });
+    }
+    /**
+     * Returns the provided {@link QualifierTypes.ReadOnlyQualifierTypeCollector | qualifier-type collector}
+     * (or synthesizes a new one) augmented with synthesized literal qualifier types for the supplied
+     * string names that are not already present.
+     *
+     * @internal
+     */
+    static _resolveQualifierTypes(provided, stringNames) {
+        if (stringNames.length === 0) {
+            // No bare names to synthesize. The all-decls case requires `provided` to be defined
+            // (else _resolveCreateParams would have failed before calling us); fall back to an
+            // empty type collector only as a defensive measure.
+            /* c8 ignore next 1 - defensive: unreachable when called from _resolveCreateParams */
+            return succeed(provided !== null && provided !== void 0 ? provided : QualifierCollector._emptyQualifierTypes());
+        }
+        return mapResults(stringNames.map((name) => LiteralQualifierType.create({ name }))).onSuccess((literalTypes) => {
+            return QualifierTypeCollector.create().onSuccess((collector) => {
+                const existingAdds = provided !== undefined
+                    ? Array.from(provided.values()).map((existing) => collector.add(existing))
+                    : [];
+                const literalAdds = literalTypes
+                    .filter((lit) => !collector.has(lit.name))
+                    .map((lit) => collector.add(lit));
+                return mapResults([...existingAdds, ...literalAdds]).onSuccess(() => succeed(collector));
+            });
+        });
+    }
+    /**
+     * Normalizes a mixed `(string | IQualifierDecl)[]` into a fully-resolved
+     * `IQualifierDecl[]`, assigning descending default priorities to synthesized
+     * decls within the `[MinConditionPriority..MaxConditionPriority]` range.
+     *
+     * @remarks
+     * Step size is adaptive to input length:
+     * `step = max(1, floor((Max - Min) / length))`. Each synthesized priority
+     * is `max(Min, Max - index * step)` — clamped at the bottom so length
+     * extremes (\>1000 axes) degrade gracefully into a tail of equal-`Min`
+     * priorities rather than overflowing the `ConditionPriority` range.
+     *
+     * @internal
+     */
+    static _normalizeQualifierDecls(qualifiers) {
+        const range = MaxConditionPriority - MinConditionPriority;
+        const step = Math.max(1, Math.floor(range / qualifiers.length));
+        return qualifiers.map((q, index) => {
+            if (typeof q === 'string') {
+                const raw = MaxConditionPriority - index * step;
+                return {
+                    name: q,
+                    typeName: q,
+                    defaultPriority: Math.max(MinConditionPriority, raw)
+                };
+            }
+            return q;
+        });
+    }
+    /**
+     * Returns an empty {@link QualifierTypes.ReadOnlyQualifierTypeCollector | qualifier-type collector}
+     * used as a placeholder when no qualifiers are supplied and the caller omits
+     * `qualifierTypes`.
+     *
+     * @internal
+     */
+    static _emptyQualifierTypes() {
+        /* c8 ignore next 1 - QualifierTypeCollector.create() is total for the empty case */
+        return QualifierTypeCollector.create().orThrow();
     }
     /**
-     * {@inheritdoc Qualifiers.IReadOnlyQualifierCollector.getByNameOrToken}
+     * {@inheritDoc Qualifiers.IReadOnlyQualifierCollector.getByNameOrToken}
      */
     getByNameOrToken(nameOrToken) {
         return this.validating.get(nameOrToken).onFailure((message) => {
@@ -70,7 +214,7 @@ export class QualifierCollector extends ValidatingConvertingCollector {
         });
     }
     /**
-     * {@inheritdoc Qualifiers.IReadOnlyQualifierCollector.hasNameOrToken}
+     * {@inheritDoc Qualifiers.IReadOnlyQualifierCollector.hasNameOrToken}
      */
     hasNameOrToken(nameOrToken) {
         /* c8 ignore next 3 - functional code path tested but coverage intermittently missed */

package/dist/packlets/qualifiers/qualifierCollector.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"qualifierCollector.js","sourceRoot":"","sources":["../../../src/packlets/qualifiers/qualifierCollector.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2025 Erik Fortune\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\nimport * as Common from '../common';\nimport {\n  captureResult,\n  Collections,\n  Converter,\n  Converters,\n  failWithDetail,\n  mapResults,\n  Result,\n  fail,\n  succeed,\n  succeedWithDetail,\n  ValidatingConvertingCollector\n} from '@fgv/ts-utils';\nimport { IQualifierDecl, IValidatedQualifierDecl } from './qualifierDecl';\nimport { MaxConditionPriority, MinConditionPriority, QualifierName } from '../common';\nimport { Qualifier } from './qualifier';\nimport { IQualifierDeclConvertContext, qualifierDecl, validatedQualifierDecl } from './convert';\nimport {\n  LiteralQualifierType,\n  QualifierTypeCollector,\n  ReadOnlyQualifierTypeCollector\n} from '../qualifier-types';\n\n/**\n * Converter for a single entry in the mixed-shape\n * {@link Qualifiers.IQualifierCollectorCreateParams.qualifiers | qualifiers}\n * input — either a bare axis-name string or a full\n * {@link Qualifiers.IQualifierDecl | declaration}. Validates the entry\n * shape at the public-API boundary rather than deferring to the\n * internal qualifier factory.\n */\nconst _qualifierEntriesConverter: Converter<ReadonlyArray<string | IQualifierDecl>> = Converters.arrayOf(\n  Converters.oneOf<string | IQualifierDecl>([Converters.string, qualifierDecl])\n);\n\n/**\n * Readonly version of {@link Qualifiers.QualifierCollector | QualifierCollector}.\n * @public\n */\nexport interface IReadOnlyQualifierCollector extends Collections.IReadOnlyValidatingCollector<Qualifier> {\n  /**\n   * {@inheritDoc Qualifiers.QualifierCollector.qualifierTypes}\n   */\n  readonly qualifierTypes: ReadOnlyQualifierTypeCollector;\n\n  /**\n   * Gets a {@link Qualifiers.Qualifier | qualifier} by name or token.\n   * @param nameOrToken - The name or token of the qualifier to retrieve.\n   * @returns `Success` with the qualifier if found, or `Failure` if not.\n   */\n  getByNameOrToken(nameOrToken: string): Result<Qualifier>;\n\n  /**\n   * Checks if a qualifier with a given name or token is in the collection.\n   * @param nameOrToken - The name or token of the qualifier to check.\n   * @returns `true` if the qualifier is in the collection, `false` if not.\n   */\n  hasNameOrToken(nameOrToken: string): boolean;\n}\n\n/**\n * Parameters for creating a new {@link Qualifiers.QualifierCollector}.\n * @public\n *\n * @remarks\n * `qualifiers` accepts a mixed array of bare axis-name strings and full\n * {@link Qualifiers.IQualifierDecl | declarations}. A string element is\n * sugar for \"literal qualifier with this name\"; the library synthesizes a\n * {@link QualifierTypes.LiteralQualifierType | LiteralQualifierType} and a\n * declaration `{ name, typeName: name, defaultPriority: <descending> }`.\n *\n * Synthesized priorities are distributed across the\n * `[MinConditionPriority..MaxConditionPriority]` range adaptively to the\n * array length: `step = max(1, floor((Max - Min) / length))`,\n * `priority = max(Min, Max - index * step)`. Earlier elements get higher\n * priority. The formula never overflows the `ConditionPriority` range\n * regardless of input length; for inputs whose length exceeds the range\n * cardinality (\\>1000 axes), trailing priorities collapse at\n * `MinConditionPriority` — supply explicit priorities in that regime\n * if uniqueness matters.\n *\n * `qualifierTypes` may be omitted only when every element of `qualifiers`\n * is a string. If any element is an {@link Qualifiers.IQualifierDecl},\n * `qualifierTypes` must be supplied and must contain the referenced\n * {@link Qualifiers.IQualifierDecl.typeName | typeNames}.\n */\nexport interface IQualifierCollectorCreateParams {\n  /**\n   * The {@link QualifierTypes.QualifierTypeCollector | qualifier types} used to\n   * create {@link Qualifiers.Qualifier | qualifiers} from {@link Qualifiers.IQualifierDecl | declarations}.\n   *\n   * Optional only when every entry in `qualifiers` is a bare axis-name string\n   * (in which case the library synthesizes a literal qualifier type per name).\n   */\n  qualifierTypes?: ReadOnlyQualifierTypeCollector;\n\n  /**\n   * Optional list of {@link Qualifiers.IQualifierDecl | declarations} or bare\n   * axis-name strings for the qualifiers to add to the collection on creation.\n   *\n   * @remarks\n   * A string element `'foo'` is sugar for a literal qualifier:\n   * `{ name: 'foo', typeName: 'foo', defaultPriority: <descending> }` backed by\n   * a synthesized {@link QualifierTypes.LiteralQualifierType | LiteralQualifierType}\n   * named `'foo'`.\n   */\n  qualifiers?: ReadonlyArray<string | IQualifierDecl>;\n}\n\n/**\n * Collects {@link Qualifiers.Qualifier | Qualifiers} from {@link Qualifiers.IQualifierDecl | declarations},\n * with strongly-typed ({@link QualifierName | QualifierName} and {@link QualifierIndex | QualifierIndex}) key\n * and index.\n * @public\n */\nexport class QualifierCollector\n  extends ValidatingConvertingCollector<Qualifier, IQualifierDecl>\n  implements IReadOnlyQualifierCollector\n{\n  /**\n   * The {@link QualifierTypes.QualifierTypeCollector | qualifier types} that this collector uses.\n   */\n  public qualifierTypes: ReadOnlyQualifierTypeCollector;\n\n  /**\n   * Constructor for a {@link Qualifiers.QualifierCollector | QualifierCollector} object.\n   * @param qualifierTypes - The {@link QualifierTypes.ReadOnlyQualifierTypeCollector | qualifier types}\n   * used to validate declarations.\n   * @param qualifiers - Optional list of fully-resolved {@link Qualifiers.IQualifierDecl | declarations}.\n   * @public\n   */\n  protected constructor(\n    qualifierTypes: ReadOnlyQualifierTypeCollector,\n    qualifiers?: ReadonlyArray<IQualifierDecl>\n  ) {\n    super({\n      factory: (k, i, v) => this._qualifierFactory(k, i, v),\n      converters: new Collections.KeyValueConverters({\n        key: Common.Convert.qualifierName,\n        value: qualifierDecl\n      })\n    });\n    this.qualifierTypes = qualifierTypes;\n    /* c8 ignore next 1 - coverage misses the branch intermittently */\n    qualifiers?.forEach((q) => this.validating.add(q.name, q).orThrow());\n  }\n\n  /**\n   * Creates a new {@link Qualifiers.QualifierCollector | QualifierCollector} object.\n   * @param params - {@link Qualifiers.IQualifierCollectorCreateParams | Parameters} for creating a new {@link Qualifiers.QualifierCollector | QualifierCollector}.\n   * @returns `Success` with the new collector if successful, or `Failure` if not.\n   *\n   * @remarks\n   * Accepts a mixed array of bare axis-name strings and full\n   * {@link Qualifiers.IQualifierDecl | declarations}. String elements are sugar\n   * for a literal qualifier: the library synthesizes a\n   * {@link QualifierTypes.LiteralQualifierType | LiteralQualifierType} named\n   * after the string and a declaration `{ name, typeName: name, defaultPriority }`.\n   * Synthesized priorities are distributed across the\n   * `[MinConditionPriority..MaxConditionPriority]` range adaptively to the\n   * input length (`step = max(1, floor((Max - Min) / length))`,\n   * `priority = max(Min, Max - index * step)`). Earlier elements get higher\n   * priority — matching the \"earlier qualifier wins when multiple match\"\n   * mental model — and the formula never overflows the `ConditionPriority`\n   * range regardless of input length.\n   *\n   * `qualifierTypes` may be omitted only when every element of `qualifiers`\n   * is a string. If any element is a declaration, `qualifierTypes` is\n   * required (and must include the referenced typeNames); the error message\n   * names the offending typeName when it is missing.\n   */\n  public static create(params: IQualifierCollectorCreateParams): Result<QualifierCollector> {\n    return QualifierCollector._resolveCreateParams(params).onSuccess(({ qualifierTypes, qualifiers }) => {\n      return captureResult(() => new QualifierCollector(qualifierTypes, qualifiers));\n    });\n  }\n\n  /**\n   * Resolves the public {@link Qualifiers.IQualifierCollectorCreateParams | create params}\n   * into the concrete `(qualifierTypes, qualifiers)` pair the constructor expects.\n   *\n   * @remarks\n   * Validates the mixed-shape `qualifiers` input through\n   * {@link Converters.oneOf} (string vs {@link Qualifiers.IQualifierDecl})\n   * at the public-API boundary, then partitions into bare-string and decl\n   * buckets to drive type synthesis. If any decl is present and\n   * `qualifierTypes` is omitted, fails with an error that names the\n   * offending typeNames.\n   *\n   * @internal\n   */\n  private static _resolveCreateParams(params: IQualifierCollectorCreateParams): Result<{\n    qualifierTypes: ReadOnlyQualifierTypeCollector;\n    qualifiers?: ReadonlyArray<IQualifierDecl>;\n  }> {\n    const raw = params.qualifiers;\n    if (raw === undefined || raw.length === 0) {\n      if (params.qualifierTypes === undefined) {\n        return succeed({ qualifierTypes: QualifierCollector._emptyQualifierTypes(), qualifiers: undefined });\n      }\n      return succeed({ qualifierTypes: params.qualifierTypes, qualifiers: undefined });\n    }\n\n    return _qualifierEntriesConverter.convert(raw).onSuccess((entries) => {\n      const stringNames: string[] = [];\n      const declTypeNames: string[] = [];\n      for (const entry of entries) {\n        if (typeof entry === 'string') {\n          stringNames.push(entry);\n        } else {\n          declTypeNames.push(entry.typeName);\n        }\n      }\n\n      if (declTypeNames.length > 0 && params.qualifierTypes === undefined) {\n        const unique = Array.from(new Set(declTypeNames));\n        return fail<{\n          qualifierTypes: ReadOnlyQualifierTypeCollector;\n          qualifiers?: ReadonlyArray<IQualifierDecl>;\n        }>(\n          `qualifierTypes must be supplied when qualifiers include declarations; ` +\n            `missing types for: ${unique.map((n) => `'${n}'`).join(', ')}`\n        );\n      }\n\n      return QualifierCollector._resolveQualifierTypes(params.qualifierTypes, stringNames).onSuccess(\n        (qualifierTypes) => {\n          const decls = QualifierCollector._normalizeQualifierDecls(entries);\n          return succeed({ qualifierTypes, qualifiers: decls });\n        }\n      );\n    });\n  }\n\n  /**\n   * Returns the provided {@link QualifierTypes.ReadOnlyQualifierTypeCollector | qualifier-type collector}\n   * (or synthesizes a new one) augmented with synthesized literal qualifier types for the supplied\n   * string names that are not already present.\n   *\n   * @internal\n   */\n  private static _resolveQualifierTypes(\n    provided: ReadOnlyQualifierTypeCollector | undefined,\n    stringNames: ReadonlyArray<string>\n  ): Result<ReadOnlyQualifierTypeCollector> {\n    if (stringNames.length === 0) {\n      // No bare names to synthesize. The all-decls case requires `provided` to be defined\n      // (else _resolveCreateParams would have failed before calling us); fall back to an\n      // empty type collector only as a defensive measure.\n      /* c8 ignore next 1 - defensive: unreachable when called from _resolveCreateParams */\n      return succeed(provided ?? QualifierCollector._emptyQualifierTypes());\n    }\n    return mapResults(stringNames.map((name) => LiteralQualifierType.create({ name }))).onSuccess(\n      (literalTypes) => {\n        return QualifierTypeCollector.create().onSuccess((collector) => {\n          const existingAdds: ReadonlyArray<Result<unknown>> =\n            provided !== undefined\n              ? Array.from(provided.values()).map((existing) => collector.add(existing))\n              : [];\n          const literalAdds: ReadonlyArray<Result<unknown>> = literalTypes\n            .filter((lit) => !collector.has(lit.name))\n            .map((lit) => collector.add(lit));\n          return mapResults([...existingAdds, ...literalAdds]).onSuccess(() =>\n            succeed(collector as ReadOnlyQualifierTypeCollector)\n          );\n        });\n      }\n    );\n  }\n\n  /**\n   * Normalizes a mixed `(string | IQualifierDecl)[]` into a fully-resolved\n   * `IQualifierDecl[]`, assigning descending default priorities to synthesized\n   * decls within the `[MinConditionPriority..MaxConditionPriority]` range.\n   *\n   * @remarks\n   * Step size is adaptive to input length:\n   * `step = max(1, floor((Max - Min) / length))`. Each synthesized priority\n   * is `max(Min, Max - index * step)` — clamped at the bottom so length\n   * extremes (\\>1000 axes) degrade gracefully into a tail of equal-`Min`\n   * priorities rather than overflowing the `ConditionPriority` range.\n   *\n   * @internal\n   */\n  private static _normalizeQualifierDecls(\n    qualifiers: ReadonlyArray<string | IQualifierDecl>\n  ): ReadonlyArray<IQualifierDecl> {\n    const range = MaxConditionPriority - MinConditionPriority;\n    const step = Math.max(1, Math.floor(range / qualifiers.length));\n    return qualifiers.map((q, index) => {\n      if (typeof q === 'string') {\n        const raw = MaxConditionPriority - index * step;\n        return {\n          name: q,\n          typeName: q,\n          defaultPriority: Math.max(MinConditionPriority, raw)\n        };\n      }\n      return q;\n    });\n  }\n\n  /**\n   * Returns an empty {@link QualifierTypes.ReadOnlyQualifierTypeCollector | qualifier-type collector}\n   * used as a placeholder when no qualifiers are supplied and the caller omits\n   * `qualifierTypes`.\n   *\n   * @internal\n   */\n  private static _emptyQualifierTypes(): ReadOnlyQualifierTypeCollector {\n    /* c8 ignore next 1 - QualifierTypeCollector.create() is total for the empty case */\n    return QualifierTypeCollector.create().orThrow();\n  }\n\n  /**\n   * {@inheritDoc Qualifiers.IReadOnlyQualifierCollector.getByNameOrToken}\n   */\n  public getByNameOrToken(nameOrToken: string): Result<Qualifier> {\n    return this.validating.get(nameOrToken).onFailure((message) => {\n      for (const q of this.values()) {\n        if (q.token === nameOrToken) {\n          return succeedWithDetail(q, 'success');\n        }\n      }\n      return failWithDetail(`Qualifier token '${nameOrToken}' not found`, 'not-found');\n    });\n  }\n\n  /**\n   * {@inheritDoc Qualifiers.IReadOnlyQualifierCollector.hasNameOrToken}\n   */\n  public hasNameOrToken(nameOrToken: string): boolean {\n    /* c8 ignore next 3 - functional code path tested but coverage intermittently missed */\n    if (this.validating.has(nameOrToken)) {\n      return true;\n    }\n    for (const q of this.values()) {\n      /* c8 ignore next 3 - functional code path tested but coverage intermittently missed */\n      if (q.token === nameOrToken) {\n        return true;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Gets a read-only view of this collector.\n   * @returns A read-only view of this collector.\n   */\n  public toReadOnly(): IReadOnlyQualifierCollector {\n    return this;\n  }\n\n  /**\n   * Factory method for creating a {@link Qualifiers.Qualifier | Qualifier} from a {@link Qualifiers.IQualifierDecl | declaration}.\n   * @param __key - The key for the qualifier.\n   * @param index - The index of the qualifier.\n   * @param decl - The {@link Qualifiers.IQualifierDecl | declaration} for the qualifier.\n   * @returns `Success` with the new {@link Qualifiers.Qualifier | Qualifier} if successful, or `Failure` if not.\n   * @public\n   */\n  protected _qualifierFactory(__key: QualifierName, index: number, decl: IQualifierDecl): Result<Qualifier> {\n    const convertContext: IQualifierDeclConvertContext = {\n      qualifierTypes: this.qualifierTypes,\n      qualifierIndex: index\n    };\n    return validatedQualifierDecl\n      .convert(decl, convertContext)\n      .onSuccess((validated) => {\n        /* c8 ignore next 9 - coverage intermittently misses this block */\n        if (this.hasNameOrToken(validated.token)) {\n          return fail<IValidatedQualifierDecl>(\n            `Qualifier token '${validated.token}' is not unique or collides with name`\n          );\n        } else if (this.hasNameOrToken(validated.name)) {\n          return fail<IValidatedQualifierDecl>(\n            `Qualifier name '${validated.name}' is not unique or collides with token`\n          );\n        }\n        return succeed(validated);\n      })\n      .onSuccess(Qualifier.create);\n  }\n}\n"]}

package/dist/packlets/qualifiers/qualifierDecl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"qualifierDecl.js","sourceRoot":"","sources":["../../../src/packlets/qualifiers/qualifierDecl.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG","sourcesContent":["/*\n * Copyright (c) 2025 Erik Fortune\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\nimport { ConditionPriority, QualifierContextValue, QualifierIndex, QualifierName } from '../common';\nimport { QualifierType } from '../qualifier-types';\n\n/**\n * Simple declaration for a {@link Qualifiers.Qualifier | Qualifier}.\n * @public\n */\nexport interface IQualifierDecl {\n  name: string;\n  typeName: string;\n  defaultPriority: number;\n  token?: string;\n  tokenIsOptional?: boolean;\n  defaultValue?: string;\n}\n\n/**\n * Validated declaration for a {@link Qualifiers.Qualifier | Qualifier}.\n * @public\n */\nexport interface IValidatedQualifierDecl {\n  /**\n   * The name of the qualifier.\n   */\n  name: QualifierName;\n\n  /**\n   * The token used to identify the qualifier in the name or\n   * path of a resource being imported.\n   */\n  token: QualifierName;\n\n  /**\n   * The {@link QualifierTypes.QualifierType | type} of the qualifier.\n   */\n  type: QualifierType;\n\n  /**\n   * The default {@link ConditionPriority | priority} of conditions\n   * that depend on this qualifier.\n   */\n  defaultPriority: ConditionPriority;\n\n  /**\n   * Indicates whether the token is optional when parsing a resource token.\n   */\n  tokenIsOptional: boolean;\n\n  /**\n   * Optional default value for the qualifier.\n   */\n  defaultValue?: QualifierContextValue;\n\n  /**\n   * Index of the qualifier.\n   */\n  index: QualifierIndex | undefined;\n}\n"]}

package/dist/packlets/qualifiers/qualifierDefaultValueDecls.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"qualifierDefaultValueDecls.js","sourceRoot":"","sources":["../../../src/packlets/qualifiers/qualifierDefaultValueDecls.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG","sourcesContent":["/*\n * Copyright (c) 2025 Erik Fortune\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\nimport { QualifierContextValue, QualifierName } from '../common';\nimport { Qualifier } from './qualifier';\n\n/**\n * Non-validated declaration of a single qualifier default value.\n * @public\n */\nexport interface IQualifierDefaultValueDecl {\n  qualifier: string;\n  value: string;\n}\n\n/**\n * Non-validated declaration of qualifier default values, consisting of named\n * default values.\n * @public\n */\nexport type IQualifierDefaultValuesDecl = Record<string, string>;\n\n/**\n * Validated declaration of a single qualifier default value.\n * @public\n */\nexport interface IValidatedQualifierDefaultValueDecl {\n  qualifier: Qualifier;\n  value: QualifierContextValue;\n}\n\n/**\n * Validated declaration of qualifier default values, a record with strongly-typed\n * {@link QualifierName | qualifier names} as keys and\n * {@link QualifierContextValue | qualifier context values} as values.\n * @public\n */\nexport type IValidatedQualifierDefaultValuesDecl = Record<QualifierName, QualifierContextValue>;\n"]}

package/dist/packlets/qualifiers/qualifierDefaultValueToken.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"qualifierDefaultValueToken.js","sourceRoot":"","sources":["../../../src/packlets/qualifiers/qualifierDefaultValueToken.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2025 Erik Fortune\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\nimport { mapResults, Result, fail, succeed } from '@fgv/ts-utils';\nimport { Helpers as CommonHelpers, QualifierName, QualifierContextValue } from '../common';\nimport {\n  IValidatedQualifierDefaultValueDecl,\n  IValidatedQualifierDefaultValuesDecl\n} from './qualifierDefaultValueDecls';\nimport { IReadOnlyQualifierCollector } from './qualifierCollector';\n\n/**\n * Helper class to parse and validate qualifier default value tokens.\n * @public\n */\nexport class QualifierDefaultValueTokens {\n  /**\n   * The {@link Qualifiers.IReadOnlyQualifierCollector | qualifier collector} used to validate\n   * qualifier names and values.\n   */\n  public readonly qualifiers: IReadOnlyQualifierCollector;\n\n  /**\n   * Constructs a new {@link Qualifiers.QualifierDefaultValueTokens | QualifierDefaultValueTokens } instance.\n   * @param qualifiers - the {@link Qualifiers.IReadOnlyQualifierCollector | qualifier collector} to use\n   */\n  public constructor(qualifiers: IReadOnlyQualifierCollector) {\n    this.qualifiers = qualifiers;\n  }\n\n  /**\n   * Parses a {@link QualifierDefaultValueToken | qualifier default value token} string and validates the parts\n   * against the qualifiers present in the {@link Qualifiers.QualifierDefaultValueTokens.qualifiers | qualifier collector}.\n   * @param token - the token string to parse.\n   * @returns `Success` with the {@link Qualifiers.IValidatedQualifierDefaultValueDecl | validated qualifier default value declaration}\n   * if successful, `Failure` with an error message if not.\n   */\n  public parseQualifierDefaultValueToken(token: string): Result<IValidatedQualifierDefaultValueDecl> {\n    return QualifierDefaultValueTokens.parseQualifierDefaultValueToken(token, this.qualifiers);\n  }\n\n  /**\n   * Parses a {@link QualifierDefaultValuesToken | qualifier default values token} string and validates the parts\n   * against the qualifiers present in the {@link Qualifiers.QualifierDefaultValueTokens.qualifiers | qualifier collector}.\n   * @param token - the token string to parse.\n   * @returns `Success` with the array of {@link Qualifiers.IValidatedQualifierDefaultValueDecl | validated qualifier default value declarations}\n   * if successful, `Failure` with an error message if not.\n   */\n  public parseQualifierDefaultValuesToken(token: string): Result<IValidatedQualifierDefaultValueDecl[]> {\n    return QualifierDefaultValueTokens.parseQualifierDefaultValuesToken(token, this.qualifiers);\n  }\n\n  /**\n   * Validates the {@link Helpers.IQualifierDefaultValueTokenParts | parts} of a {@link QualifierDefaultValueToken | qualifier default value token}.\n   * @param parts - the parts to validate\n   * @returns `Success` with the validated declaration if successful, `Failure` with an error message if not.\n   */\n  public validateQualifierDefaultValueTokenParts(\n    parts: CommonHelpers.IQualifierDefaultValueTokenParts\n  ): Result<IValidatedQualifierDefaultValueDecl> {\n    return QualifierDefaultValueTokens.validateQualifierDefaultValueTokenParts(parts, this.qualifiers);\n  }\n\n  /**\n   * Converts a {@link QualifierDefaultValuesToken | qualifier default values token} to a validated qualifier default values declaration.\n   * @param token - the qualifier default values token to convert\n   * @returns `Success` with the validated qualifier default values declaration if successful, `Failure` with an error message if not.\n   */\n  public qualifierDefaultValuesTokenToDecl(token: string): Result<IValidatedQualifierDefaultValuesDecl> {\n    return QualifierDefaultValueTokens.qualifierDefaultValuesTokenToDecl(token, this.qualifiers);\n  }\n\n  /**\n   * Converts a validated qualifier default values declaration to a {@link QualifierDefaultValuesToken | qualifier default values token}.\n   * @param decl - the validated qualifier default values declaration to convert\n   * @returns `Success` with the qualifier default values token if successful, `Failure` with an error message if not.\n   */\n  public declToQualifierDefaultValuesToken(decl: IValidatedQualifierDefaultValuesDecl): Result<string> {\n    return QualifierDefaultValueTokens.declToQualifierDefaultValuesToken(decl);\n  }\n\n  /**\n   * Parses a {@link QualifierDefaultValueToken | qualifier default value token} and validates it against the qualifiers\n   * present in the supplied {@link Qualifiers.IReadOnlyQualifierCollector | qualifier collector}.\n   * @param token - the token string to parse.\n   * @param qualifiers - the {@link Qualifiers.IReadOnlyQualifierCollector | qualifier collector} to use\n   * @returns `Success` with a {@link Qualifiers.IValidatedQualifierDefaultValueDecl | validated qualifier default value declaration} if successful,\n   * `Failure` with an error message if not.\n   */\n  public static parseQualifierDefaultValueToken(\n    token: string,\n    qualifiers: IReadOnlyQualifierCollector\n  ): Result<IValidatedQualifierDefaultValueDecl> {\n    return CommonHelpers.parseQualifierDefaultValueTokenParts(token).onSuccess((parts) => {\n      return QualifierDefaultValueTokens.validateQualifierDefaultValueTokenParts(parts, qualifiers);\n    });\n  }\n\n  /**\n   * Parses a {@link QualifierDefaultValuesToken | qualifier default values token} and validates it against the qualifiers\n   * present in the supplied {@link Qualifiers.IReadOnlyQualifierCollector | qualifier collector}.\n   * @param token - the token string to parse.\n   * @param qualifiers - the {@link Qualifiers.IReadOnlyQualifierCollector | qualifier collector} to use\n   * @returns `Success` with an array of {@link Qualifiers.IValidatedQualifierDefaultValueDecl | validated qualifier default value declarations}\n   * if successful, `Failure` with an error message if not\n   */\n  public static parseQualifierDefaultValuesToken(\n    token: string,\n    qualifiers: IReadOnlyQualifierCollector\n  ): Result<IValidatedQualifierDefaultValueDecl[]> {\n    return CommonHelpers.parseQualifierDefaultValuesTokenParts(token).onSuccess((parts) => {\n      return mapResults(\n        parts.map((part) =>\n          QualifierDefaultValueTokens.validateQualifierDefaultValueTokenParts(part, qualifiers)\n        )\n      );\n    });\n  }\n\n  /**\n   * Validates the parts of a qualifier default value token against the qualifiers present in the supplied\n   * {@link Qualifiers.IReadOnlyQualifierCollector | qualifier collector}.\n   * @param parts - the {@link Helpers.IQualifierDefaultValueTokenParts | qualifier default value token parts} to validate.\n   * @param qualifiers - the {@link Qualifiers.IReadOnlyQualifierCollector | qualifier collector} used to\n   * validate qualifier names and values.\n   * @returns `Success` with a {@link Qualifiers.IValidatedQualifierDefaultValueDecl | validated qualifier default value declaration} if successful,\n   * `Failure` with an error message if not.\n   */\n  public static validateQualifierDefaultValueTokenParts(\n    parts: CommonHelpers.IQualifierDefaultValueTokenParts,\n    qualifiers: IReadOnlyQualifierCollector\n  ): Result<IValidatedQualifierDefaultValueDecl> {\n    return qualifiers.getByNameOrToken(parts.qualifier).onSuccess((qualifier) => {\n      // Allow empty values to remove defaults\n      if (parts.value === '') {\n        return succeed({ qualifier, value: '' as QualifierContextValue });\n      }\n\n      return qualifier.type\n        .validateContextValue(parts.value)\n        .onSuccess((value) => {\n          return succeed({ qualifier, value });\n        })\n        .withDetail('failure', 'success');\n    });\n  }\n\n  /**\n   * Converts a {@link QualifierDefaultValuesToken | qualifier default values token} to a validated qualifier default values declaration.\n   * @param token - the qualifier default values token to convert\n   * @param qualifiers - the {@link Qualifiers.IReadOnlyQualifierCollector | qualifier collector} to use\n   * @returns `Success` with the validated qualifier default values declaration if successful, `Failure` with an error message if not.\n   */\n  public static qualifierDefaultValuesTokenToDecl(\n    token: string,\n    qualifiers: IReadOnlyQualifierCollector\n  ): Result<IValidatedQualifierDefaultValuesDecl> {\n    return QualifierDefaultValueTokens.parseQualifierDefaultValuesToken(token, qualifiers).onSuccess(\n      (qualifierDefaultValues) => {\n        const defaultValues: IValidatedQualifierDefaultValuesDecl = {};\n\n        for (const { qualifier, value } of qualifierDefaultValues) {\n          const qualifierName = qualifier.name as QualifierName;\n          const contextValue = value as QualifierContextValue;\n\n          // Check for duplicate qualifiers\n          if (qualifierName in defaultValues) {\n            return fail(`${qualifier.name}: duplicate qualifier in default values token`);\n          }\n\n          // Only add non-empty values (empty values remove defaults)\n          if (contextValue !== '') {\n            defaultValues[qualifierName] = contextValue;\n          }\n        }\n\n        return succeed(defaultValues);\n      }\n    );\n  }\n\n  /**\n   * Converts a validated qualifier default values declaration to a {@link QualifierDefaultValuesToken | qualifier default values token}.\n   * @param decl - the validated qualifier default values declaration to convert\n   * @returns `Success` with the qualifier default values token if successful, `Failure` with an error message if not.\n   */\n  public static declToQualifierDefaultValuesToken(\n    decl: IValidatedQualifierDefaultValuesDecl\n  ): Result<string> {\n    const tokens: string[] = [];\n\n    for (const [qualifierName, contextValue] of Object.entries(decl)) {\n      // Build token as \"qualifier=value\"\n      tokens.push(`${qualifierName}=${contextValue}`);\n    }\n\n    if (tokens.length === 0) {\n      return succeed('');\n    }\n\n    const tokenString = tokens.join('|');\n\n    // Validate the generated token\n    return CommonHelpers.buildQualifierDefaultValuesToken(\n      tokens.map((token) => {\n        const [qualifier, value] = token.split('=');\n        return { qualifier, value };\n      })\n    ).onSuccess(() => succeed(tokenString));\n  }\n}\n"]}

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

@@ -0,0 +1 @@
+{"version":3,"file":"common.js","sourceRoot":"","sources":["../../../../src/packlets/resource-json/compiled/common.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG","sourcesContent":["/*\n * Copyright (c) 2025 Erik Fortune\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\n/**\n * Options for controlling the compilation of resource objects.\n * @public\n */\nexport interface ICompiledResourceOptions {\n  /**\n   * Whether to include metadata in the compiled objects.\n   * Metadata includes human-readable information like semantic keys\n   * that can be useful for debugging or tooling.\n   * @defaultValue false\n   */\n  includeMetadata?: boolean;\n}\n"]}

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

@@ -0,0 +1 @@
+{"version":3,"file":"convert.js","sourceRoot":"","sources":["../../../../src/packlets/resource-json/compiled/convert.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2025 Erik Fortune\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\nimport * as Common from '../../common';\nimport { Converters } from '@fgv/ts-utils';\nimport { Converters as JsonConverters } from '@fgv/ts-json-base';\nimport * as Model from './json';\n\n/* eslint-disable @rushstack/typedef-var */\n\n/**\n * Converter for a {@link ResourceJson.Compiled.ICompiledConditionMetadata | compiled condition metadata}.\n * @public\n */\nexport const compiledConditionMetadata = Converters.strictObject<Model.ICompiledConditionMetadata>({\n  key: Common.Convert.conditionKey\n});\n\n/**\n * Converter for a {@link ResourceJson.Compiled.ICompiledConditionSetMetadata | compiled condition set metadata}.\n * @public\n */\nexport const compiledConditionSetMetadata = Converters.strictObject<Model.ICompiledConditionSetMetadata>({\n  key: Common.Convert.conditionSetKey\n});\n\n/**\n * Converter for a {@link ResourceJson.Compiled.ICompiledDecisionMetadata | compiled decision metadata}.\n * @public\n */\nexport const compiledDecisionMetadata = Converters.strictObject<Model.ICompiledDecisionMetadata>({\n  key: Common.Convert.decisionKey\n});\n\n/**\n * Converter for a {@link ResourceJson.Compiled.ICompiledQualifierType | compiled qualifier type}.\n * @public\n */\nexport const compiledQualifierType = Converters.strictObject<Model.ICompiledQualifierType>({\n  name: Common.Convert.qualifierTypeName\n});\n\n/**\n * Converter for a {@link ResourceJson.Compiled.ICompiledQualifier | compiled qualifier}.\n * @public\n */\nexport const compiledQualifier = Converters.strictObject<Model.ICompiledQualifier>({\n  name: Common.Convert.qualifierName,\n  type: Common.Convert.qualifierTypeIndex,\n  defaultPriority: Common.Convert.conditionPriority\n});\n\n/**\n * Converter for a {@link ResourceJson.Compiled.ICompiledResourceType | compiled resource type}.\n * @public\n */\nexport const compiledResourceType = Converters.strictObject<Model.ICompiledResourceType>({\n  name: Common.Convert.resourceTypeName\n});\n\n/**\n * Converter for a {@link ResourceJson.Compiled.ICompiledCondition | compiled condition}.\n * @public\n */\nexport const compiledCondition = Converters.strictObject<Model.ICompiledCondition>({\n  qualifierIndex: Common.Convert.qualifierIndex,\n  operator: Common.Convert.conditionOperator.optional(),\n  value: Converters.string,\n  priority: Common.Convert.conditionPriority,\n  scoreAsDefault: Common.Convert.qualifierMatchScore.optional(),\n  metadata: compiledConditionMetadata.optional()\n});\n\n/**\n * Converter for a {@link ResourceJson.Compiled.ICompiledConditionSet | compiled condition set}.\n * @public\n */\nexport const compiledConditionSet = Converters.strictObject<Model.ICompiledConditionSet>({\n  conditions: Converters.arrayOf(Common.Convert.conditionIndex),\n  metadata: compiledConditionSetMetadata.optional()\n});\n/**\n * Converter for a {@link ResourceJson.Compiled.ICompiledAbstractDecision | compiled abstract decision}.\n * @public\n */\nexport const compiledAbstractDecision = Converters.strictObject<Model.ICompiledAbstractDecision>({\n  conditionSets: Converters.arrayOf(Common.Convert.conditionSetIndex),\n  metadata: compiledDecisionMetadata.optional()\n});\n\n/**\n * Converter for a {@link ResourceJson.Compiled.ICompiledCandidate | compiled candidate}.\n * @public\n */\nexport const compiledCandidate = Converters.strictObject<Model.ICompiledCandidate>({\n  valueIndex: Common.Convert.candidateValueIndex,\n  isPartial: Converters.boolean,\n  mergeMethod: Common.Convert.resourceValueMergeMethod\n});\n\n/**\n * Converter for a {@link ResourceJson.Compiled.ICompiledResource | compiled resource}.\n * @public\n */\nexport const compiledResource = Converters.strictObject<Model.ICompiledResource>({\n  id: Common.Convert.resourceId,\n  type: Common.Convert.resourceTypeIndex,\n  decision: Common.Convert.decisionIndex,\n  candidates: Converters.arrayOf(compiledCandidate)\n});\n\n/**\n * Converter for a {@link ResourceJson.Compiled.ICompiledResourceCollection | compiled resource collection}.\n * This combines all the individual converters into a single converter for the entire resource collection.\n * @public\n */\nexport const compiledResourceCollection = Converters.strictObject<Model.ICompiledResourceCollection>({\n  qualifiers: Converters.arrayOf(compiledQualifier),\n  qualifierTypes: Converters.arrayOf(compiledQualifierType),\n  resourceTypes: Converters.arrayOf(compiledResourceType),\n  conditions: Converters.arrayOf(compiledCondition),\n  conditionSets: Converters.arrayOf(compiledConditionSet),\n  decisions: Converters.arrayOf(compiledAbstractDecision),\n  candidateValues: Converters.arrayOf(JsonConverters.jsonValue),\n  resources: Converters.arrayOf(compiledResource)\n});\n"]}

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/packlets/resource-json/compiled/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,OAAO,MAAM,WAAW,CAAC;AAErC,cAAc,UAAU,CAAC;AACzB,cAAc,QAAQ,CAAC;AACvB,OAAO,EAAE,OAAO,EAAE,CAAC","sourcesContent":["/*\n * Copyright (c) 2025 Erik Fortune\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\n\nimport * as Convert from './convert';\n\nexport * from './common';\nexport * from './json';\nexport { Convert };\n"]}

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

@@ -0,0 +1 @@
+{"version":3,"file":"json.js","sourceRoot":"","sources":["../../../../src/packlets/resource-json/compiled/json.ts"],"names":[],"mappings":"","sourcesContent":["/*\n * Copyright (c) 2025 Erik Fortune\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to deal\n * in the Software without restriction, including without limitation the rights\n * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n * copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in all\n * copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n * SOFTWARE.\n */\nimport * as Common from '../../common';\nimport { JsonValue } from '@fgv/ts-json-base';\n\n/**\n * Metadata for a compiled condition, containing human-readable information.\n * @public\n */\nexport interface ICompiledConditionMetadata {\n  /**\n   * The semantic key of the condition (e.g., \"language=en-US\").\n   */\n  key: Common.ConditionKey;\n}\n\n/**\n * Metadata for a compiled condition set, containing human-readable information.\n * @public\n */\nexport interface ICompiledConditionSetMetadata {\n  /**\n   * The semantic key of the condition set (e.g., \"language=en-US,territory=US\").\n   */\n  key: Common.ConditionSetKey;\n}\n\n/**\n * Metadata for a compiled decision, containing human-readable information.\n * @public\n */\nexport interface ICompiledDecisionMetadata {\n  /**\n   * The semantic key of the decision (e.g., \"language=en-US,territory=US OR language=fr,territory=CA\").\n   */\n  key: Common.DecisionKey;\n}\n\n/**\n * Represents a compiled qualifier type with a name.\n * @public\n */\nexport interface ICompiledQualifierType {\n  /**\n   * The name of the qualifier type.\n   */\n  name: Common.QualifierTypeName;\n}\n\n/**\n * Represents a compiled qualifier with a name and type reference.\n * @public\n */\nexport interface ICompiledQualifier {\n  /**\n   * The name of the qualifier.\n   */\n  name: Common.QualifierName;\n  /**\n   * Index reference to the qualifier type.\n   */\n  type: Common.QualifierTypeIndex;\n\n  /**\n   * The token used to identify the qualifier in resource names or paths.\n   */\n  defaultPriority: Common.ConditionPriority;\n}\n\n/**\n * Represents a compiled resource type with a name.\n * @public\n */\nexport interface ICompiledResourceType {\n  /**\n   * The name of the resource type.\n   */\n  name: Common.ResourceTypeName;\n}\n\n/**\n * Represents a compiled condition used for resource selection.\n * @public\n */\nexport interface ICompiledCondition {\n  /**\n   * Index reference to the qualifier being evaluated.\n   */\n  qualifierIndex: Common.QualifierIndex;\n  /**\n   * Optional operator to apply in the condition evaluation.\n   */\n  operator?: Common.ConditionOperator;\n  /**\n   * The value to compare against when evaluating the condition.\n   */\n  value: string;\n  /**\n   * The priority of the condition when multiple conditions match.\n   */\n  priority: Common.ConditionPriority;\n  /**\n   * Optional score to use when treating this condition as a default.\n   */\n  scoreAsDefault?: Common.QualifierMatchScore;\n  /**\n   * Optional metadata containing human-readable information about this condition.\n   */\n  metadata?: ICompiledConditionMetadata;\n}\n\n/**\n * Represents a compiled set of conditions that must be satisfied together.\n * @public\n */\nexport interface ICompiledConditionSet {\n  /**\n   * Array of indices referencing the conditions in this set.\n   */\n  conditions: ReadonlyArray<Common.ConditionIndex>;\n  /**\n   * Optional metadata containing human-readable information about this condition set.\n   */\n  metadata?: ICompiledConditionSetMetadata;\n}\n\n/**\n * Represents a compiled abstract decision with condition sets.\n * @public\n */\nexport interface ICompiledAbstractDecision {\n  /**\n   * Array of indices referencing the condition sets for this decision.\n   */\n  conditionSets: ReadonlyArray<Common.ConditionSetIndex>;\n  /**\n   * Optional metadata containing human-readable information about this decision.\n   */\n  metadata?: ICompiledDecisionMetadata;\n}\n\n/**\n * Represents a compiled resource candidate with JSON value and merge properties.\n * @public\n */\nexport interface ICompiledCandidate {\n  /**\n   * The global index of the JSON value of the candidate.\n   */\n  valueIndex: Common.CandidateValueIndex;\n  /**\n   * Indicates if this is a partial resource that needs to be merged.\n   */\n  isPartial: boolean;\n  /**\n   * The method to use when merging this candidate with others.\n   */\n  mergeMethod: Common.ResourceValueMergeMethod;\n}\n\n/**\n * Represents a compiled resource with an identifier and associated candidates.\n * @public\n */\nexport interface ICompiledResource {\n  /**\n   * The unique identifier of the resource.\n   */\n  id: Common.ResourceId;\n\n  /**\n   * Index reference to the resource type of this resource.\n   */\n  type: Common.ResourceTypeIndex;\n\n  /**\n   * Index reference to the decision that determines when this resource applies.\n   */\n  decision: Common.DecisionIndex;\n  /**\n   * Array of candidate values for this resource.\n   */\n  candidates: ReadonlyArray<ICompiledCandidate>;\n}\n\n/**\n * Represents a complete compiled collection of resources with their associated\n * qualifiers, types, conditions, and decisions.\n * @public\n */\nexport interface ICompiledResourceCollection {\n  /**\n   * Array of all qualifier types in the collection.\n   */\n  qualifierTypes: ReadonlyArray<ICompiledQualifierType>;\n  /**\n   * Array of all qualifiers in the collection.\n   */\n  qualifiers: ReadonlyArray<ICompiledQualifier>;\n  /**\n   * Array of all resource types in the collection.\n   */\n  resourceTypes: ReadonlyArray<ICompiledResourceType>;\n  /**\n   * Array of all conditions in the collection.\n   */\n  conditions: ReadonlyArray<ICompiledCondition>;\n  /**\n   * Array of all condition sets in the collection.\n   */\n  conditionSets: ReadonlyArray<ICompiledConditionSet>;\n  /**\n   * Array of all decisions in the collection.\n   */\n  decisions: ReadonlyArray<ICompiledAbstractDecision>;\n  /**\n   * Array of all candidate values in the collection.\n   */\n  candidateValues: ReadonlyArray<JsonValue>;\n  /**\n   * Array of all resources in the collection.\n   */\n  resources: ReadonlyArray<ICompiledResource>;\n}\n"]}