@fgv/ts-res 5.0.0-9 → 5.0.1-0

package/lib/packlets/resources/resourceManagerBuilder.js

@@ -56,14 +56,18 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ResourceManagerBuilder = void 0;
 const ts_utils_1 = require("@fgv/ts-utils");
+const ts_json_base_1 = require("@fgv/ts-json-base");
 const conditions_1 = require("../conditions");
 const decisions_1 = require("../decisions");
 const common_1 = require("../common");
+const runtime_1 = require("../runtime");
 const resourceBuilder_1 = require("./resourceBuilder");
 const resource_1 = require("./resource");
+const candidateValueCollector_1 = require("./candidateValueCollector");
 const ResourceJson = __importStar(require("../resource-json"));
 const Context = __importStar(require("../context"));
 const Config = __importStar(require("../config"));
+const ts_json_1 = require("@fgv/ts-json");
 /**
  * Builder for a collection of {@link Resources.Resource | resources}. Collects
  * {@link Resources.ResourceCandidate | candidates} for each resource into a
@@ -72,6 +76,13 @@ const Config = __importStar(require("../config"));
  * @public
  */
 class ResourceManagerBuilder {
+    /**
+     * The {@link QualifierTypes.ReadOnlyQualifierTypeCollector | qualifier types} used by this resource manager.
+     */
+    get qualifierTypes() {
+        /* c8 ignore next 1 - functional code tested but coverage intermittently missed */
+        return this.qualifiers.qualifierTypes;
+    }
     /**
      * A {@link Conditions.ConditionCollector | ConditionCollector} which
      * contains the {@link Conditions.Condition | conditions} used so far by
@@ -140,6 +151,7 @@ class ResourceManagerBuilder {
         this._conditions = conditions_1.ConditionCollector.create({ qualifiers: params.qualifiers }).orThrow();
         this._conditionSets = conditions_1.ConditionSetCollector.create({ conditions: this._conditions }).orThrow();
         this._decisions = decisions_1.AbstractDecisionCollector.create({ conditionSets: this._conditionSets }).orThrow();
+        this._candidateValues = candidateValueCollector_1.CandidateValueCollector.create().orThrow();
         this._resources = new ts_utils_1.ValidatingResultMap({
             converters: new ts_utils_1.Collections.KeyValueConverters({
                 key: common_1.Convert.resourceId,
@@ -155,6 +167,7 @@ class ResourceManagerBuilder {
             })
         });
         this._built = false;
+        this._cachedResourceTree = undefined;
     }
     /**
      * Creates a new {@link Resources.ResourceManagerBuilder | ResourceManagerBuilder} object.
@@ -175,13 +188,39 @@ class ResourceManagerBuilder {
      * @public
      */
     static createPredefined(name, qualifierDefaultValues) {
-        return Config.getPredefinedSystemConfiguration(name, qualifierDefaultValues ? { qualifierDefaultValues } : undefined).onSuccess((systemConfig) => {
+        return Config.getPredefinedSystemConfiguration(name, 
+        /* c8 ignore next 1 - defense in depth */
+        qualifierDefaultValues ? { qualifierDefaultValues } : undefined).onSuccess((systemConfig) => {
             return ResourceManagerBuilder.create({
                 qualifiers: systemConfig.qualifiers,
                 resourceTypes: systemConfig.resourceTypes
             });
         });
     }
+    /**
+     * Creates a new {@link Resources.ResourceManagerBuilder | ResourceManagerBuilder} from a
+     * {@link ResourceJson.Compiled.ICompiledResourceCollection | compiled resource collection}.
+     * This method reconstructs an exactly equivalent builder where all qualifier, condition,
+     * condition set, and decision indices match the original compiled collection.
+     * @param compiledCollection - The compiled resource collection to reconstruct from.
+     * @param systemConfig - The system configuration containing qualifiers and resource types.
+     * @returns `Success` with the new manager if successful, or `Failure` with an error message if not.
+     * @public
+     */
+    static createFromCompiledResourceCollection(compiledCollection, systemConfig) {
+        // Create the base builder with system configuration
+        return ResourceManagerBuilder.create({
+            qualifiers: systemConfig.qualifiers,
+            resourceTypes: systemConfig.resourceTypes
+        }).onSuccess((builder) => {
+            // Reconstruct all entities in order to preserve indices
+            return ResourceManagerBuilder._reconstructConditions(builder, compiledCollection)
+                .onSuccess(() => ResourceManagerBuilder._reconstructConditionSets(builder, compiledCollection))
+                .onSuccess(() => ResourceManagerBuilder._reconstructDecisions(builder, compiledCollection))
+                .onSuccess(() => ResourceManagerBuilder._reconstructResources(builder, compiledCollection))
+                .onSuccess(() => (0, ts_utils_1.succeed)(builder));
+        });
+    }
     /**
      * Given a {@link ResourceJson.Json.ILooseResourceCandidateDecl | resource candidate declaration}, builds and adds
      * a {@link Resources.ResourceCandidate | candidate} to the manager.
@@ -198,7 +237,8 @@ class ResourceManagerBuilder {
             id,
             resourceTypes: this.resourceTypes,
             conditionSets: this._conditionSets,
-            decisions: this._decisions
+            decisions: this._decisions,
+            candidateValues: this._candidateValues
         }));
         /* c8 ignore next 6 - defense in depth against internal error */
         if (builderResult.isFailure()) {
@@ -208,12 +248,14 @@ class ResourceManagerBuilder {
             this._builtResources.delete(id);
             this._built = false;
             this._numCandidates = undefined;
+            this._cachedResourceTree = undefined;
             return (0, ts_utils_1.succeedWithDetail)(c, d);
         });
     }
     addResource(decl) {
         var _a;
         const { value: id, message } = common_1.Validate.toResourceId(decl.id);
+        /* c8 ignore next 3 - defensive coding: resource ID validation should prevent invalid IDs */
         if (message !== undefined) {
             return (0, ts_utils_1.failWithDetail)(`${id}: invalid id - ${message}`, 'failure');
         }
@@ -222,13 +264,15 @@ class ResourceManagerBuilder {
             typeName: decl.resourceTypeName,
             resourceTypes: this.resourceTypes,
             conditionSets: this._conditionSets,
-            decisions: this._decisions
+            decisions: this._decisions,
+            candidateValues: this._candidateValues
         }));
         /* c8 ignore next 3 - defense in depth against internal error */
         if (getOrAddMessage !== undefined) {
             return (0, ts_utils_1.failWithDetail)(`${id}: unable to get or add resource\n${getOrAddMessage}`, detail);
         }
         if (detail === 'exists') {
+            /* c8 ignore next 4 - defensive coding: resource type mismatch on existing resources should not occur */
             const { message } = builder.setResourceType(decl.resourceTypeName);
             if (message !== undefined) {
                 return (0, ts_utils_1.failWithDetail)(`${id}: unable to set resource type\n${message}`, 'type-mismatch');
@@ -317,6 +361,36 @@ class ResourceManagerBuilder {
     getAllBuiltResources() {
         return this.build().onSuccess((manager) => (0, ts_utils_1.succeed)(Array.from(manager._builtResources.values()).sort((a, b) => a.id.localeCompare(b.id))));
     }
+    /**
+     * Builds and returns a hierarchical tree representation of all resources managed by this builder.
+     * Resources are organized based on their dot-separated resource IDs (e.g., "app.messages.welcome"
+     * becomes a tree with "app" as root, "messages" as branch, and "welcome" as leaf).
+     *
+     * String-based validation is available through the `children.validating` property,
+     * allowing callers to use `tree.children.validating.getById(stringId)` for validated access.
+     *
+     * Uses lazy initialization with caching for performance.
+     * @returns Result containing the resource tree root, or failure if tree construction fails
+     * @public
+     */
+    getBuiltResourceTree() {
+        // Ensure resources are built first
+        return this.build().onSuccess((manager) => {
+            if (manager._cachedResourceTree) {
+                return (0, ts_utils_1.succeed)(manager._cachedResourceTree);
+            }
+            // Convert all built resources to [ResourceId, Resource] pairs
+            const resources = [];
+            for (const [id, resource] of manager._builtResources.entries()) {
+                resources.push([id, resource]);
+            }
+            // Create the resource tree with lazy initialization
+            return runtime_1.ResourceTree.ReadOnlyResourceTreeRoot.create(resources).onSuccess((tree) => {
+                manager._cachedResourceTree = tree;
+                return (0, ts_utils_1.succeed)(tree);
+            });
+        });
+    }
     /**
      * Gets a read-only array of all {@link Resources.Resource | built resources} in the manager.
      * @returns `Success` with an array of resources if successful, or `Failure` with an error message if not.
@@ -407,6 +481,7 @@ class ResourceManagerBuilder {
     getCompiledResourceCollection(options) {
         // Build resources first to ensure all data is available
         const buildResult = this._performBuild();
+        /* c8 ignore next 3 - defensive coding: build failure should not occur after successful validation */
         if (buildResult.isFailure()) {
             return (0, ts_utils_1.fail)(`Failed to build resources: ${buildResult.message}`);
         }
@@ -427,6 +502,7 @@ class ResourceManagerBuilder {
             conditions: Array.from(this._conditions.values()).map((c) => c.toCompiled(options)),
             conditionSets: Array.from(this._conditionSets.values()).map((cs) => cs.toCompiled(options)),
             decisions: Array.from(this._decisions.values()).map((d) => d.toCompiled(options)),
+            candidateValues: this._candidateValues.getValuesByIndex(),
             resources: Array.from(this._builtResources.values()).map((r) => r.toCompiled(options))
         };
         // Apply validation through the converter
@@ -467,20 +543,26 @@ class ResourceManagerBuilder {
         });
     }
     /**
-     * Creates a filtered clone of this ResourceManagerBuilder using the specified context.
-     * This is a convenience method that creates a new ResourceManagerBuilder with the same
-     * configuration but filtered to include only candidates that match the provided context.
-     * If candidates are provided for editing, they will be applied with collision detection.
-     * @param options - Options for the cloning operation, including the strongly-typed filterForContext property and optional candidates for edits.
-     * @returns A Result containing the new filtered ResourceManagerBuilder.
+     * Creates a clone of this ResourceManagerBuilder with optional configuration overrides.
+     * This method creates a new ResourceManagerBuilder that can optionally use different
+     * qualifiers and/or resource types than the original. It can also be filtered to include
+     * only candidates that match the provided context and apply candidate edits.
+     *
+     * @param options - Options for the cloning operation:
+     *   - `qualifiers`: Optional qualifier collector to use instead of the original
+     *   - `resourceTypes`: Optional resource type collector to use instead of the original
+     *   - `filterForContext`: Optional context filter for candidates
+     *   - `candidates`: Optional candidate edits to apply during cloning
+     * @returns A Result containing the new ResourceManagerBuilder with the specified configuration.
      * @public
      */
     /* c8 ignore next 21 - functional code path tested but coverage intermittently missed */
     clone(options) {
         return this.getResourceCollectionDecl(options).onSuccess((collection) => {
+            var _a, _b;
             return ResourceManagerBuilder.create({
-                qualifiers: this.qualifiers,
-                resourceTypes: this.resourceTypes
+                qualifiers: (_a = options === null || options === void 0 ? void 0 : options.qualifiers) !== null && _a !== void 0 ? _a : this.qualifiers,
+                resourceTypes: (_b = options === null || options === void 0 ? void 0 : options.resourceTypes) !== null && _b !== void 0 ? _b : this.resourceTypes
             }).onSuccess((newManager) => {
                 // Check if we have candidates to apply as edits
                 const editCandidates = (options === null || options === void 0 ? void 0 : options.candidates) || [];
@@ -500,6 +582,7 @@ class ResourceManagerBuilder {
                                 return (0, ts_utils_1.fail)(`${resourceDecl.id}: Failed to apply edits: ${editedDeclResult.message}`);
                             }
                             const addResult = newManager.addResource(editedDeclResult.value);
+                            /* c8 ignore next 5 - edge case (nearly?) impossible to reproduce */
                             if (addResult.isFailure()) {
                                 return (0, ts_utils_1.fail)(`${resourceDecl.id}: Failed to add resource to cloned manager: ${addResult.message}`);
                             }
@@ -556,36 +639,6 @@ class ResourceManagerBuilder {
      * @returns A Result containing the ConditionSet token if successful, or failure if validation fails
      * @internal
      */
-    static _getConditionSetToken(conditionSet, conditionCollector) {
-        if (!conditionSet) {
-            return (0, ts_utils_1.succeed)(conditions_1.ConditionSet.UnconditionalKey);
-        }
-        // Convert ConditionSetDecl to IConditionSetDecl format
-        let conditionSetDecl;
-        if (Array.isArray(conditionSet)) {
-            // ConditionSetDeclAsArray: array of ILooseConditionDecl
-            conditionSetDecl = { conditions: conditionSet };
-        }
-        else {
-            // ConditionSetDeclAsRecord: Record<string, string | IChildConditionDecl>
-            const conditions = Object.entries(conditionSet).map(([qualifierName, value]) => {
-                if (typeof value === 'string') {
-                    return { qualifierName, value };
-                }
-                else {
-                    return Object.assign({ qualifierName }, value);
-                }
-            });
-            conditionSetDecl = { conditions };
-        }
-        // Validate and convert to IValidatedConditionSetDecl
-        return conditions_1.Convert.validatedConditionSetDecl
-            .convert(conditionSetDecl, { conditions: conditionCollector })
-            .onSuccess((validatedDecl) => {
-            // Use proper ConditionSet.getKeyForDecl method to generate the token
-            return conditions_1.ConditionSet.getKeyForDecl(validatedDecl);
-        });
-    }
     /**
      * Applies candidate edits to a resource declaration, handling collisions using condition set tokens.
      * If there's no collision, adds the candidate. If there's a collision, replaces the original candidate with the edit.
@@ -596,7 +649,9 @@ class ResourceManagerBuilder {
      * @internal
      */
     static _applyEditsToResourceDeclaration(resourceDecl, candidatesByResource, conditionCollector) {
+        var _a, _b;
         const { value: resourceId, message } = common_1.Validate.toResourceId(resourceDecl.id);
+        /* c8 ignore next 3 - defensive validation: resource IDs are validated when added to builder, but this protects against corrupted data */
         if (message !== undefined) {
             return (0, ts_utils_1.fail)(`Invalid resource ID "${resourceDecl.id}": ${message}`);
         }
@@ -606,9 +661,12 @@ class ResourceManagerBuilder {
         }
         // Use Map approach: apply original candidates first, then replace with edits on collision
         const candidatesByConditionKey = new Map();
+        /* c8 ignore next 1 - ?? is defense in depth */
+        const declCandidates = (_a = resourceDecl.candidates) !== null && _a !== void 0 ? _a : [];
         // First, add all original candidates keyed by their condition set token
-        for (const candidate of resourceDecl.candidates || []) {
-            const conditionTokenResult = ResourceManagerBuilder._getConditionSetToken(candidate.conditions, conditionCollector);
+        for (const candidate of declCandidates) {
+            const conditionTokenResult = conditions_1.ConditionSet.getKeyFromLooseDecl(candidate.conditions, conditionCollector);
+            /* c8 ignore next 5 - edge case or internal error (nearly?) impossible to reproduce */
             if (conditionTokenResult.isFailure()) {
                 return (0, ts_utils_1.fail)(`Failed to generate condition token for original candidate: ${conditionTokenResult.message}`);
             }
@@ -617,12 +675,26 @@ class ResourceManagerBuilder {
         // Then, apply edits (this replaces any colliding original candidates)
         // Convert edit candidates (which have ids) to child candidates (without ids) for merging
         for (const editCandidate of editCandidates) {
-            const conditionTokenResult = ResourceManagerBuilder._getConditionSetToken(editCandidate.conditions, conditionCollector);
+            const conditionTokenResult = conditions_1.ConditionSet.getKeyFromLooseDecl(editCandidate.conditions, conditionCollector);
             if (conditionTokenResult.isFailure()) {
                 return (0, ts_utils_1.fail)(`Failed to generate condition token for edit candidate: ${conditionTokenResult.message}`);
             }
+            let editedJson = editCandidate.json;
+            const previousJson = (_b = candidatesByConditionKey.get(conditionTokenResult.value)) === null || _b === void 0 ? void 0 : _b.json;
+            if (previousJson && previousJson !== editedJson) {
+                editedJson = ts_json_1.JsonEditor.create({
+                    merge: {
+                        arrayMergeBehavior: 'replace',
+                        nullAsDelete: false
+                    }
+                })
+                    .onSuccess((editor) => {
+                    return editor.mergeObjectsInPlace({}, [previousJson, editedJson]);
+                })
+                    .orThrow();
+            }
             const childCandidate = {
-                json: editCandidate.json,
+                json: editedJson,
                 conditions: editCandidate.conditions,
                 isPartial: editCandidate.isPartial,
                 mergeMethod: editCandidate.mergeMethod
@@ -647,11 +719,13 @@ class ResourceManagerBuilder {
         // Convert candidate declarations to child candidate declarations
         const childCandidates = [];
         // Ensure we have candidates
+        /* c8 ignore next 3 - defense in depth against internal error */
         if (candidates.length === 0) {
             return (0, ts_utils_1.fail)('Cannot create resource declaration from empty candidates array');
         }
         // Extract resourceTypeName from the first candidate (all candidates for the same resource should have the same type)
         const resourceTypeName = candidates[0].resourceTypeName;
+        /* c8 ignore next 3 - defense in depth */
         if (!resourceTypeName) {
             return (0, ts_utils_1.fail)('resourceTypeName is required for new resource candidates');
         }
@@ -672,6 +746,170 @@ class ResourceManagerBuilder {
         };
         return (0, ts_utils_1.succeed)(newResourceDecl);
     }
+    /**
+     * Reconstructs conditions from a compiled collection and adds them to the builder.
+     * @param builder - The builder to add conditions to.
+     * @param compiledCollection - The compiled collection containing conditions.
+     * @returns `Success` if all conditions were added successfully, `Failure` otherwise.
+     * @internal
+     */
+    static _reconstructConditions(builder, compiledCollection) {
+        const errors = new ts_utils_1.MessageAggregator();
+        for (const compiledCondition of compiledCollection.conditions) {
+            // Get the qualifier by index
+            const qualifierResult = builder.qualifiers.getAt(compiledCondition.qualifierIndex);
+            /* c8 ignore next 4 - edge case or internal error (nearly?) impossible to reproduce */
+            if (qualifierResult.isFailure()) {
+                qualifierResult.aggregateError(errors);
+                continue;
+            }
+            // Create condition declaration from compiled condition
+            const conditionDecl = {
+                qualifierName: qualifierResult.value.name,
+                operator: compiledCondition.operator,
+                value: compiledCondition.value,
+                priority: compiledCondition.priority,
+                scoreAsDefault: compiledCondition.scoreAsDefault
+            };
+            // Add condition to builder (it will get the next sequential index)
+            builder.addCondition(conditionDecl).aggregateError(errors);
+        }
+        return errors.returnOrReport((0, ts_utils_1.succeed)(true));
+    }
+    /**
+     * Reconstructs condition sets from a compiled collection and adds them to the builder.
+     * @param builder - The builder to add condition sets to.
+     * @param compiledCollection - The compiled collection containing condition sets.
+     * @returns `Success` if all condition sets were added successfully, `Failure` otherwise.
+     * @internal
+     */
+    static _reconstructConditionSets(builder, compiledCollection) {
+        const errors = new ts_utils_1.MessageAggregator();
+        for (const compiledConditionSet of compiledCollection.conditionSets) {
+            // Get conditions by their indices
+            const conditionResults = compiledConditionSet.conditions.map((idx) => builder._conditions.getAt(idx));
+            // Check for any failures
+            const failedIndex = conditionResults.findIndex((r) => r.isFailure());
+            /* c8 ignore next 4 - edge case or internal error (nearly?) impossible to reproduce */
+            if (failedIndex >= 0) {
+                conditionResults[failedIndex].aggregateError(errors);
+                continue;
+            }
+            // Create condition set from conditions (not declarations)
+            const conditions = conditionResults.map((r) => r.orThrow());
+            // Convert conditions to declarations for addConditionSet
+            const conditionDecls = conditions.map((c) => c.toLooseConditionDecl());
+            builder.addConditionSet(conditionDecls).aggregateError(errors);
+        }
+        return errors.returnOrReport((0, ts_utils_1.succeed)(true));
+    }
+    /**
+     * Reconstructs decisions from a compiled collection and adds them to the builder.
+     * @param builder - The builder to add decisions to.
+     * @param compiledCollection - The compiled collection containing decisions.
+     * @returns `Success` if all decisions were added successfully, `Failure` otherwise.
+     * @internal
+     */
+    static _reconstructDecisions(builder, compiledCollection) {
+        const errors = new ts_utils_1.MessageAggregator();
+        for (const compiledDecision of compiledCollection.decisions) {
+            // Get condition sets by their indices
+            const conditionSetResults = compiledDecision.conditionSets.map((idx) => builder._conditionSets.getAt(idx));
+            // Check for any failures
+            const failedIndex = conditionSetResults.findIndex((r) => r.isFailure());
+            if (failedIndex >= 0) {
+                conditionSetResults[failedIndex].aggregateError(errors);
+                continue;
+            }
+            // Get condition sets from successful results
+            const conditionSets = conditionSetResults.map((r) => r.orThrow());
+            // Create AbstractDecision from condition sets and add to collector
+            decisions_1.AbstractDecision.createAbstractDecision({ conditionSets })
+                .onSuccess((decision) => builder._decisions.getOrAdd(decision))
+                .aggregateError(errors);
+        }
+        return errors.returnOrReport((0, ts_utils_1.succeed)(true));
+    }
+    /**
+     * Reconstructs resources and their candidates from a compiled collection and adds them to the builder.
+     * @param builder - The builder to add resources to.
+     * @param compiledCollection - The compiled collection containing resources.
+     * @returns `Success` if all resources were added successfully, `Failure` otherwise.
+     * @internal
+     */
+    static _reconstructResources(builder, compiledCollection) {
+        const errors = new ts_utils_1.MessageAggregator();
+        for (const compiledResource of compiledCollection.resources) {
+            // Get the resource type by index
+            const resourceTypeResult = builder.resourceTypes.getAt(compiledResource.type);
+            /* c8 ignore next 4 - edge case or internal error (nearly?) impossible to reproduce */
+            if (resourceTypeResult.isFailure()) {
+                resourceTypeResult.aggregateError(errors);
+                continue;
+            }
+            // Get the decision by index
+            const decisionResult = builder._decisions.getAt(compiledResource.decision);
+            /* c8 ignore next 4 - edge case or internal error (nearly?) impossible to reproduce */
+            if (decisionResult.isFailure()) {
+                decisionResult.aggregateError(errors);
+                continue;
+            }
+            const decision = decisionResult.value;
+            const resourceType = resourceTypeResult.value;
+            // Create candidates from the decision's condition sets
+            ResourceManagerBuilder._createCandidatesFromDecision(compiledResource, decision, resourceType, builder, compiledCollection.candidateValues).aggregateError(errors);
+        }
+        return errors.returnOrReport((0, ts_utils_1.succeed)(true));
+    }
+    /**
+     * Helper method to create candidates from a decision's condition sets.
+     * @param compiledResource - The compiled resource containing candidates.
+     * @param decision - The decision containing condition sets.
+     * @param resourceType - The resource type for the candidates.
+     * @param builder - The builder to add candidates to.
+     * @param candidateValues - Array of candidate values indexed by valueIndex.
+     * @returns `Success` if all candidates were added successfully, `Failure` otherwise.
+     * @internal
+     */
+    static _createCandidatesFromDecision(compiledResource, decision, resourceType, builder, candidateValues) {
+        var _a;
+        const errors = new ts_utils_1.MessageAggregator();
+        // Match each candidate to its corresponding condition set
+        for (let i = 0; i < compiledResource.candidates.length; i++) {
+            const candidate = compiledResource.candidates[i];
+            // Build conditions from the corresponding condition set (if available)
+            let conditions;
+            if (i < decision.candidates.length) {
+                const decisionCandidate = decision.candidates[i];
+                conditions = {};
+                for (const condition of decisionCandidate.conditionSet.conditions) {
+                    conditions[condition.qualifier.name] = condition.value;
+                }
+                /* c8 ignore next 3 - defense in depth */
+                if (Object.keys(conditions).length === 0) {
+                    conditions = undefined;
+                }
+            }
+            // Get json value from candidateValues array using valueIndex
+            /* c8 ignore next 1 - defense in depth */
+            const rawJson = (_a = candidateValues[candidate.valueIndex]) !== null && _a !== void 0 ? _a : {};
+            ts_json_base_1.Converters.jsonObject
+                .convert(rawJson)
+                .onSuccess((json) => {
+                const candidateDecl = {
+                    id: compiledResource.id,
+                    json,
+                    conditions,
+                    isPartial: candidate.isPartial,
+                    mergeMethod: candidate.mergeMethod,
+                    resourceTypeName: resourceType.key
+                };
+                return builder.addLooseCandidate(candidateDecl).aggregateError(errors);
+            })
+                .aggregateError(errors);
+        }
+        return errors.returnOrReport((0, ts_utils_1.succeed)(true));
+    }
 }
 exports.ResourceManagerBuilder = ResourceManagerBuilder;
 //# sourceMappingURL=resourceManagerBuilder.js.map

package/lib/packlets/runtime/compiledResourceCollection.d.ts

@@ -1,13 +1,14 @@
 import { Collections, Result } from '@fgv/ts-utils';
 import { ReadOnlyConditionCollector, ReadOnlyConditionSetCollector } from '../conditions';
 import { ReadOnlyAbstractDecisionCollector } from '../decisions';
-import { QualifierCollector } from '../qualifiers';
-import { ResourceType, ResourceTypeCollector } from '../resource-types';
-import { QualifierType, QualifierTypeCollector } from '../qualifier-types';
+import { IReadOnlyQualifierCollector } from '../qualifiers';
+import { ResourceType, ReadOnlyResourceTypeCollector } from '../resource-types';
+import { QualifierType, ReadOnlyQualifierTypeCollector } from '../qualifier-types';
 import { ResourceId } from '../common';
+import { JsonValue } from '@fgv/ts-json-base';
 import { IResourceManager, IResource } from './iResourceManager';
 import * as ResourceJson from '../resource-json';
-import { IReadOnlyResourceTreeRoot } from './resource-tree';
+import { ReadOnlyResourceTreeRoot } from './resource-tree';
 import * as Context from '../context';
 /**
  * Interface for parameters to create a {@link Runtime.CompiledResourceCollection | CompiledResourceCollection}.
@@ -33,30 +34,35 @@ export interface ICompiledResourceCollectionCreateParams {
  * and use pre-compiled resource collections without rebuilding them from scratch.
  * @public
  */
-export declare class CompiledResourceCollection implements IResourceManager {
+export declare class CompiledResourceCollection implements IResourceManager<IResource> {
     readonly conditions: ReadOnlyConditionCollector;
     readonly conditionSets: ReadOnlyConditionSetCollector;
     readonly decisions: ReadOnlyAbstractDecisionCollector;
     private readonly _qualifierTypes;
     private readonly _qualifiers;
     private readonly _resourceTypes;
+    private readonly _candidateValues;
     private readonly _builtResources;
     private _cachedResourceTree?;
     /**
-     * A {@link QualifierTypes.QualifierTypeCollector | QualifierTypeCollector} which
+     * A {@link QualifierTypes.ReadOnlyQualifierTypeCollector | ReadOnlyQualifierTypeCollector} which
      * contains the {@link QualifierTypes.QualifierType | qualifier types} used in this collection.
      */
-    get qualifierTypes(): QualifierTypeCollector;
+    get qualifierTypes(): ReadOnlyQualifierTypeCollector;
     /**
-     * A {@link Qualifiers.QualifierCollector | QualifierCollector} which
+     * A {@link Qualifiers.IReadOnlyQualifierCollector | ReadOnlyQualifierCollector} which
      * contains the {@link Qualifiers.Qualifier | qualifiers} used in this collection.
      */
-    get qualifiers(): QualifierCollector;
+    get qualifiers(): IReadOnlyQualifierCollector;
     /**
      * A {@link ResourceTypes.ResourceTypeCollector | ResourceTypeCollector} which
      * contains the {@link ResourceTypes.ResourceType | resource types} used in this collection.
      */
-    get resourceTypes(): ResourceTypeCollector;
+    get resourceTypes(): ReadOnlyResourceTypeCollector;
+    /**
+     * The candidate values in the collection.
+     */
+    get candidateValues(): ReadonlyArray<JsonValue>;
     /**
      * {@inheritdoc Runtime.IResourceManager.builtResources}
      */
@@ -105,7 +111,7 @@ export declare class CompiledResourceCollection implements IResourceManager {
      * @returns Result containing the resource tree root, or failure if tree construction fails
      * @public
      */
-    getBuiltResourceTree(): Result<IReadOnlyResourceTreeRoot<IResource>>;
+    getBuiltResourceTree(): Result<ReadOnlyResourceTreeRoot<IResource>>;
     /**
      * Reconstructs a QualifierTypeCollector from compiled data.
      * @param compiled - The compiled resource collection
@@ -154,6 +160,12 @@ export declare class CompiledResourceCollection implements IResourceManager {
      * @internal
      */
     private _buildDecisions;
+    /**
+     * Gets a candidate value from the collection.
+     * @param valueIndex - The index of the candidate value to get.
+     * @returns
+     */
+    private _getCandidateValue;
     /**
      * Reconstructs a ValidatingResultMap of resources from compiled data.
      * @param compiled - The compiled resource collection