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

package/src/packlets/conditions/conditionToken.ts

@@ -0,0 +1,180 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import { mapResults, Result, fail, succeed } from '@fgv/ts-utils';
+import { Helpers as CommonHelpers, ConditionOperator } from '../common';
+import { IValidatedConditionDecl } from './conditionDecls';
+import { IReadOnlyQualifierCollector, Qualifier } from '../qualifiers';
+
+/**
+ * Helper class to parse and validate condition tokens.
+ * @public
+ */
+export class ConditionTokens {
+  /**
+   * The {@link Qualifiers.IReadOnlyQualifierCollector | qualifier collector} used to validate
+   * qualifier names and values.
+   */
+  public readonly qualifiers: IReadOnlyQualifierCollector;
+
+  /**
+   * Constructs a new {@link Conditions.ConditionTokens | ConditionTokens } instance.
+   * @param qualifiers - the {@link Qualifiers.IReadOnlyQualifierCollector | qualifier collector} to use
+   */
+  public constructor(qualifiers: IReadOnlyQualifierCollector) {
+    this.qualifiers = qualifiers;
+  }
+
+  /**i
+   * Parses a {@link ConditionToken | condition token} string and validates the parts
+   * against the qualifiers present in the {@link Conditions.ConditionTokens.qualifiers | qualifier collector}.
+   * @param token - the token string to parse.
+   * @returns `Success` with the {@link Conditions.IValidatedConditionDecl | validated condition declaration}
+   * if successful, `Failure` with an error message if not.
+   */
+  public parseConditionToken(token: string): Result<IValidatedConditionDecl> {
+    return ConditionTokens.parseConditionToken(token, this.qualifiers);
+  }
+
+  /**
+   * Parses a {@link ConditionSetToken | condition set token} string and validates the parts
+   * against the qualifiers present in the {@link Conditions.ConditionTokens.qualifiers | qualifier collector}.
+   * @param token - the token string to parse.
+   * @returns `Success` with the array of {@link Conditions.IValidatedConditionDecl | validated condition declarations}
+   * if successful, `Failure` with an error message if not.
+   */
+  public parseConditionSetToken(token: string): Result<IValidatedConditionDecl[]> {
+    return ConditionTokens.parseConditionSetToken(token, this.qualifiers);
+  }
+
+  /**
+   * Validates the {@link Helpers.IConditionTokenParts | parts} of a {@link ConditionToken | condition token}.
+   * @param parts - the parts to validate
+   * @returns `Success` with the validated declaration if successful, `Failure` with an error message if not.
+   */
+  public validateConditionTokenParts(
+    parts: CommonHelpers.IConditionTokenParts
+  ): Result<IValidatedConditionDecl> {
+    return ConditionTokens.validateConditionTokenParts(parts, this.qualifiers);
+  }
+
+  /**
+   * Given a value, finds a single token-optional qualifier that matches the value.
+   * Fails if no qualifiers match, or if more than one qualifier matches.
+   * @param value - the value to match.
+   * @returns `Success` with the matching qualifier if successful, `Failure` with an error message if not.
+   */
+  public findQualifierForValue(value: string): Result<Qualifier> {
+    return ConditionTokens.findQualifierForValue(value, this.qualifiers);
+  }
+
+  /**
+   * Parses a {@link ConditionToken | condition token} and validates it against the qualifiers
+   * present in the supplied {@link Qualifiers.IReadOnlyQualifierCollector | qualifier collector}.
+   * @param token - the token string to parse.
+   * @param qualifiers - the {@link Qualifiers.IReadOnlyQualifierCollector | qualifier collector} to use
+   * @returns `Success` with a {@link Conditions.IValidatedConditionDecl | validated condition declaration} if successful,
+   * `Failure` with an error message if not.
+   */
+  public static parseConditionToken(
+    token: string,
+    qualifiers: IReadOnlyQualifierCollector
+  ): Result<IValidatedConditionDecl> {
+    return CommonHelpers.parseConditionTokenParts(token).onSuccess((parts) => {
+      return ConditionTokens.validateConditionTokenParts(parts, qualifiers);
+    });
+  }
+
+  /**
+   * Parses a {@link ConditionSetToken | condition set token} and validates it against the qualifiers
+   * present in the supplied {@link Qualifiers.IReadOnlyQualifierCollector | qualifier collector}.
+   * @param token - the token string to parse.
+   * @param qualifiers - the {@link Qualifiers.IReadOnlyQualifierCollector | qualifier collector} to use
+   * @returns `Success` with an array of {@link Conditions.IValidatedConditionDecl | validated condition declarations}
+   * if successful, `Failure` with an error message if not
+   */
+  public static parseConditionSetToken(
+    token: string,
+    qualifiers: IReadOnlyQualifierCollector
+  ): Result<IValidatedConditionDecl[]> {
+    return CommonHelpers.parseConditionSetTokenParts(token).onSuccess((parts) => {
+      return mapResults(parts.map((part) => ConditionTokens.validateConditionTokenParts(part, qualifiers)));
+    });
+  }
+
+  /**
+   * Validates the parts of a condition token against the qualifiers present in the supplied
+   * {@link Qualifiers.IReadOnlyQualifierCollector | qualifier collector}.
+   * @param parts - the {@link Helpers.IConditionTokenParts | condition token parts} to validate.
+   * @param qualifiers - the {@link Qualifiers.IReadOnlyQualifierCollector | qualifier collector} used to
+   * validate qualifier names and values.
+   * @returns `Success` with a {@link Conditions.IValidatedConditionDecl | validated condition declaration} if successful,
+   * `Failure` with an error message if not.
+   */
+  public static validateConditionTokenParts(
+    parts: CommonHelpers.IConditionTokenParts,
+    qualifiers: IReadOnlyQualifierCollector
+  ): Result<IValidatedConditionDecl> {
+    const qualifierLookup =
+      parts.qualifier === undefined
+        ? ConditionTokens.findQualifierForValue(parts.value, qualifiers)
+        : qualifiers.getByNameOrToken(parts.qualifier);
+
+    return qualifierLookup.onSuccess((qualifier) => {
+      return qualifier.type
+        .validateCondition(parts.value)
+        .onSuccess((value) => {
+          const operator: ConditionOperator = 'matches';
+          const priority = qualifier.defaultPriority;
+          return succeed({ qualifier, value, operator, priority });
+        })
+        .withDetail('failure', 'success');
+    });
+  }
+
+  /**
+   * Given a value and a set of qualifiers, finds a single token-optional qualifier that matches the value.
+   * Fails if no qualifiers match, or if more than one qualifier matches.
+   * @param value - the value to match.
+   * @param qualifiers - the qualifiers to match against.
+   * @returns `Success` with the matching qualifier if successful, `Failure` with an error message if not.
+   */
+  public static findQualifierForValue(
+    value: string,
+    qualifiers: IReadOnlyQualifierCollector
+  ): Result<Qualifier> {
+    const matched: Qualifier[] = [];
+    for (const qualifier of qualifiers.values()) {
+      if (qualifier.tokenIsOptional && qualifier.validateCondition(value).isSuccess()) {
+        matched.push(qualifier);
+      }
+    }
+    if (matched.length === 0) {
+      return fail(`${value}: does not match any qualifier`);
+    }
+    /* c8 ignore next 3 - functional code path tested but coverage intermittently missed */
+    if (matched.length > 1) {
+      return fail(`${value}: matches multiple qualifiers (${matched.map((q) => q.name).join(', ')})`);
+    }
+    return succeed(matched[0]);
+  }
+}

