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

package/README.md

@@ -29,70 +29,46 @@ npm install @fgv/ts-res
 ```typescript
 import * as TsRes from '@fgv/ts-res';
 
-// 1. Set up qualifier types
-const qualifierTypes = TsRes.QualifierTypes.QualifierTypeCollector.create({
-  qualifierTypes: [
-    TsRes.QualifierTypes.LanguageQualifierType.create().orThrow(),
-    TsRes.QualifierTypes.TerritoryQualifierType.create().orThrow()
-  ]
-}).orThrow();
-
-// 2. Define qualifiers with priorities
-const qualifiers = TsRes.Qualifiers.QualifierCollector.create({
-  qualifierTypes,
-  qualifiers: [
-    { name: 'language', typeName: 'language', defaultPriority: 600 },
-    { name: 'territory', typeName: 'territory', defaultPriority: 700 }
-  ]
-}).orThrow();
+// 1. Create a resource manager using predefined configuration
+const manager = TsRes.Resources.ResourceManagerBuilder.createPredefined('default').orThrow();
 
-// 3. Set up resource types
-const resourceTypes = TsRes.ResourceTypes.ResourceTypeCollector.create({
-  resourceTypes: [
-    TsRes.ResourceTypes.JsonResourceType.create().orThrow()
+// 2. Add resources with different language/territory conditions
+manager.addResource({
+  id: 'greeting.message',
+  resourceTypeName: 'json',
+  candidates: [
+    {
+      json: { message: 'Hello' },
+      conditions: { language: 'en' }
+    },
+    {
+      json: { message: 'Bonjour' },
+      conditions: { language: 'fr' }
+    },
+    {
+      json: { message: 'Hello from Canada' },
+      conditions: { 
+        language: 'en-CA',
+        currentTerritory: 'CA'
+      }
+    }
   ]
 }).orThrow();
 
-// 4. Create resource manager
-const manager = TsRes.Resources.ResourceManager.create({
-  qualifiers,
-  resourceTypes
-}).orThrow();
-
-// 5. Add resources
-const resources = [
-  {
-    id: 'greeting.message',
-    json: { message: 'Hello' },
-    conditions: { language: 'en' }
-  },
-  {
-    id: 'greeting.message',
-    json: { message: 'Bonjour' },
-    conditions: { language: 'fr' }
-  },
-  {
-    id: 'greeting.message',
-    json: { message: 'Hello from Canada' },
-    conditions: { 
-      language: 'en-CA',
-      territory: 'CA'
-    }
-  }
-];
-
-resources.forEach(resource => {
-  manager.addLooseCandidate(resource).orThrow();
-});
-
-// 6. Build and resolve resources
+// 3. Build the resource manager to prepare for resolution
 manager.build().orThrow();
 
-const greetingResource = manager.getBuiltResource('greeting.message').orThrow();
-const context = { language: 'en-CA', territory: 'CA' };
-const candidates = greetingResource.getCandidatesForContext(context);
+// 4. Resolve resources for specific contexts
+const resolver = TsRes.ResourceResolver.create(manager).orThrow();
+
+// Get resolver for Canadian English context
+const caResolver = resolver.withContext({ 
+  language: 'en-CA', 
+  currentTerritory: 'CA' 
+}).orThrow();
 
-// Returns the most specific match: "Hello from Canada"
+// Resolve the greeting message - returns: { message: "Hello from Canada" }
+const greeting = caResolver.resolveComposedResourceValue('greeting.message').orThrow();
 ```
 
 ## Core Concepts
