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

package/lib/packlets/qualifier-types/qualifierType.d.ts

@@ -1,16 +1,22 @@
 import { Collections, ICollectible, Result } from '@fgv/ts-utils';
 import { ConditionOperator, QualifierConditionValue, QualifierContextValue, QualifierMatchScore, QualifierTypeIndex, QualifierTypeName } from '../common';
+import { JsonCompatible, JsonObject } from '@fgv/ts-json-base';
+import * as Config from './config';
 /**
  * Interface for a qualifier type. A qualifier type implements the build and
  * runtime semantics for some class of related qualifiers (e.g. language,
  * territories, etc).
  * @public
  */
-export interface IQualifierType extends ICollectible<QualifierTypeName, QualifierTypeIndex> {
+export interface IQualifierType<TCFGJSON extends JsonObject = JsonObject> extends ICollectible<QualifierTypeName, QualifierTypeIndex> {
     /**
      * The name of the qualifier type.
      */
     readonly name: QualifierTypeName;
+    /**
+     * Name of the underlying system type.
+     */
+    readonly systemTypeName: QualifierTypeName;
     /**
      * Unique key for this qualifier.
      */
@@ -73,6 +79,17 @@ export interface IQualifierType extends ICollectible<QualifierTypeName, Qualifie
      * Sets the index for this qualifier type. Once set, index is immutable.
      */
     setIndex(index: number): Result<QualifierTypeIndex>;
+    /**
+     * Gets the configuration for this qualifier type.
+     * @returns `Success` with the configuration if successful, `Failure` with an error message otherwise.
+     */
+    getConfigurationJson(): Result<JsonCompatible<Config.IQualifierTypeConfig<TCFGJSON>>>;
+    /**
+     * Validates configuration JSON data for this qualifier type.
+     * @param from - The unknown data to validate as configuration JSON.
+     * @returns `Success` with validated JSON configuration if valid, `Failure` with an error message otherwise.
+     */
+    validateConfigurationJson(from: unknown): Result<JsonCompatible<Config.IQualifierTypeConfig<TCFGJSON>>>;
 }
 /**
  * Parameters used to create a base {@link QualifierTypes.QualifierType | qualifier type}.
@@ -98,11 +115,15 @@ export interface IQualifierTypeCreateParams {
  * the {@link QualifierTypes.IQualifierType | IQualifierType} interface.
  * @public
  */
-export declare abstract class QualifierType implements IQualifierType {
+export declare abstract class QualifierType<TCFGJSON extends JsonObject = JsonObject> implements IQualifierType<TCFGJSON> {
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.name}
      */
     readonly name: QualifierTypeName;
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.systemTypeName}
+     */
+    abstract readonly systemTypeName: QualifierTypeName;
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.key}
      */
@@ -148,6 +169,14 @@ export declare abstract class QualifierType implements IQualifierType {
      * {@inheritdoc QualifierTypes.IQualifierType.matches}
      */
     matches(condition: QualifierConditionValue, context: QualifierContextValue, operator: ConditionOperator): QualifierMatchScore;
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.getConfigurationJson}
+     */
+    abstract getConfigurationJson(): Result<JsonCompatible<Config.IQualifierTypeConfig<TCFGJSON>>>;
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.validateConfigurationJson}
+     */
+    abstract validateConfigurationJson(from: unknown): Result<JsonCompatible<Config.IQualifierTypeConfig<TCFGJSON>>>;
     /**
      * {@inheritdoc QualifierTypes.IQualifierType.setIndex}
      */

package/lib/packlets/qualifier-types/territoryQualifierType.d.ts

@@ -1,8 +1,9 @@
 import { Result } from '@fgv/ts-utils';
-import { QualifierConditionValue, QualifierContextValue, QualifierMatchScore, ConditionOperator } from '../common';
+import { QualifierConditionValue, QualifierContextValue, QualifierMatchScore, ConditionOperator, QualifierTypeName } from '../common';
 import { QualifierType } from './qualifierType';
-import { LiteralValueHierarchy, LiteralValueHierarchyDecl } from './literalValueHierarchy';
+import { LiteralValueHierarchy } from './literalValueHierarchy';
 import * as Config from './config';