package/src/packlets/conditions/convert/conditionSetDecls.ts

@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import { Converters, Result, fail, mapResults, succeed } from '@fgv/ts-utils';
+import { IConditionSetDecl, IValidatedConditionSetDecl } from '../conditionSetDecls';
+import { conditionDecl } from './decls';
+import { ConditionCollector } from '../conditionCollector';
+
+/* eslint-disable @rushstack/typedef-var */
+
+/**
+ * Converter which converts to a {@link Conditions.IConditionSetDecl | condition set declaration}.
+ * @public
+ */
+export const conditionSetDecl = Converters.strictObject<IConditionSetDecl>({
+  conditions: Converters.arrayOf(conditionDecl)
+});
+
+/**
+ * Context for converting a {@link Conditions.IConditionSetDecl | condition set declaration}
+ * into an instantiated {@link Conditions.ConditionSet | condition set} object.
+ * @public
+ */
+export interface IConditionSetDeclConvertContext {
+  readonly conditions: ConditionCollector;
+  conditionSetIndex?: number;
+}
+
+/**
+ * Converter which constructs a {@link Conditions.IValidatedConditionSetDecl | validated condition set declaration}
+ * from a {@link Conditions.IConditionSetDecl | condition set declaration}, instantiating qualifiers by name
+ * from a supplied {@link Conditions.Convert.IConditionSetDeclConvertContext | conversion context}.
+ * @public
+ */
+export const validatedConditionSetDecl = Converters.generic<
+  IValidatedConditionSetDecl,
+  IConditionSetDeclConvertContext
+>((from: unknown, __self, context?: IConditionSetDeclConvertContext): Result<IValidatedConditionSetDecl> => {
+  /* c8 ignore next 3 - coverage is having a bad day */
+  if (!context) {
+    return fail('validatedConditionSetDecl converter requires a context');
+  }
+
+  return conditionSetDecl.convert(from).onSuccess((decl) => {
+    return mapResults(
+      decl.conditions.map((condition) => context.conditions.validating.getOrAdd(condition))
+    ).onSuccess((conditions) => {
+      /* c8 ignore next 1 - coverage having issues */
+      const index = context.conditionSetIndex ? context.conditionSetIndex++ : undefined;
+      return succeed({ conditions, index });
+    });
+  });
+});

