@fgv/ts-res 5.0.0-21 → 5.0.0-23

package/lib/packlets/resources/resourceManagerBuilder.js

@@ -63,6 +63,7 @@ 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"));
@@ -79,6 +80,7 @@ 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;
     }
     /**
@@ -149,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,
@@ -234,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()) {
@@ -259,7 +263,8 @@ 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) {
@@ -494,6 +499,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
@@ -848,7 +854,7 @@ class ResourceManagerBuilder {
             const decision = decisionResult.value;
             const resourceType = resourceTypeResult.value;
             // Create candidates from the decision's condition sets
-            ResourceManagerBuilder._createCandidatesFromDecision(compiledResource, decision, resourceType, builder).aggregateError(errors);
+            ResourceManagerBuilder._createCandidatesFromDecision(compiledResource, decision, resourceType, builder, compiledCollection.candidateValues).aggregateError(errors);
         }
         return errors.returnOrReport((0, ts_utils_1.succeed)(true));
     }
@@ -858,10 +864,11 @@ class ResourceManagerBuilder {
      * @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) {
+    static _createCandidatesFromDecision(compiledResource, decision, resourceType, builder, candidateValues) {
         var _a;
         const errors = new ts_utils_1.MessageAggregator();
         // Match each candidate to its corresponding condition set
@@ -880,9 +887,9 @@ class ResourceManagerBuilder {
                     conditions = undefined;
                 }
             }
-            // Convert json value to JsonObject, handling undefined case
+            // Get json value from candidateValues array using valueIndex
             /* c8 ignore next 1 - defense in depth */