+import { JsonCompatible } from '@fgv/ts-json-base';
 /**
  * Parameters used to create a new {@link QualifierTypes.TerritoryQualifierType | TerritoryQualifierType} instance.
  * @public
@@ -30,10 +31,10 @@ export interface ITerritoryQualifierTypeCreateParams {
      */
     acceptLowercase?: boolean;
     /**
-     * Optional {@link QualifierTypes.LiteralValueHierarchyDecl | hierarchy declaration}
+     * Optional {@link QualifierTypes.Config.LiteralValueHierarchyDecl | hierarchy declaration}
      * of territory values to use for matching. If not provided, no hierarchy will be used.
      */
-    hierarchy?: LiteralValueHierarchyDecl<string>;
+    hierarchy?: Config.LiteralValueHierarchyDecl<string>;
 }
 /**
  * Qualifier type for territory values. Territories are two-letter ISO-3166-2
@@ -41,7 +42,11 @@ export interface ITerritoryQualifierTypeCreateParams {
  * implementation handles incorrect casing.
  * @public
  */
-export declare class TerritoryQualifierType extends QualifierType {
+export declare class TerritoryQualifierType extends QualifierType<JsonCompatible<Config.ITerritoryQualifierTypeConfig>> {
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.systemTypeName}
+     */
+    readonly systemTypeName: QualifierTypeName;
     /**
      * Optional array enumerating allowed territories to further constrain the type.
      */
@@ -83,6 +88,27 @@ export declare class TerritoryQualifierType extends QualifierType {
      * @public
      */
     static createFromConfig(config: Config.IQualifierTypeConfig<Config.ITerritoryQualifierTypeConfig>): Result<TerritoryQualifierType>;
+    /**
+     * Gets the {@link QualifierTypes.Config.ISystemTerritoryQualifierTypeConfig | strongly typed configuration}
+     * for this qualifier type.
+     * @returns `Success` with the configuration if successful, `Failure` with an error message otherwise.
+     */
+    getConfiguration(): Result<Config.ISystemTerritoryQualifierTypeConfig>;
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.getConfigurationJson}
+     */
+    getConfigurationJson(): Result<JsonCompatible<Config.ISystemTerritoryQualifierTypeConfig>>;
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.validateConfigurationJson}
+     */
+    validateConfigurationJson(from: unknown): Result<JsonCompatible<Config.ISystemTerritoryQualifierTypeConfig>>;
+    /**
+     * Validates a {@link QualifierTypes.Config.ISystemTerritoryQualifierTypeConfig | strongly typed configuration object}
+     * for this qualifier type.
+     * @param from - The unknown data to validate as a configuration object.
+     * @returns `Success` with the validated configuration if successful, `Failure` with an error message otherwise.
+     */
+    validateConfiguration(from: unknown): Result<Config.ISystemTerritoryQualifierTypeConfig>;
     /**
      * {@inheritdoc QualifierTypes.QualifierType._matchOne}
      */

package/lib/packlets/qualifier-types/territoryQualifierType.js

@@ -20,12 +20,46 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TerritoryQualifierType = void 0;
 const ts_utils_1 = require("@fgv/ts-utils");
 const common_1 = require("../common");
 const qualifierType_1 = require("./qualifierType");
 const literalValueHierarchy_1 = require("./literalValueHierarchy");