package/src/packlets/conditions/convert/decls.ts

@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import * as Common from '../../common';
+import { Converters, populateObject, Result, fail, succeed } from '@fgv/ts-utils';
+import { IConditionDecl, IValidatedConditionDecl } from '../conditionDecls';
+import { IReadOnlyQualifierCollector } from '../../qualifiers';
+
+/* eslint-disable @rushstack/typedef-var */
+
+/**
+ * Converter for a {@link Conditions.IConditionDecl | condition declaration}.
+ * @public
+ */
+export const conditionDecl = Converters.strictObject<IConditionDecl>({
+  qualifierName: Converters.string,
+  value: Converters.string,
+  operator: Common.Convert.conditionOperator.optional(),
+  priority: Converters.number.optional(),
+  scoreAsDefault: Converters.number.optional()
+});
+
+/**
+ * Conversion context to uses when converting
+ * a {@link Conditions.IValidatedConditionDecl | validated condition declaration}.
+ * @public
+ */
+export interface IConditionDeclConvertContext {
+  readonly qualifiers: IReadOnlyQualifierCollector;
+  conditionIndex?: number;
+}
+
+/**
+ * Converter which constructs a {@link Conditions.IValidatedConditionDecl | validated condition declaration}
+ * from a {@link Conditions.IConditionDecl | condition declaration}, instantiating qualifiers by name
+ * from a supplied {@link Conditions.Convert.IConditionDeclConvertContext | conversion context}.
+ * @public
+ */
+export const validatedConditionDecl = Converters.generic<
+  IValidatedConditionDecl,
+  IConditionDeclConvertContext
+>((from: unknown, __self, context?: IConditionDeclConvertContext): Result<IValidatedConditionDecl> => {
+  /* c8 ignore next 3 - coverage is having a bad day */
+  if (!context) {
+    return fail('validatedConditionDecl converter requires a context');
+  }
+  return conditionDecl.convert(from).onSuccess((decl) => {
+    const operator = decl.operator ?? 'matches';
+    return context.qualifiers.validating.get(decl.qualifierName).onSuccess((qualifier) => {
+      return populateObject<IValidatedConditionDecl>({
+        qualifier: () => succeed(qualifier),
+        value: () => qualifier.validateCondition(decl.value, operator),
+        operator: () => succeed(operator),
+        priority: () =>
+          decl.priority
+            ? Common.Convert.conditionPriority.convert(decl.priority)
+            : succeed(qualifier.defaultPriority),
+        scoreAsDefault: () =>
+          decl.scoreAsDefault
+            ? Common.Convert.qualifierMatchScore.convert(decl.scoreAsDefault)
+            : succeed(undefined),
+        index: () =>
+          context.conditionIndex
+            ? Common.Convert.conditionIndex.convert(context.conditionIndex)
+            : succeed(undefined)
+      })
+        .onSuccess((result) => {
+          if (context.conditionIndex !== undefined) {
+            context.conditionIndex++;
+          }
+          return succeed(result);
+        })
+        .withDetail('success');
+    });
+  });
+});

package/src/packlets/conditions/convert/index.ts

@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+export * from './decls';
+export * from './conditionSetDecls';

package/src/packlets/conditions/index.ts

@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import * as Convert from './convert';
+
+export * from './condition';
+export * from './conditionCollector';
+export * from './conditionDecls';
+export * from './conditionSet';
+export * from './conditionSetCollector';
+export * from './conditionSetDecls';
+export * from './conditionToken';
+
+export { Convert };