@@ -130,35 +106,34 @@ The library automatically selects the most appropriate resource based on:
 ### Resource Building with ResourceBuilder
 
 ```typescript
-const builder = TsRes.Resources.ResourceBuilder.create({
-  qualifiers,
-  resourceTypes
-}).orThrow();
+// Using the resource manager's builder for individual resources
+const manager = TsRes.Resources.ResourceManagerBuilder.createPredefined('default').orThrow();
 
-const resource = builder
-  .withId('user.profile')
-  .withResourceTypeName('json')
-  .withCandidate({
-    json: { title: 'Profile', button: 'Edit' },
-    conditions: { language: 'en' }
-  })
-  .withCandidate({
-    json: { title: 'Profil', button: 'Modifier' },
-    conditions: { language: 'fr' }
-  })
-  .build()
-  .orThrow();
-
-manager.addResource(resource).orThrow();
+manager.addResource({
+  id: 'user.profile',
+  resourceTypeName: 'json',
+  candidates: [
+    {
+      json: { title: 'Profile', button: 'Edit' },
+      conditions: { language: 'en' }
+    },
+    {
+      json: { title: 'Profil', button: 'Modifier' },
+      conditions: { language: 'fr' }
+    }
+  ]
+}).orThrow();
 ```
 
 ### File System Integration
 
 ```typescript
-// Import resources from file system
+// Create a resource manager and import from file system
+const manager = TsRes.Resources.ResourceManagerBuilder.createPredefined('default').orThrow();
+
 const importManager = TsRes.Import.ImportManager.create({
   filetree: fileTree,
-  resources: resourceManager,
+  resources: manager,
   importers: TsRes.Import.ImportManager.getDefaultImporters(),
   initialContext: TsRes.Import.ImportContext.create().orThrow()
 }).orThrow();
@@ -182,16 +157,36 @@ Resources support different merge strategies:
 }
 ```
 
-### Custom Qualifier Types
+### Custom System Configuration
 
 ```typescript
-const customType = TsRes.QualifierTypes.LiteralQualifierType.create({
-  key: 'userType',
-  values: ['admin', 'user', 'guest'],
-  hierarchy: {
-    'admin': ['user', 'guest'],
-    'user': ['guest']
-  }
+// Create a system configuration with custom qualifiers and types
+const customConfig = TsRes.Config.SystemConfiguration.create({
+  name: 'custom-config',
+  description: 'Custom configuration with user types',
+  qualifierTypes: [
+    TsRes.QualifierTypes.LanguageQualifierType.create().orThrow(),
+    TsRes.QualifierTypes.LiteralQualifierType.create({
+      key: 'userType',
+      values: ['admin', 'user', 'guest'],
+      hierarchy: {
+        'admin': ['user', 'guest'],
+        'user': ['guest']
+      }
+    }).orThrow()
+  ],
+  qualifiers: [
+    { name: 'language', typeName: 'language', defaultPriority: 600 },
+    { name: 'userType', typeName: 'userType', defaultPriority: 500 }
+  ],
+  resourceTypes: [
+    TsRes.ResourceTypes.JsonResourceType.create().orThrow()
+  ]
+}).orThrow();
+
+const manager = TsRes.Resources.ResourceManagerBuilder.create({
+  qualifiers: customConfig.qualifiers,
+  resourceTypes: customConfig.resourceTypes
 }).orThrow();
 ```
 