+const Config = __importStar(require("./config"));
 const ts_json_base_1 = require("@fgv/ts-json-base");
 /**
  * Qualifier type for territory values. Territories are two-letter ISO-3166-2
@@ -51,6 +85,12 @@ class TerritoryQualifierType extends qualifierType_1.QualifierType {
             allowContextList,
             index: validIndex
         });
+        /**
+         * {@inheritdoc QualifierTypes.IQualifierType.systemTypeName}
+         */
+        this.systemTypeName = common_1.Convert.qualifierTypeName
+            .convert('territory')
+            .orThrow();
         this.allowedTerritories = validTerritories;
         this.acceptLowercase = acceptLowercase === true;
         if (hierarchy) {
@@ -66,6 +106,7 @@ class TerritoryQualifierType extends qualifierType_1.QualifierType {
      */
     isValidConditionValue(value) {
         const normalized = this.acceptLowercase ? value.toUpperCase() : value;
+        /* c8 ignore next 6 - edge case: invalid territory values and allowed territory filtering rarely hit */
         if (!TerritoryQualifierType.isValidTerritoryConditionValue(normalized)) {
             return false;
         }
@@ -106,6 +147,43 @@ class TerritoryQualifierType extends qualifierType_1.QualifierType {
             hierarchy: territoryConfig.hierarchy
         }).onSuccess(TerritoryQualifierType.create);
     }
+    /**
+     * Gets the {@link QualifierTypes.Config.ISystemTerritoryQualifierTypeConfig | strongly typed configuration}
+     * for this qualifier type.
+     * @returns `Success` with the configuration if successful, `Failure` with an error message otherwise.
+     */
+    getConfiguration() {
+        return this.getConfigurationJson().onSuccess((json) => Config.Convert.systemTerritoryQualifierTypeConfig.convert(json));
+    }
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.getConfigurationJson}
+     */
+    getConfigurationJson() {
+        const hierarchy = this.hierarchy ? { hierarchy: this.hierarchy.asRecord() } : {};
+        const allowedTerritories = this.allowedTerritories
+            ? { allowedTerritories: [...this.allowedTerritories] }
+            : {};
+        return (0, ts_utils_1.succeed)({
+            name: this.name,
+            systemType: 'territory',
+            configuration: Object.assign(Object.assign({ allowContextList: this.allowContextList, acceptLowercase: this.acceptLowercase }, allowedTerritories), hierarchy)
+        });
+    }
+    /**
+     * {@inheritdoc QualifierTypes.IQualifierType.validateConfigurationJson}
+     */
+    validateConfigurationJson(from) {
+        return Config.Convert.systemTerritoryQualifierTypeConfig.convert(from);
+    }
+    /**
+     * Validates a {@link QualifierTypes.Config.ISystemTerritoryQualifierTypeConfig | strongly typed configuration object}
+     * for this qualifier type.
+     * @param from - The unknown data to validate as a configuration object.
+     * @returns `Success` with the validated configuration if successful, `Failure` with an error message otherwise.
+     */
+    validateConfiguration(from) {
+        return this.validateConfigurationJson(from).onSuccess((json) => Config.Convert.systemTerritoryQualifierTypeConfig.convert(json));
+    }
     /**
      * {@inheritdoc QualifierTypes.QualifierType._matchOne}
      */