package/src/packlets/config/common.ts

@@ -0,0 +1,107 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import { Result, fail } from '@fgv/ts-utils';
+import { ISystemConfiguration } from './json';
+import {
+  SystemConfiguration,
+  ISystemConfigurationInitParams,
+  updateSystemConfigurationQualifierDefaultValues
+} from './systemConfiguration';
+import { sanitizeJsonObject } from '@fgv/ts-json-base';
+import { Default, Example } from './predefined';
+
+/**
+ * A `string` literal type representing a well-known predefined system configuration.
+ * @public
+ */
+export type PredefinedSystemConfiguration =
+  | 'default'
+  | 'language-priority'
+  | 'territory-priority'
+  | 'extended-example';
+
+/**
+ * An array of all well-known predefined system configurations.
+ * @public
+ */
+export const allPredefinedSystemConfigurations: ReadonlyArray<PredefinedSystemConfiguration> = [
+  'default',
+  'language-priority',
+  'territory-priority',
+  'extended-example'
+];
+
+export * from './predefined';
+
+const predefinedDecls: Record<PredefinedSystemConfiguration, ISystemConfiguration> = {
+  default: Default.DefaultSystemConfiguration,
+  'language-priority': Default.LanguagePrioritySystemConfiguration,
+  'territory-priority': Default.TerritoryPrioritySystemConfiguration,
+  'extended-example': Example.ExtendedSystemConfiguration
+};
+
+/**
+ * Returns the {@link Config.Model.ISystemConfiguration | system configuration} declaration for the
+ * specified predefined system configuration.
+ * @param name - The name of the predefined system configuration.
+ * @param initParams - Optional {@link Config.ISystemConfigurationInitParams | initialization parameters}.
+ * @returns `Success` with the {@link Config.Model.ISystemConfiguration | system configuration}
+ * declaration if successful, `Failure` with an error message otherwise.
+ * @public
+ */
+export function getPredefinedDeclaration(
+  name: PredefinedSystemConfiguration,
+  initParams?: ISystemConfigurationInitParams
+): Result<ISystemConfiguration> {
+  if (name in predefinedDecls) {
+    const baseConfig = sanitizeJsonObject(predefinedDecls[name]);
+    if (initParams?.qualifierDefaultValues) {
+      return baseConfig.onSuccess((config) =>
+        updateSystemConfigurationQualifierDefaultValues(config, initParams.qualifierDefaultValues!)
+      );
+    }
+    return baseConfig;
+  }
+
+  return fail(`Unknown predefined system configuration: ${name}`);
+}
+
+/**
+ * Returns the {@link Config.SystemConfiguration | SystemConfiguration} for the specified
+ * predefined system configuration.
+ * @param name - The name of the predefined system configuration.
+ * @param initParams - Optional {@link Config.ISystemConfigurationInitParams | initialization parameters}.
+ * @returns `Success` with the {@link Config.SystemConfiguration | SystemConfiguration}
+ * if successful, `Failure` with an error message otherwise.
+ * @public
+ */
+export function getPredefinedSystemConfiguration(
+  name: PredefinedSystemConfiguration,
+  initParams?: ISystemConfigurationInitParams
+): Result<SystemConfiguration> {
+  if (name in predefinedDecls) {
+    return SystemConfiguration.create(predefinedDecls[name], initParams);
+  }
+
+  return fail(`Unknown predefined system configuration: ${name}`);
+}

package/src/packlets/config/configInitFactory.ts