@@ -199,22 +194,26 @@ const customType = TsRes.QualifierTypes.LiteralQualifierType.create({
 
 ### Core Classes
 
-- **ResourceManager**: Central orchestrator for resource operations
+- **ResourceManagerBuilder**: Central builder for resource management systems
+- **ResourceResolver**: Runtime resolver for getting resources in specific contexts
 - **Resource**: Individual resource with candidates for different contexts
 - **ResourceCandidate**: Specific resource variant with conditions
-- **ResourceBuilder**: Builder pattern for constructing resources
-- **QualifierCollector**: Manages qualifier definitions
+- **SystemConfiguration**: Configuration defining qualifiers, types, and defaults
+- **Condition**: Individual condition with qualifier, operator, and value
 - **ConditionSet**: Collection of conditions for resource matching
 
 ### Namespaces
 
-- **Resources**: Core resource management classes
+- **Resources**: Core resource management classes (`ResourceManagerBuilder`, etc.)
+- **Config**: System configuration classes (`SystemConfiguration`, predefined configs)
 - **Qualifiers**: Qualifier definition and management
 - **Conditions**: Condition and condition set management
 - **QualifierTypes**: Built-in and custom qualifier type definitions
 - **Context**: Context definition for resource resolution
 - **Import**: File system and external resource import utilities
 - **ResourceJson**: JSON serialization and deserialization
+- **Bundle**: Resource bundling and deployment utilities
+- **Runtime**: Runtime resolution classes (`ResourceResolver`, etc.)
 
 ## Context Filtering and Qualifier Reduction
 
@@ -299,6 +298,10 @@ const completeBundle = resourceManager.getResourceCollectionDecl().orThrow();
 Filter for a specific environment (e.g., production):
 
 ```typescript
+const resourceManager = TsRes.Resources.ResourceManagerBuilder.createPredefined('default').orThrow();
+// ... add feature flag resources ...
+resourceManager.build().orThrow();
+
 const productionContext = resourceManager.validateContext({ 
   environment: 'production' 
 }).orThrow();
@@ -475,33 +478,58 @@ const result = resource.toLooseResourceDecl({
 ### Web Application Localization
 
 ```typescript
-// Set up for multi-language, multi-region application
-const qualifiers = [
-  { name: 'language', typeName: 'language', defaultPriority: 600 },
-  { name: 'homeTerritory', typeName: 'territory', defaultPriority: 700 },
-  { name: 'currentTerritory', typeName: 'territory', defaultPriority: 800 }
-];
+// Use predefined configuration or create custom one with territories
+const manager = TsRes.Resources.ResourceManagerBuilder.createPredefined('territoryPriority').orThrow();
 
-// Resources with fallback chains
-const resources = [
-  // Default English
-  { id: 'app.title', json: { title: 'My App' }, conditions: { language: 'en' } },
-  // Canadian English variant
-  { id: 'app.title', json: { title: 'My App, eh!' }, conditions: { language: 'en-CA' } },
-  // French
-  { id: 'app.title', json: { title: 'Mon App' }, conditions: { language: 'fr' } }
-];
+manager.addResource({
+  id: 'app.title',
+  resourceTypeName: 'json',
+  candidates: [
+    // Default English
+    { json: { title: 'My App' }, conditions: { language: 'en' } },
+    // Canadian English variant
+    { json: { title: 'My App, eh!' }, conditions: { language: 'en-CA' } },
+    // French
+    { json: { title: 'Mon App' }, conditions: { language: 'fr' } }
+  ]
+}).orThrow();
+
+manager.build().orThrow();
+
+// Create resolver for Canadian user
+const resolver = TsRes.ResourceResolver.create(manager).orThrow();
+const canadianResolver = resolver.withContext({ 
+  language: 'en-CA', 
+  currentTerritory: 'CA' 
+}).orThrow();
+
+const title = canadianResolver.resolveComposedResourceValue('app.title').orThrow();
+// Returns: { title: 'My App, eh!' }
 ```
 
 ### Configuration Management
 
 ```typescript
-// Environment-specific configurations
-const configs = [
-  { id: 'api.config', json: { url: 'localhost:3000' }, conditions: { env: 'development' } },
-  { id: 'api.config', json: { url: 'api.staging.com' }, conditions: { env: 'staging' } },
-  { id: 'api.config', json: { url: 'api.production.com' }, conditions: { env: 'production' } }
-];
+// Create manager with custom environment qualifier
+const manager = TsRes.Resources.ResourceManagerBuilder.createPredefined('default').orThrow();
+
+manager.addResource({
+  id: 'api.config',
+  resourceTypeName: 'json',
+  candidates: [
+    { json: { url: 'localhost:3000' }, conditions: { environment: 'development' } },
+    { json: { url: 'api.staging.com' }, conditions: { environment: 'staging' } },
+    { json: { url: 'api.production.com' }, conditions: { environment: 'production' } }
+  ]
+}).orThrow();
+
+manager.build().orThrow();
+
+// Resolve configuration for production
+const resolver = TsRes.ResourceResolver.create(manager).orThrow();
+const prodResolver = resolver.withContext({ environment: 'production' }).orThrow();
+const config = prodResolver.resolveComposedResourceValue('api.config').orThrow();
+// Returns: { url: 'api.production.com' }
 ```
 
 ## Dependencies
@@ -515,24 +543,32 @@ const configs = [
 
 ## Development
 
+This library is part of a Rush monorepo. Development commands:
+
 ```bash
-# Install dependencies
-npm install
+# Install dependencies (from repository root)
+rush install
 
-# Build the project
-npm run build
+# Build the project 
+rushx build
 
 # Run tests
-npm run test
+rushx test
 
 # Run tests with coverage
-npm run coverage
+rushx coverage
 
 # Lint code
-npm run lint
+rushx lint
+
+# Fix linting issues
+rushx fixlint
+
+# Generate API documentation
+rushx build-docs
 
-# Generate documentation
-npm run build-docs
+# Build project and docs together
+rushx build-all
 ```
 
 ## License

package/dist/ts-res.d.ts

@@ -707,7 +707,8 @@ declare namespace Common {
         ResourceTypeIndex,
         ResourceValueMergeMethod,
         allResourceValueMergeMethods,
-        CandidateCompleteness
+        CandidateCompleteness,
+        IResourceResolver
     }
 }
 
@@ -3828,6 +3829,11 @@ declare interface IJsonResourceTypeCreateParams {
      * instance.
      */
     index?: number;
+    /**
+     * Optional template for new instances of {@link ResourceTypes.JsonResourceType | JsonResourceType}
+     * resources.
+     */
+    template?: JsonObject;
 }
 
 /**
@@ -4960,6 +4966,31 @@ declare interface IResourceManagerCloneOptions extends IResourceDeclarationOptio
     readonly resourceTypes?: ReadOnlyResourceTypeCollector;
 }
 
+/**
+ * Minimal resource resolver
+ * @public
+ */
+export declare interface IResourceResolver {
+    /**
+     * 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>;
+    /**
+     * Creates a new {@link IResourceResolver | resource resolver} with the given context.
+     * @param context - The context to use for the new resource resolver.
+     * @returns `Success` with the new resource resolver if successful,
+     * or `Failure` with an error message if the context is invalid.
+     * @public
+     */
+    withContext(context: Record<string, string>): Result<IResourceResolver>;
+}
+
 /**
  * A listener for {@link Runtime.ResourceResolver | ResourceResolver} cache activity.
  * @public
@@ -5161,11 +5192,14 @@ declare interface IResourceType<T = unknown> extends ICollectible<ResourceTypeNa
     /**
      * Creates a template for a new resource of this type.
      * The template provides a default structure for creating new resource instances.
-     * @param resourceId - The id for the new resource
-     * @returns A loose resource declaration with default values for this resource type
+     * @param resourceId - The id for the new resource.
+     * @param init - An optional initial value for the resource.
+     * @param resolver - An optional resource resolver that can be used to create the template.
+     * @param conditions - An optional set of conditions that must be met for the resource to be selected.
+     * @returns A loose resource declaration with default values for this resource type.
      * @public
      */
-    createTemplate(resourceId: ResourceId): ResourceJson.Json.ILooseResourceDecl;
+    createTemplate(resourceId: ResourceId, init?: JsonValue, conditions?: ResourceJson.Json.ConditionSetDecl, resolver?: IResourceResolver): Result<ResourceJson.Json.ILooseResourceDecl>;
 }
 
 /**
@@ -5175,6 +5209,7 @@ declare interface IResourceType<T = unknown> extends ICollectible<ResourceTypeNa
 declare interface IResourceTypeConfig {
     name: string;
     typeName: string;
+    template?: JsonObject;
 }
 
 /**
@@ -5899,7 +5934,7 @@ declare class JsonResourceType extends ResourceType<JsonObject> {
      * @param key - The key for the new {@link ResourceTypes.JsonResourceType | JsonResourceType} instance.
      * @param index - Optional index for the new {@link ResourceTypes.JsonResourceType | JsonResourceType} instance.
      */
-    protected constructor(key: ResourceTypeName, index?: number);
+    protected constructor(key: ResourceTypeName, index?: number, template?: JsonObject);
     /**
      * Factory method to create a new {@link ResourceTypes.JsonResourceType | JsonResourceType} instance.
      * @param params - {@link ResourceTypes.IJsonResourceTypeCreateParams | Parameters} to create the new instance.
@@ -5923,11 +5958,6 @@ declare class JsonResourceType extends ResourceType<JsonObject> {
      * {@inheritdoc ResourceTypes.ResourceType.(validate:3)}
      */
     validate(json: JsonObject, completeness: 'partial'): Result<JsonObject>;
-    /**
-     * Gets the default template value for a JSON resource type.
-     * @returns An empty object as the default JSON value
-     */
-    protected getDefaultTemplateValue(): JsonObject;
 }
 
 /**
@@ -8163,7 +8193,7 @@ declare const resourceName: Converter<ResourceName, unknown>;
  * 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.
      */
@@ -8180,6 +8210,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
@@ -8264,6 +8298,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.
@@ -8273,6 +8316,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
@@ -8283,6 +8335,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
@@ -8533,6 +8599,7 @@ declare const resourceTreeRootDecl: Converter<Normalized.IResourceTreeRootDecl>;
  */
 export declare abstract class ResourceType<T = unknown> implements IResourceType<T> {
     private _collectible;
+    private _template;
     /**
      * {@inheritdoc ResourceTypes.IResourceType.key}
      */
@@ -8541,7 +8608,7 @@ export declare abstract class ResourceType<T = unknown> implements IResourceType
      * {@inheritdoc ResourceTypes.IResourceType.index}
      */
     get index(): ResourceTypeIndex | undefined;
-    protected constructor(key: ResourceTypeName, index?: number);
+    protected constructor(key: ResourceTypeName, index?: number, template?: JsonObject);
     /**
      * Validates properties of a {@link ResourceJson.Json.ILooseResourceCandidateDecl | resource candidate declaration} for
      * a resource instance value.
@@ -8596,16 +8663,20 @@ export declare abstract class ResourceType<T = unknown> implements IResourceType
      * Default implementation provides a basic template.
      * Subclasses can override to provide type-specific templates.
      * @param resourceId - The id for the new resource
+     * @param init - An optional initial value for the resource.
+     * @param conditions - An optional set of conditions that must be met for the resource to be selected.
+     * @param resolver - An optional resource resolver that can be used to create the template.
      * @returns A loose resource declaration with default values for this resource type
      * @public
      */
-    createTemplate(resourceId: ResourceId): ResourceJson.Json.ILooseResourceDecl;
+    createTemplate(resourceId: ResourceId, init?: JsonValue, conditions?: ResourceJson.Json.ConditionSetDecl, resolver?: IResourceResolver): Result<ResourceJson.Json.ILooseResourceDecl>;
     /**
      * Gets the default template value for this resource type.
      * Subclasses should override this to provide type-specific default values.
      * @returns The default JSON value for a new resource of this type
+     * @public
      */
-    protected getDefaultTemplateValue(): JsonObject;
+    getDefaultTemplateCandidate(json?: JsonValue, conditions?: ResourceJson.Json.ConditionSetDecl, __resolver?: IResourceResolver): Result<ResourceJson.Json.IChildResourceCandidateDecl>;
 }
 
 /**

package/lib/packlets/common/resources.d.ts

@@ -1,4 +1,5 @@
-import { Brand } from '@fgv/ts-utils';
+import { JsonValue } from '@fgv/ts-json-base';
+import { Brand, Result } from '@fgv/ts-utils';
 /**
  * Branded string representing a validated resource id.  A resource ID
  * is a dot-separated sequence of resource names.
@@ -46,4 +47,28 @@ export declare const allResourceValueMergeMethods: ResourceValueMergeMethod[];
  * @public
  */
 export type CandidateCompleteness = 'full' | 'partial';
+/**
+ * Minimal resource resolver
+ * @public
+ */
+export interface IResourceResolver {
+    /**
+     * 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>;
+    /**
+     * Creates a new {@link IResourceResolver | resource resolver} with the given context.
+     * @param context - The context to use for the new resource resolver.
+     * @returns `Success` with the new resource resolver if successful,
+     * or `Failure` with an error message if the context is invalid.
+     * @public
+     */
+    withContext(context: Record<string, string>): Result<IResourceResolver>;
+}
 //# sourceMappingURL=resources.d.ts.map

package/lib/packlets/resource-types/config/convert.js

@@ -24,6 +24,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.resourceTypeConfig = void 0;
 /* eslint-disable @rushstack/typedef-var */
 const ts_utils_1 = require("@fgv/ts-utils");
+const ts_json_base_1 = require("@fgv/ts-json-base");
 /**
  * A `Converter` for {@link ResourceTypes.Config.IResourceTypeConfig | ResourceTypeConfig} objects.
  * @returns A `Converter` for {@link ResourceTypes.Config.IResourceTypeConfig | ResourceTypeConfig} objects.
@@ -31,6 +32,7 @@ const ts_utils_1 = require("@fgv/ts-utils");
  */
 exports.resourceTypeConfig = ts_utils_1.Converters.strictObject({
     name: ts_utils_1.Converters.string,
-    typeName: ts_utils_1.Converters.string
+    typeName: ts_utils_1.Converters.string,
+    template: ts_json_base_1.Converters.jsonObject.optional()
 });
 //# sourceMappingURL=convert.js.map

package/lib/packlets/resource-types/config/json.d.ts

@@ -1,3 +1,4 @@
+import { JsonObject } from '@fgv/ts-json-base';
 /**
  * Configuration for a {@link ResourceTypes.ResourceType | resource type}.
  * @public
@@ -5,5 +6,6 @@
 export interface IResourceTypeConfig {
     name: string;
     typeName: string;
+    template?: JsonObject;
 }
 //# sourceMappingURL=json.d.ts.map

package/lib/packlets/resource-types/jsonResourceType.d.ts

@@ -17,6 +17,11 @@ export interface IJsonResourceTypeCreateParams {
      * instance.
      */
     index?: number;
+    /**
+     * Optional template for new instances of {@link ResourceTypes.JsonResourceType | JsonResourceType}
+     * resources.
+     */
+    template?: JsonObject;
 }
 /**
  * Implementation of a {@link ResourceTypes.ResourceType | ResourceType} for JSON values.
@@ -29,7 +34,7 @@ export declare class JsonResourceType extends ResourceType<JsonObject> {
      * @param key - The key for the new {@link ResourceTypes.JsonResourceType | JsonResourceType} instance.
      * @param index - Optional index for the new {@link ResourceTypes.JsonResourceType | JsonResourceType} instance.
      */
-    protected constructor(key: ResourceTypeName, index?: number);
+    protected constructor(key: ResourceTypeName, index?: number, template?: JsonObject);
     /**
      * Factory method to create a new {@link ResourceTypes.JsonResourceType | JsonResourceType} instance.
      * @param params - {@link ResourceTypes.IJsonResourceTypeCreateParams | Parameters} to create the new instance.
@@ -53,10 +58,5 @@ export declare class JsonResourceType extends ResourceType<JsonObject> {
      * {@inheritdoc ResourceTypes.ResourceType.(validate:3)}
      */
     validate(json: JsonObject, completeness: 'partial'): Result<JsonObject>;
-    /**
-     * Gets the default template value for a JSON resource type.
-     * @returns An empty object as the default JSON value
-     */
-    protected getDefaultTemplateValue(): JsonObject;
 }
 //# sourceMappingURL=jsonResourceType.d.ts.map