@@ -117,6 +195,7 @@ class TerritoryQualifierType extends qualifierType_1.QualifierType {
             if (normalizedCondition === normalizedContext) {
                 return common_1.PerfectMatch;
             }
+            /* c8 ignore next 8 - edge case: hierarchy matching and fallback logic rarely used */
             if (this.hierarchy) {
                 return this.hierarchy.match(normalizedCondition, normalizedContext, __operator);
             }
@@ -132,6 +211,7 @@ class TerritoryQualifierType extends qualifierType_1.QualifierType {
      * @public
      */
     static isValidTerritoryConditionValue(value, acceptLowercase) {
+        /* c8 ignore next 3 - edge case: lowercase validation rarely fails */
         if (acceptLowercase !== true && value !== value.toUpperCase()) {
             return false;
         }

package/lib/packlets/qualifiers/qualifierCollector.js

@@ -144,12 +144,11 @@ class QualifierCollector extends ts_utils_1.ValidatingConvertingCollector {
         return convert_1.validatedQualifierDecl
             .convert(decl, convertContext)
             .onSuccess((validated) => {
+            /* c8 ignore next 9 - coverage intermittently misses this block */
             if (this.hasNameOrToken(validated.token)) {
-                /* c8 ignore next 3 - functional error case tested but coverage intermittently missed */
                 return (0, ts_utils_1.fail)(`Qualifier token '${validated.token}' is not unique or collides with name`);
             }
             else if (this.hasNameOrToken(validated.name)) {
-                /* c8 ignore next 4 - functional error case tested but coverage intermittently missed */
                 return (0, ts_utils_1.fail)(`Qualifier name '${validated.name}' is not unique or collides with token`);
             }
             return (0, ts_utils_1.succeed)(validated);

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

@@ -136,7 +136,7 @@ exports.compiledAbstractDecision = ts_utils_1.Converters.strictObject({
  * @public
  */
 exports.compiledCandidate = ts_utils_1.Converters.strictObject({
-    json: ts_json_base_1.Converters.jsonValue,
+    valueIndex: Common.Convert.candidateValueIndex,
     isPartial: ts_utils_1.Converters.boolean,
     mergeMethod: Common.Convert.resourceValueMergeMethod
 });
@@ -162,6 +162,7 @@ exports.compiledResourceCollection = ts_utils_1.Converters.strictObject({
     conditions: ts_utils_1.Converters.arrayOf(exports.compiledCondition),
     conditionSets: ts_utils_1.Converters.arrayOf(exports.compiledConditionSet),
     decisions: ts_utils_1.Converters.arrayOf(exports.compiledAbstractDecision),
+    candidateValues: ts_utils_1.Converters.arrayOf(ts_json_base_1.Converters.jsonValue),
     resources: ts_utils_1.Converters.arrayOf(exports.compiledResource)
 });
 //# sourceMappingURL=convert.js.map

package/lib/packlets/resource-json/compiled/json.d.ts

@@ -132,9 +132,9 @@ export interface ICompiledAbstractDecision {
  */
 export interface ICompiledCandidate {
     /**
-     * The JSON value of the candidate.
+     * The global index of the JSON value of the candidate.
      */
-    json: JsonValue;
+    valueIndex: Common.CandidateValueIndex;
     /**
      * Indicates if this is a partial resource that needs to be merged.
      */
@@ -196,6 +196,10 @@ export interface ICompiledResourceCollection {
      * Array of all decisions in the collection.
      */
     decisions: ReadonlyArray<ICompiledAbstractDecision>;
+    /**
+     * Array of all candidate values in the collection.
+     */
+    candidateValues: ReadonlyArray<JsonValue>;
     /**
      * Array of all resources in the collection.
      */

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

@@ -4,5 +4,5 @@ import { IResourceTypeConfig } from './json';
  * @returns A `Converter` for {@link ResourceTypes.Config.IResourceTypeConfig | ResourceTypeConfig} objects.
  * @public
  */
-export declare const resourceTypeConfig: import("@fgv/ts-utils").ObjectConverter<IResourceTypeConfig, unknown>;
+export declare const resourceTypeConfig: import("@fgv/ts-utils").ObjectConverter<IResourceTypeConfig<import("@fgv/ts-json-base").JsonObject>, unknown>;
 //# sourceMappingURL=convert.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,9 +1,11 @@
+import { JsonObject } from '@fgv/ts-json-base';
 /**
  * Configuration for a {@link ResourceTypes.ResourceType | resource type}.
  * @public
  */
-export interface IResourceTypeConfig {
+export interface IResourceTypeConfig<T extends JsonObject = JsonObject> {
     name: string;
     typeName: string;
+    template?: T;
 }
 //# sourceMappingURL=json.d.ts.map

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

@@ -17,19 +17,28 @@ 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.
  * @public
  */
 export declare class JsonResourceType extends ResourceType<JsonObject> {
+    /**
+     * {@inheritdoc ResourceTypes.ResourceType.systemTypeName}
+     */
+    readonly systemTypeName: ResourceTypeName;
     /**
      * Protected {@link ResourceTypes.JsonResourceType | JsonResourceType} constructor for use by subclasses.
      * Use {@link ResourceTypes.JsonResourceType.create | JsonResourceType.create} to create a new instance.
      * @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.

package/lib/packlets/resource-types/jsonResourceType.js

@@ -37,8 +37,12 @@ class JsonResourceType extends resourceType_1.ResourceType {
      * @param key - The key for the new {@link ResourceTypes.JsonResourceType | JsonResourceType} instance.
      * @param index - Optional index for the new {@link ResourceTypes.JsonResourceType | JsonResourceType} instance.
      */
-    constructor(key, index) {
-        super(key, index);
+    constructor(key, index, template) {
+        super(key, index, template);
+        /**
+         * {@inheritdoc ResourceTypes.ResourceType.systemTypeName}
+         */
+        this.systemTypeName = common_1.Convert.resourceTypeName.convert('json').orThrow();
     }
     /**
      * Factory method to create a new {@link ResourceTypes.JsonResourceType | JsonResourceType} instance.
@@ -49,7 +53,7 @@ class JsonResourceType extends resourceType_1.ResourceType {
     static create(params) {
         var _a;
         return common_1.Convert.resourceTypeName.convert((_a = params === null || params === void 0 ? void 0 : params.key) !== null && _a !== void 0 ? _a : 'json').onSuccess((key) => {
-            return (0, ts_utils_1.captureResult)(() => new JsonResourceType(key, params === null || params === void 0 ? void 0 : params.index));
+            return (0, ts_utils_1.captureResult)(() => new JsonResourceType(key, params === null || params === void 0 ? void 0 : params.index, params === null || params === void 0 ? void 0 : params.template));
         });
     }
     /**

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

@@ -1,6 +1,7 @@
-import { JsonValue } from '@fgv/ts-json-base';
+import { JsonObject, JsonValue } from '@fgv/ts-json-base';
 import { ICollectible, Result } from '@fgv/ts-utils';
-import { CandidateCompleteness, ResourceTypeIndex, ResourceTypeName, ResourceValueMergeMethod, ResourceId } from '../common';
+import { CandidateCompleteness, ResourceTypeIndex, ResourceTypeName, ResourceValueMergeMethod, ResourceId, IResourceResolver } from '../common';
+import * as ResourceJson from '../resource-json';
 /**
  * Parameters used to validate a {@link ResourceJson.Json.ILooseResourceCandidateDecl | resource candidate declaration}.
  * @public
@@ -12,10 +13,10 @@ export interface IResourceCandidateValidationProperties {
      */
     id: ResourceId;
     /**
-     * {@inheritdoc ResourceJson.Json.ILooseResourceCandidateDecl.isPartial}
+     * Describes how complete the candidate value is.
      * @public
      */
-    isPartial: boolean;
+    completeness: CandidateCompleteness;
     /**
      * {@inheritdoc ResourceJson.Json.ILooseResourceCandidateDecl.json}
      * @public
@@ -27,23 +28,95 @@ export interface IResourceCandidateValidationProperties {
      */
     mergeMethod: ResourceValueMergeMethod;
 }
+/**
+ * Interface for a resource type.  Resource types are responsible for
+ * validating and converting JSON values into the appropriate strongly-typed
+ * resource value.
+ * @public
+ */
+export interface IResourceType<T = unknown> extends ICollectible<ResourceTypeName, ResourceTypeIndex> {
+    /**
+     * The key for this resource type.
+     */
+    readonly key: ResourceTypeName;
+    /**
+     * The index for this resource type.
+     */
+    readonly index: ResourceTypeIndex | undefined;
+    /**
+     * Validates properties of a {@link ResourceJson.Json.ILooseResourceCandidateDecl | resource candidate declaration} for
+     * a resource instance value.
+     * @param props - The {@link ResourceTypes.IResourceCandidateValidationProperties | properties } to validate.
+     * @returns `Success` with the strongly-typed resource value if the JSON and merge method
+     * are valid, `Failure` with an error message otherwise.
+     * @public
+     */
+    validateDeclaration(props: IResourceCandidateValidationProperties): Result<T | Partial<T>>;
+    /**
+     * Validates a JSON value for use as a partial resource instance value.
+     * @param json - The JSON value to validate.
+     * @param completeness - Describes {@link CandidateCompleteness | how complete} the candidate value is.
+     * @returns `Success` with the strongly-typed partial resource value if the JSON is valid,
+     * `Failure` with an error message otherwise.
+     * @public
+     */
+    validate(json: JsonValue, completeness: CandidateCompleteness): Result<Partial<T>>;
+    /**
+     * Validates a JSON value for use as a complete resource instance value.
+     * @param json - The JSON value to validate.
+     * @param completeness - Describes {@link CandidateCompleteness | how complete} the candidate value is.
+     * @returns `Success` with the strongly-typed resource value if the JSON is valid,
+     * `Failure` with an error message otherwise.
+     * @public
+     */
+    validate(json: JsonValue, completeness: 'full'): Result<T>;
+    /**
+     * Validates a JSON value for use as a partial resource instance value.
+     * @param json - The JSON value to validate.
+     * @param completeness - Describes {@link CandidateCompleteness | how complete} the candidate value is.
+     * @returns `Success` with the strongly-typed partial resource value if the JSON is valid,
+     * `Failure` with an error message otherwise.
+     * @public
+     */
+    validate(json: JsonValue, completeness: 'partial'): Result<Partial<T>>;
+    /**
+     * Sets the index for this resource type.  Once set, the index cannot be changed.
+     */
+    setIndex(index: number): Result<ResourceTypeIndex>;
+    /**
+     * 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.
+     * @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, init?: JsonValue, conditions?: ResourceJson.Json.ConditionSetDecl, resolver?: IResourceResolver): Result<ResourceJson.Json.ILooseResourceDecl>;
+}
 /**
  * Abstract base class for resource types which are responsible for
  * validating and converting JSON values into the appropriate strongly-typed
  * resource value.
  * @public
  */
-export declare abstract class ResourceType<T = unknown> implements ICollectible<ResourceTypeName, ResourceTypeIndex> {
+export declare abstract class ResourceType<T = unknown> implements IResourceType<T> {
     private _collectible;
+    private _template;
     /**
-     * The key for this resource type.
+     * {@inheritdoc ResourceTypes.IResourceType.key}
      */
     get key(): ResourceTypeName;
     /**
-     * The index for this resource type.
+     * Name of the underlying system type.
+     */
+    abstract readonly systemTypeName: ResourceTypeName;
+    /**
+     * {@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.
@@ -93,5 +166,24 @@ export declare abstract class ResourceType<T = unknown> implements ICollectible<
      * Sets the index for this resource type.  Once set, the index cannot be changed.
      */
     setIndex(index: number): Result<ResourceTypeIndex>;
+    /**
+     * Creates a template for a new resource of this type.
+     * 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, 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
+     */
+    getDefaultTemplateCandidate(json?: JsonValue, conditions?: ResourceJson.Json.ConditionSetDecl, __resolver?: IResourceResolver): Result<ResourceJson.Json.IChildResourceCandidateDecl>;
 }
 //# sourceMappingURL=resourceType.d.ts.map

package/lib/packlets/resource-types/resourceType.js

@@ -22,6 +22,7 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ResourceType = void 0;
+const ts_json_base_1 = require("@fgv/ts-json-base");
 const ts_utils_1 = require("@fgv/ts-utils");
 const common_1 = require("../common");
 /**
@@ -32,24 +33,25 @@ const common_1 = require("../common");
  */
 class ResourceType {
     /**
-     * The key for this resource type.
+     * {@inheritdoc ResourceTypes.IResourceType.key}
      */
     get key() {
         return this._collectible.key;
     }
     /**
-     * The index for this resource type.
+     * {@inheritdoc ResourceTypes.IResourceType.index}
      */
     get index() {
         return this._collectible.index;
     }
-    constructor(key, index) {
+    constructor(key, index, template) {
         this._collectible = new ts_utils_1.Collections.Collectible({
             key,
             /* c8 ignore next 1 - coverage having a rough time */
             index: index !== undefined ? common_1.Validate.toResourceTypeIndex(index).orThrow() : undefined,
             indexConverter: common_1.Convert.resourceTypeIndex
         });
+        this._template = template !== null && template !== void 0 ? template : {};
     }
     /**
      * Sets the index for this resource type.  Once set, the index cannot be changed.
@@ -57,6 +59,40 @@ class ResourceType {
     setIndex(index) {
         return this._collectible.setIndex(index);
     }
+    /**
+     * Creates a template for a new resource of this type.
+     * 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, init, conditions, resolver) {
+        return this.getDefaultTemplateCandidate(init, conditions, resolver).onSuccess((candidate) => (0, ts_utils_1.succeed)({
+            id: resourceId,
+            resourceTypeName: this.key,
+            candidates: [candidate]
+        }));
+    }
+    /**
+     * 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
+     */
+    getDefaultTemplateCandidate(json, conditions, __resolver) {
+        json = json !== null && json !== void 0 ? json : this._template;
+        if (!(0, ts_json_base_1.isJsonObject)(json)) {
+            return (0, ts_utils_1.fail)(`${this.key}: Invalid initial value "${json}" must be JSON object.`);
+        }
+        const candidate = Object.assign(Object.assign({ json }, (conditions ? { conditions } : {})), { mergeMethod: 'replace' });
+        return this.validate(json, 'full')
+            .onSuccess((json) => (0, ts_utils_1.succeed)(Object.assign(Object.assign({}, candidate), { isPartial: false })))
+            .onFailure(() => this.validate(json, 'partial').onSuccess((json) => (0, ts_utils_1.succeed)(Object.assign(Object.assign({}, candidate), { isPartial: true }))));
+    }
 }
 exports.ResourceType = ResourceType;
 //# sourceMappingURL=resourceType.js.map