-            const rawJson = (_a = candidate.json) !== null && _a !== void 0 ? _a : {};
+            const rawJson = (_a = candidateValues[candidate.valueIndex]) !== null && _a !== void 0 ? _a : {};
             ts_json_base_1.Converters.jsonObject
                 .convert(rawJson)
                 .onSuccess((json) => {

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

@@ -1,10 +1,11 @@
 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 { ReadOnlyResourceTreeRoot } from './resource-tree';
@@ -40,23 +41,28 @@ export declare class CompiledResourceCollection implements IResourceManager<IRes
     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}
      */
@@ -154,6 +160,12 @@ export declare class CompiledResourceCollection implements IResourceManager<IRes
      * @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

package/lib/packlets/runtime/compiledResourceCollection.js

@@ -75,14 +75,14 @@ const Context = __importStar(require("../context"));
  */
 class CompiledResourceCollection {
     /**
-     * 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() {
         return this._qualifierTypes;
     }
     /**
-     * A {@link Qualifiers.QualifierCollector | QualifierCollector} which
+     * A {@link Qualifiers.IReadOnlyQualifierCollector | ReadOnlyQualifierCollector} which
      * contains the {@link Qualifiers.Qualifier | qualifiers} used in this collection.
      */
     get qualifiers() {
@@ -95,6 +95,12 @@ class CompiledResourceCollection {
     get resourceTypes() {
         return this._resourceTypes;
     }
+    /**
+     * The candidate values in the collection.
+     */
+    get candidateValues() {
+        return this._candidateValues;
+    }
     /**
      * {@inheritdoc Runtime.IResourceManager.builtResources}
      */
@@ -133,6 +139,7 @@ class CompiledResourceCollection {
         this.conditions = conditionCollector;
         this.conditionSets = conditionSetCollector;
         this.decisions = decisionCollector;
+        this._candidateValues = [...params.compiledCollection.candidateValues];
         // Build resources from compiled data
         this._builtResources = this._buildResources(params.compiledCollection, this._resourceTypes, decisionCollector).orThrow();
     }
@@ -381,6 +388,21 @@ class CompiledResourceCollection {
         }
         return errors.hasMessages ? (0, ts_utils_1.fail)(errors.toString()) : (0, ts_utils_1.succeed)(decisionCollector);
     }
+    /**
+     * Gets a candidate value from the collection.
+     * @param valueIndex - The index of the candidate value to get.
+     * @returns
+     */
+    _getCandidateValue(valueIndex) {
+        if (valueIndex < 0 || valueIndex >= this._candidateValues.length) {
+            return (0, ts_utils_1.fail)(`Invalid candidate value index ${valueIndex}`);
+        }
+        /* c8 ignore next 3 - defensive coding for invalid candidate value conversion */
+        if (!(0, ts_json_base_1.isJsonObject)(this._candidateValues[valueIndex])) {
+            return (0, ts_utils_1.fail)(`${valueIndex}: candidate value not a JSON object.`);
+        }
+        return (0, ts_utils_1.succeed)(this._candidateValues[valueIndex]);
+    }
     /**
      * Reconstructs a ValidatingResultMap of resources from compiled data.
      * @param compiled - The compiled resource collection
@@ -413,7 +435,7 @@ class CompiledResourceCollection {
             }
             const decision = decisionResult.value;
             // Build candidates from compiled data
-            const candidateDeclsResult = (0, ts_utils_1.mapResults)(compiledResource.candidates.map((compiledCandidate) => ts_json_base_1.Converters.jsonObject.convert(compiledCandidate.json).onSuccess((json) => {
+            const candidateDeclsResult = (0, ts_utils_1.mapResults)(compiledResource.candidates.map((compiledCandidate) => this._getCandidateValue(compiledCandidate.valueIndex).onSuccess((json) => {
                 return (0, ts_utils_1.succeed)({
                     json,
                     isPartial: compiledCandidate.isPartial,
@@ -431,7 +453,6 @@ class CompiledResourceCollection {
                 isPartial: candidateDecl.isPartial,
                 mergeMethod: candidateDecl.mergeMethod
             }));
-            // Create a ConcreteDecision from the abstract decision and candidate values
             const candidatesWithConditionSets = decision.candidates.map((baseCandidate, idx) => ({
                 conditionSet: baseCandidate.conditionSet,
                 value: candidates[idx].json

package/lib/packlets/runtime/resource-tree/common.d.ts

@@ -49,7 +49,7 @@ export type IReadOnlyResourceTreeNode<T> = IReadOnlyResourceTreeLeaf<T> | IReadO
  * Interface for a read-only result-based resource tree with navigation methods.
  * @public
  */
-export interface IReadOnlyResourceTreeChildren<T, TID extends string = ResourceId, TNAME extends string = ResourceName> extends IReadOnlyResultMap<ResourceName, IReadOnlyResourceTreeNode<T>> {
+export interface IReadOnlyResourceTreeChildren<T, TID extends string = ResourceId, TNAME extends string = ResourceName> extends IReadOnlyResultMap<TNAME, IReadOnlyResourceTreeNode<T>> {
     /**
      * Gets a tree node by its full ResourceId path.
      * @param id - The ResourceId path to look up

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

@@ -1,5 +1,6 @@
 import { Result } from '@fgv/ts-utils';
 import { JsonValue } from '@fgv/ts-json-base';
+import { IResourceResolver } from '../common';
 import { Condition, ConditionSet } from '../conditions';
 import { AbstractDecision } from '../decisions';
 import { ReadOnlyQualifierTypeCollector } from '../qualifier-types';
@@ -7,6 +8,7 @@ import { IContextQualifierProvider } from './context';
 import { IResourceManager, IResource, IResourceCandidate } from './iResourceManager';
 import { ConditionSetResolutionResult, IConditionMatchResult } from './conditionSetResolutionResult';
 import { IResourceResolverCacheListener } from './cacheListener';
+import { IReadOnlyQualifierCollector } from '../qualifiers';
 /**
  * Represents the cached result of resolving a decision.
  * Contains either a failure indicator or a list of instance indices for matching condition sets,
@@ -68,7 +70,7 @@ export interface IResourceResolverCreateParams {
  * and caching results for optimal performance.
  * @public
  */
-export declare class ResourceResolver {
+export declare class ResourceResolver implements IResourceResolver {
     /**
      * The resource manager that defines available resources and provides condition access.
      */
@@ -85,6 +87,10 @@ export declare class ResourceResolver {
      * The configuration options for this resource resolver.
      */
     readonly options: IResourceResolverOptions;
+    /**
+     * The readonly qualifier collector that provides qualifier implementations.
+     */
+    get qualifiers(): IReadOnlyQualifierCollector;
     /**
      * The cache array for resolved conditions, indexed by condition index for O(1) lookup.
      * Each entry stores the resolved {@link Runtime.IConditionMatchResult | condition match result} for
@@ -169,6 +175,15 @@ export declare class ResourceResolver {
      * @public
      */
     resolveResource(resource: IResource): Result<IResourceCandidate>;
+    /**
+     * Resolves a resource by finding the best matching candidate.
+     * Uses the resource's associated decision to determine the best match based on the current context.
+     * @param resource - The string id of the resource to resolve.
+     * @returns `Success` with the best matching candidate if successful,
+     * or `Failure` with an error message if no candidates match or resolution fails.
+     * @public
+     */
+    resolveResource(resource: string): Result<IResourceCandidate>;
     /**
      * Resolves all matching resource candidates in priority order.
      * Uses the resource's associated decision to determine all matching candidates based on the current context.
@@ -178,6 +193,15 @@ export declare class ResourceResolver {
      * @public
      */
     resolveAllResourceCandidates(resource: IResource): Result<ReadonlyArray<IResourceCandidate>>;
+    /**
+     * Resolves all matching resource candidates in priority order.
+     * Uses the resource's associated decision to determine all matching candidates based on the current context.
+     * @param resource - The string id of the resource to resolve.
+     * @returns `Success` with an array of all matching candidates in priority order if successful,
+     * or `Failure` with an error message if no candidates match or resolution fails.
+     * @public
+     */
+    resolveAllResourceCandidates(resource: string): Result<ReadonlyArray<IResourceCandidate>>;
     /**
      * Resolves a resource to a composed value by merging matching candidates according to their merge methods.
      * Starting from the highest priority candidates, finds the first "full" candidate and merges all higher
@@ -188,6 +212,20 @@ export declare class ResourceResolver {
      * @public
      */
     resolveComposedResourceValue(resource: IResource): Result<JsonValue>;
+    /**
+     * Resolves a resource to a composed value by merging matching candidates according to their merge methods.
+     * Starting from the highest priority candidates, finds the first "full" candidate and merges all higher
+     * priority "partial" candidates into it in ascending order of priority.
+     * @param resource - The string id of the resource to resolve.
+     * @returns `Success` with the composed JsonValue if successful,
+     * or `Failure` with an error message if no candidates match or resolution fails.
+     * @public
+     */
+    resolveComposedResourceValue(resource: string): Result<JsonValue>;
+    /**
+     * {@inheritDoc IResourceResolver.withContext}
+     */
+    withContext(context: Record<string, string>): Result<ResourceResolver>;
     /**
      * Clears all caches (condition, condition set, and decision), forcing all cached items
      * to be re-evaluated on next access. This should be called when the context changes and cached

package/lib/packlets/runtime/resourceResolver.js

@@ -26,6 +26,7 @@ const ts_utils_1 = require("@fgv/ts-utils");
 const ts_json_base_1 = require("@fgv/ts-json-base");
 const ts_json_1 = require("@fgv/ts-json");
 const common_1 = require("../common");
+const context_1 = require("./context");
 const conditionSetResolutionResult_1 = require("./conditionSetResolutionResult");
 /**
  * High-performance runtime resource resolver with O(1) condition caching.
@@ -34,6 +35,12 @@ const conditionSetResolutionResult_1 = require("./conditionSetResolutionResult")
  * @public
  */
 class ResourceResolver {
+    /**
+     * The readonly qualifier collector that provides qualifier implementations.
+     */
+    get qualifiers() {
+        return this.contextQualifierProvider.qualifiers;
+    }
     /**
      * The cache array for resolved conditions, indexed by condition index for O(1) lookup.
      * Each entry stores the resolved {@link Runtime.IConditionMatchResult | condition match result} for
@@ -268,15 +275,13 @@ class ResourceResolver {
         (_c = this._listener) === null || _c === void 0 ? void 0 : _c.onCacheMiss('decision', decisionIndex);
         return (0, ts_utils_1.succeed)(successResult);
     }
-    /**
-     * Resolves a resource by finding the best matching candidate.
-     * Uses the resource's associated decision to determine the best match based on the current context.
-     * @param resource - The {@link Resources.Resource | resource} to resolve.
-     * @returns `Success` with the best matching candidate if successful,
-     * or `Failure` with an error message if no candidates match or resolution fails.
-     * @public
-     */
-    resolveResource(resource) {
+    resolveResource(idOrResource) {
+        if (typeof idOrResource === 'string') {
+            return this.resourceManager
+                .getBuiltResource(idOrResource)
+                .onSuccess((resource) => this.resolveResource(resource));
+        }
+        const resource = idOrResource;
         // Get the abstract decision from the resource's concrete decision
         const abstractDecision = resource.decision.baseDecision;
         // Resolve the decision to get candidate indices in priority order
@@ -301,15 +306,13 @@ class ResourceResolver {
         const bestCandidate = resource.candidates[candidateIndex];
         return (0, ts_utils_1.succeed)(bestCandidate);
     }
-    /**
-     * Resolves all matching resource candidates in priority order.
-     * Uses the resource's associated decision to determine all matching candidates based on the current context.
-     * @param resource - The {@link Resources.Resource | resource} to resolve.
-     * @returns `Success` with an array of all matching candidates in priority order if successful,
-     * or `Failure` with an error message if no candidates match or resolution fails.
-     * @public
-     */
-    resolveAllResourceCandidates(resource) {
+    resolveAllResourceCandidates(idOrResource) {
+        if (typeof idOrResource === 'string') {
+            return this.resourceManager
+                .getBuiltResource(idOrResource)
+                .onSuccess((resource) => this.resolveAllResourceCandidates(resource));
+        }
+        const resource = idOrResource;
         // Get the abstract decision from the resource's concrete decision
         const abstractDecision = resource.decision.baseDecision;
         // Resolve the decision to get candidate indices in priority order
@@ -345,16 +348,13 @@ class ResourceResolver {
         }
         return (0, ts_utils_1.succeed)(candidates);
     }
-    /**
-     * Resolves a resource to a composed value by merging matching candidates according to their merge methods.
-     * Starting from the highest priority candidates, finds the first "full" candidate and merges all higher
-     * priority "partial" candidates into it in ascending order of priority.
-     * @param resource - The {@link Resources.Resource | resource} to resolve.
-     * @returns `Success` with the composed JsonValue if successful,
-     * or `Failure` with an error message if no candidates match or resolution fails.
-     * @public
-     */
-    resolveComposedResourceValue(resource) {
+    resolveComposedResourceValue(idOrResource) {
+        if (typeof idOrResource === 'string') {
+            return this.resourceManager
+                .getBuiltResource(idOrResource)
+                .onSuccess((resource) => this.resolveComposedResourceValue(resource));
+        }
+        const resource = idOrResource;
         return this.resolveAllResourceCandidates(resource).onSuccess((candidates) => {
             /* c8 ignore next 3 - defense in depth should never occur */
             if (candidates.length === 0) {
@@ -415,6 +415,23 @@ class ResourceResolver {
                 .withErrorFormat((err) => `${resource.id}: Composition failed: ${err}`);
         });
     }
+    /**
+     * {@inheritDoc IResourceResolver.withContext}
+     */
+    withContext(context) {
+        const { resourceManager, qualifierTypes, options } = this;
+        return context_1.ValidatingSimpleContextQualifierProvider.create({
+            qualifiers: this.qualifiers,
+            qualifierValues: context
+        }).onSuccess((contextQualifierProvider) => {
+            return ResourceResolver.create({
+                resourceManager,
+                qualifierTypes,
+                options,
+                contextQualifierProvider
+            });
+        });
+    }
     /**
      * Clears all caches (condition, condition set, and decision), forcing all cached items
      * to be re-evaluated on next access. This should be called when the context changes and cached

package/lib/test/unit/qualifier-types/testQualifierType.d.ts

@@ -1,15 +1,19 @@
 import { Result } from '@fgv/ts-utils';
 import * as TsRes from '../../../index';
+import { JsonObject } from '@fgv/ts-json-base';
 export interface ITestQualifierTypeConstructorParams {
     name?: string;
     allowContextList?: string;
     index?: number;
 }
 export declare class TestQualifierType extends TsRes.QualifierTypes.QualifierType {
+    readonly systemTypeName: TsRes.QualifierTypeName;
     constructor(params?: ITestQualifierTypeConstructorParams);
     static create(params?: ITestQualifierTypeConstructorParams): Result<TestQualifierType>;
     isValidConditionValue(value: string): value is TsRes.QualifierConditionValue;
     validateCondition(value: string, operator?: TsRes.ConditionOperator): Result<TsRes.QualifierConditionValue>;
+    getConfigurationJson(): Result<JsonObject>;
+    validateConfigurationJson(from: unknown): Result<JsonObject>;
     protected _matchOne(condition: TsRes.QualifierConditionValue, context: TsRes.QualifierContextValue, operator: TsRes.ConditionOperator): TsRes.QualifierMatchScore;
 }
 //# sourceMappingURL=testQualifierType.d.ts.map

package/lib/test/unit/qualifier-types/testQualifierType.js

@@ -65,6 +65,9 @@ class TestQualifierType extends TsRes.QualifierTypes.QualifierType {
             allowContextList: (params === null || params === void 0 ? void 0 : params.allowContextList) === 'true',
             index: params === null || params === void 0 ? void 0 : params.index
         });
+        this.systemTypeName = TsRes.Convert.qualifierTypeName
+            .convert('test')
+            .orThrow();
     }
     static create(params) {
         return (0, ts_utils_1.captureResult)(() => new TestQualifierType(params));
@@ -75,6 +78,27 @@ class TestQualifierType extends TsRes.QualifierTypes.QualifierType {
     validateCondition(value, operator) {
         return this.isValidConditionValue(value) ? (0, ts_utils_1.succeed)(value) : (0, ts_utils_1.fail)(`Invalid condition value: ${value}`);
     }
+    getConfigurationJson() {
+        return (0, ts_utils_1.succeed)({
+            name: this.name,
+            systemType: 'test',
+            configuration: {}
+        });
+    }
+    validateConfigurationJson(from) {
+        // Simple validation for test class
+        if (typeof from !== 'object' || from === null) {
+            return (0, ts_utils_1.fail)('Expected object');
+        }
+        const obj = from;
+        if (typeof obj.name !== 'string') {
+            return (0, ts_utils_1.fail)('name must be string');
+        }
+        if (obj.systemType !== 'test') {
+            return (0, ts_utils_1.fail)('systemType must be test');
+        }
+        return (0, ts_utils_1.succeed)(from);
+    }
     _matchOne(condition, context, operator) {
         if (condition === context) {
             return TsRes.PerfectMatch;

package/lib/test/unit/resource-types/derivedResourceType.test.d.ts

@@ -0,0 +1,2 @@
+import '@fgv/ts-utils-jest';
+//# sourceMappingURL=derivedResourceType.test.d.ts.map

package/lib/test/unit/resource-types/testDerivedResourceType.d.ts

@@ -0,0 +1,79 @@
+import { JsonObject, JsonValue } from '@fgv/ts-json-base';
+import { Result } from '@fgv/ts-utils';
+import { CandidateCompleteness, ResourceTypeName, ResourceId, IResourceResolver } from '../../../packlets/common';
+import { IResourceCandidateValidationProperties, ResourceType } from '../../../packlets/resource-types/resourceType';
+import * as ResourceJson from '../../../packlets/resource-json';
+/**
+ * Parameters to create a TestDerivedResourceType instance.
+ */
+export interface ITestDerivedResourceTypeCreateParams {
+    /**
+     * Optional key for the new TestDerivedResourceType instance.
+     * Defaults to 'test-derived'.
+     */
+    key?: string;
+    /**
+     * Optional index for the new TestDerivedResourceType instance.
+     */
+    index?: number;
+    /**
+     * Optional template for new instances.
+     */
+    template?: JsonObject;
+    /**
+     * Optional resource ID to use as a template source.
+     * When provided, the resource resolver will be used to look up
+     * this resource and use its value as the template.
+     */
+    templateResourceId?: string;
+}
+/**
+ * Test data structure for the derived resource type
+ */
+export interface ITestData {
+    title: string;
+    description?: string;
+    metadata?: Record<string, JsonValue>;
+}
+/**
+ * Partial test data structure for the derived resource type
+ */
+export interface IPartialTestData {
+    title?: string;
+    description?: string;
+    metadata?: Record<string, JsonValue>;
+}
+/**
+ * A derived resource type for testing that demonstrates:
+ * 1. Custom validation logic
+ * 2. Using a resource resolver to look up template values
+ * 3. Type-specific defaults and error handling
+ */
+export declare class TestDerivedResourceType extends ResourceType<ITestData> {
+    readonly systemTypeName: ResourceTypeName;
+    private _templateResourceId?;
+    protected constructor(key: ResourceTypeName, index?: number, template?: JsonObject, templateResourceId?: string);
+    /**
+     * Factory method to create a new TestDerivedResourceType instance.
+     */
+    static create(params?: ITestDerivedResourceTypeCreateParams): Result<TestDerivedResourceType>;
+    /**
+     * Validates a resource candidate declaration with custom logic.
+     */
+    validateDeclaration(props: IResourceCandidateValidationProperties): Result<ITestData | IPartialTestData>;
+    /**
+     * Validates JSON for this resource type with custom business logic.
+     */
+    validate(json: JsonValue, completeness: CandidateCompleteness): Result<IPartialTestData>;
+    validate(json: JsonValue, completeness: 'full'): Result<ITestData>;
+    validate(json: JsonValue, completeness: 'partial'): Result<IPartialTestData>;
+    /**
+     * Override to demonstrate looking up template values from another resource.
+     */
+    getDefaultTemplateCandidate(json?: JsonValue, conditions?: ResourceJson.Json.ConditionSetDecl, resolver?: IResourceResolver): Result<ResourceJson.Json.IChildResourceCandidateDecl>;
+    /**
+     * Override createTemplate to add additional validation for the derived type.
+     */
+    createTemplate(resourceId: ResourceId, init?: JsonValue, conditions?: ResourceJson.Json.ConditionSetDecl, resolver?: IResourceResolver): Result<ResourceJson.Json.ILooseResourceDecl>;
+}
+//# sourceMappingURL=testDerivedResourceType.d.ts.map