@@ -0,0 +1,142 @@
+/*
+ * Copyright (c) 2025 Erik Fortune
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+import { Result, fail } from '@fgv/ts-utils';
+import { QualifierType } from '../qualifier-types';
+import * as QualifierTypes from '../qualifier-types';
+import * as ResourceTypes from '../resource-types';
+import { ResourceType } from '../resource-types';
+/**
+ * Interface for a factory that creates a new instance of a configuration object.
+ * @public
+ */
+export interface IConfigInitFactory<TConfig, T> {
+  /**
+   * Creates a new instance of a configuration object.
+   * @param config - The configuration object to create.
+   * @returns A result containing the new instance of the configuration object.
+   */
+  create(config: TConfig): Result<T>;
+}
+
+/**
+ * A factory that chains multiple factories together.
+ * @public
+ */
+export class ChainedConfigInitFactory<TConfig, T> implements IConfigInitFactory<TConfig, T> {
+  public readonly factories: IConfigInitFactory<TConfig, T>[];
+
+  /**
+   * Constructor for a chained config init factory.
+   * @param factories - The factories to chain.
+   */
+  public constructor(factories: IConfigInitFactory<TConfig, T>[]) {
+    this.factories = factories;
+  }
+
+  /**
+   * Creates a new instance of a configuration object.
+   * @param config - The configuration object to create.
+   * @returns A result containing the new instance of the configuration object.
+   */
+  public create(config: TConfig): Result<T> {
+    for (const factory of this.factories) {
+      const result = factory.create(config);
+      if (result.isSuccess()) {
+        return result;
+      }
+    }
+    return fail('No factory was able to create the configuration object');
+  }
+}
+
+/**
+ * A factory that creates a {@link QualifierTypes.QualifierType | QualifierType} from a {@link QualifierTypes.Config.ISystemQualifierTypeConfig | system qualifier type configuration}.
+ * @public
+ */
+export class BuiltInQualifierTypeFactory
+  implements IConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, QualifierType>
+{
+  /** {@inheritDoc Config.IConfigInitFactory.create} */
+  public create(config: QualifierTypes.Config.IAnyQualifierTypeConfig): Result<QualifierType> {
+    if (QualifierTypes.Config.isSystemQualifierTypeConfig(config)) {
+      return QualifierTypes.createQualifierTypeFromSystemConfig(config);
+    }
+    return fail(`${config.name}: unknown built-in qualifier type (${config.systemType})`);
+  }
+}
+
+/**
+ * A factory that creates a {@link QualifierTypes.QualifierType | QualifierType} from a {@link QualifierTypes.Config.IAnyQualifierTypeConfig | system qualifier type configuration}
+ * by chaining a supplied factory with a {@link Config.BuiltInQualifierTypeFactory | built-in factory} that handles built-in qualifier types.
+ * @public
+ */
+export class QualifierTypeFactory extends ChainedConfigInitFactory<
+  QualifierTypes.Config.IAnyQualifierTypeConfig,
+  QualifierType
+> {
+  /**
+   * Constructor for a {@link Config.QualifierTypeFactory | qualifier type factory}.
+   * @param factories - The {@link Config.IConfigInitFactory | factories} to chain.
+   * @remarks The {@link Config.BuiltInQualifierTypeFactory | built-in factory} is always added to the end of the chain.
+   */
+  public constructor(
+    factories: IConfigInitFactory<QualifierTypes.Config.IAnyQualifierTypeConfig, QualifierType>[]
+  ) {
+    super([...factories, new BuiltInQualifierTypeFactory()]);
+  }
+}
+
+/**
+ * A factory that creates a {@link ResourceTypes.ResourceType | ResourceType} from a {@link ResourceTypes.Config.IResourceTypeConfig | resource type configuration}.
+ * @public
+ */
+export class BuiltInResourceTypeFactory
+  implements IConfigInitFactory<ResourceTypes.Config.IResourceTypeConfig, ResourceType>
+{
+  /** {@inheritDoc Config.IConfigInitFactory.create} */
+  public create(config: ResourceTypes.Config.IResourceTypeConfig): Result<ResourceType> {
+    return ResourceTypes.createResourceTypeFromConfig(config);
+  }
+}
+
+/**
+ * A factory that creates a {@link ResourceTypes.ResourceType | ResourceType} from a {@link ResourceTypes.Config.IResourceTypeConfig | resource type configuration}
+ * by chaining a supplied factory with a {@link Config.BuiltInResourceTypeFactory | built-in factory} that handles built-in resource types.
+ * @public
+ */
+export class ResourceTypeFactory extends ChainedConfigInitFactory<
+  ResourceTypes.Config.IResourceTypeConfig,
+  ResourceType
+> {
+  /**
+   * Constructor for a resource type factory.
+   * @param factories - The {@link Config.IConfigInitFactory | factories}  to chain.
+   * @remarks The {@link Config.BuiltInResourceTypeFactory | built-in factory} is always added to the end of the chain.
+   */
+  public constructor(
+    factories: IConfigInitFactory<ResourceTypes.Config.IResourceTypeConfig, ResourceType>[]
+  ) {
+    factories = factories ?? [];
+    super([...factories, new BuiltInResourceTypeFactory()]);
+  }
+}