@fgv/ts-res 5.1.0-2 → 5.1.0-4

package/dist/packlets/config/common.js

@@ -0,0 +1,78 @@
+/*
+ * 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 { fail } from '@fgv/ts-utils';
+import { SystemConfiguration, updateSystemConfigurationQualifierDefaultValues } from './systemConfiguration';
+import { sanitizeJsonObject } from '@fgv/ts-json-base';
+import { Default, Example } from './predefined';
+/**
+ * An array of all well-known predefined system configurations.
+ * @public
+ */
+export const allPredefinedSystemConfigurations = [
+    'default',
+    'language-priority',
+    'territory-priority',
+    'extended-example'
+];
+export * from './predefined';
+const predefinedDecls = {
+    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, initParams) {
+    if (name in predefinedDecls) {
+        const baseConfig = sanitizeJsonObject(predefinedDecls[name]);
+        if (initParams === null || initParams === void 0 ? void 0 : initParams.qualifierDefaultValues) {
+            return baseConfig.onSuccess((config) => updateSystemConfigurationQualifierDefaultValues(config, initParams.qualifierDefaultValues));
+        }
+        return baseConfig;
+    }
+    /* c8 ignore next 3 - defense in depth */
+    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, initParams) {
+    if (name in predefinedDecls) {
+        return SystemConfiguration.create(predefinedDecls[name], initParams);
+    }
+    return fail(`Unknown predefined system configuration: ${name}`);
+}
+//# sourceMappingURL=common.js.map

package/dist/packlets/config/configInitFactory.js

@@ -0,0 +1,258 @@
+/*
+ * 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 { fail } from '@fgv/ts-utils';
+import * as QualifierTypes from '../qualifier-types';
+import * as ResourceTypes from '../resource-types';
+/**
+ * Creates a {@link Config.IConfigInitFactory | IConfigInitFactory} from a factory function.
+ * @param fn - The factory function to wrap.
+ * @returns An `IConfigInitFactory` instance that delegates to the function.
+ * @public
+ */
+export function createQualifierTypeFactory(fn) {
+    return {
+        create: fn
+    };
+}
+/**
+ * Creates a {@link Config.IConfigInitFactory | IConfigInitFactory} from a resource type factory function.
+ * @param fn - The factory function to wrap.
+ * @returns An `IConfigInitFactory` instance that delegates to the function.
+ * @public
+ */
+export function createResourceTypeFactory(fn) {
+    return {
+        create: fn
+    };
+}
+/**
+ * A factory that chains multiple factories together.
+ * @public
+ */
+export class ChainedConfigInitFactory {
+    /**
+     * Constructor for a chained config init factory.
+     * @param factories - The factories to chain.
+     */
+    constructor(factories) {
+        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.
+     */
+    create(config) {
+        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.SystemQualifierType | SystemQualifierType} from
+ * {@link QualifierTypes.Config.IAnyQualifierTypeConfig | any qualifier type configuration}.
+ * @returns `Success` with the new {@link QualifierTypes.SystemQualifierType | SystemQualifierType}
+ * if successful, `Failure` with an error message otherwise.
+ * @public
+ */
+export class BuiltInQualifierTypeFactory {
+    /** {@inheritDoc Config.IConfigInitFactory.create} */
+    create(config) {
+        if (QualifierTypes.Config.isSystemQualifierTypeConfig(config)) {
+            return QualifierTypes.createQualifierTypeFromSystemConfig(config);
+        }
+        /* c8 ignore next 2 - functional code tested but coverage intermittently missed */
+        return fail(`${config.name}: unknown built-in qualifier type (${config.systemType})`);
+    }
+}
+/**
+ * A factory that creates {@link QualifierTypes.QualifierType | QualifierType} instances from configuration,
+ * supporting both built-in system types and custom external types.
+ *
+ * This factory allows external consumers to extend the qualifier type system with their own custom types
+ * while maintaining support for all built-in types (Language, Territory, Literal).
+ *
+ * @typeParam T - The custom qualifier type(s) to support. Defaults to {@link QualifierTypes.SystemQualifierType | SystemQualifierType}.
+ *
+ * @example Creating a factory with custom qualifier types
+ * ```typescript
+ * // Define a custom qualifier type
+ * class CustomQualifierType extends QualifierType {
+ *   // ... implementation
+ * }
+ *
+ * // Define a discriminated union of all types
+ * type AppQualifierType = SystemQualifierType | CustomQualifierType;
+ *
+ * // Create a factory that handles custom types
+ * const customFactory: IConfigInitFactory<IAnyQualifierTypeConfig, CustomQualifierType> = {
+ *   create(config) {
+ *     // ... handle custom type creation
+ *   }
+ * };
+ *
+ * // Create the combined factory
+ * const qualifierTypeFactory = new QualifierTypeFactory<AppQualifierType>([customFactory]);
+ *
+ * // The factory returns T | SystemQualifierType, supporting all types
+ * const result = qualifierTypeFactory.create(config); // Result<AppQualifierType | SystemQualifierType>
+ * ```
+ *
+ * @remarks
+ * - The factory chains custom factories with the built-in factory
+ * - Custom factories are tried first, falling back to built-in types
+ * - The return type is a union of custom types (T) and system types
+ *
+ * @public
+ */
+export class QualifierTypeFactory extends ChainedConfigInitFactory {
+    /**
+     * Constructor for a {@link Config.QualifierTypeFactory | qualifier type factory}.
+     * @param factories - Array of factories for custom qualifier types. Can be:
+     *                    - {@link Config.IConfigInitFactory | IConfigInitFactory} instances
+     *                    - {@link Config.QualifierTypeFactoryFunction | Factory functions}
+     *                    - A mix of both
+     *                    These are tried in order before falling back to built-in types.
+     * @remarks The {@link Config.BuiltInQualifierTypeFactory | built-in factory} is always appended to handle
+     *          system qualifier types (Language, Territory, Literal).
+     */
+    constructor(factories) {
+        const normalizedFactories = factories.map((f) => typeof f === 'function' ? createQualifierTypeFactory(f) : f);
+        super([...normalizedFactories, new BuiltInQualifierTypeFactory()]);
+    }
+}
+/**
+ * A factory that validates and creates {@link QualifierTypes.QualifierType | QualifierType} instances
+ * from weakly-typed configuration objects. This factory accepts configurations with unvalidated
+ * string properties and validates them before delegating to the underlying factory chain.
+ *
+ * This pattern is useful at package boundaries where type identity issues may occur with
+ * branded types across different package instances.
+ *
+ * @example
+ * ```typescript
+ * // Accept weakly-typed config from external source
+ * const validatingFactory = new ValidatingQualifierTypeFactory([customFactory]);
+ *
+ * // Config can have plain string types instead of branded types
+ * const config = {
+ *   name: 'my-qualifier',  // plain string, not QualifierTypeName
+ *   systemType: 'custom',   // plain string
+ *   configuration: { ... }
+ * };
+ *
+ * const result = validatingFactory.create(config); // Validates and converts internally
+ * ```
+ *
+ * @public
+ */
+export class ValidatingQualifierTypeFactory {
+    /**
+     * Constructor for a validating qualifier type factory.
+     * @param factories - Array of factories for custom qualifier types. Can be:
+     *                    - {@link Config.IConfigInitFactory | IConfigInitFactory} instances
+     *                    - {@link Config.QualifierTypeFactoryFunction | Factory functions}
+     *                    - A mix of both
+     */
+    constructor(factories) {
+        this._innerFactory = new QualifierTypeFactory(factories);
+    }
+    /**
+     * Creates a qualifier type from a weakly-typed configuration object.
+     * @param config - The configuration object to validate and use for creation.
+     * @returns A result containing the new qualifier type if successful.
+     */
+    create(config) {
+        return QualifierTypes.Config.Convert.anyQualifierTypeConfig
+            .convert(config)
+            .onSuccess((validatedConfig) => {
+            return this._innerFactory.create(validatedConfig);
+        });
+    }
+}
+/**
+ * A factory that creates a {@link ResourceTypes.ResourceType | ResourceType} from a {@link ResourceTypes.Config.IResourceTypeConfig | resource type configuration}.
+ * @public
+ */
+export class BuiltInResourceTypeFactory {
+    /** {@inheritDoc Config.IConfigInitFactory.create} */
+    create(config) {
+        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 {
+    /**
+     * Constructor for a resource type factory.
+     * @param factories - Array of factories for resource types. Can be:
+     *                    - {@link Config.IConfigInitFactory | IConfigInitFactory} instances
+     *                    - {@link Config.ResourceTypeFactoryFunction | Factory functions}
+     *                    - A mix of both
+     * @remarks The {@link Config.BuiltInResourceTypeFactory | built-in factory} is always added to the end of the chain.
+     */
+    constructor(factories) {
+        factories = factories !== null && factories !== void 0 ? factories : [];
+        const normalizedFactories = factories.map((f) => typeof f === 'function' ? createResourceTypeFactory(f) : f);
+        super([...normalizedFactories, new BuiltInResourceTypeFactory()]);
+    }
+}
+/**
+ * A factory that validates and creates {@link ResourceTypes.ResourceType | ResourceType} instances
+ * from weakly-typed configuration objects. This factory accepts configurations with unvalidated
+ * string properties and validates them before delegating to the underlying factory chain.
+ *
+ * This pattern is useful at package boundaries where type identity issues may occur with
+ * branded types across different package instances.
+ *
+ * @public
+ */
+export class ValidatingResourceTypeFactory {
+    /**
+     * Constructor for a validating resource type factory.
+     * @param factories - Array of factories for resource types. Can be:
+     *                    - {@link Config.IConfigInitFactory | IConfigInitFactory} instances
+     *                    - {@link Config.ResourceTypeFactoryFunction | Factory functions}
+     *                    - A mix of both
+     */
+    constructor(factories) {
+        this._innerFactory = new ResourceTypeFactory(factories);
+    }
+    /**
+     * Creates a resource type from a weakly-typed configuration object.
+     * @param config - The configuration object to validate and use for creation.
+     * @returns A result containing the new resource type if successful.
+     */
+    create(config) {
+        return ResourceTypes.Config.Convert.resourceTypeConfig.convert(config).onSuccess((validatedConfig) => {
+            return this._innerFactory.create(validatedConfig);
+        });
+    }
+}
+//# sourceMappingURL=configInitFactory.js.map

package/dist/packlets/config/convert.js

@@ -0,0 +1,56 @@
+/*
+ * 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.
+ */
+/* eslint-disable @rushstack/typedef-var */
+import { Converters } from '@fgv/ts-utils';
+import * as QualifierTypes from '../qualifier-types';
+import * as Qualifiers from '../qualifiers';
+import * as ResourceTypes from '../resource-types';
+import { allPredefinedSystemConfigurations } from './common';
+/**
+ * A `Converter` for {@link Config.Model.ISystemConfiguration | ISystemConfiguration} objects.
+ * @returns A `Converter` for {@link Config.Model.ISystemConfiguration | ISystemConfiguration} objects.
+ * @public
+ */
+export const systemConfiguration = Converters.strictObject({
+    name: Converters.optionalString,
+    description: Converters.optionalString,
+    qualifierTypes: Converters.arrayOf(QualifierTypes.Config.Convert.anyQualifierTypeConfig),
+    qualifiers: Converters.arrayOf(Qualifiers.Convert.qualifierDecl),
+    resourceTypes: Converters.arrayOf(ResourceTypes.Config.Convert.resourceTypeConfig)
+});
+/**
+ * A `Converter` for {@link Config.PredefinedSystemConfiguration | PredefinedSystemConfiguration} values.
+ * @returns A `Converter` for {@link Config.PredefinedSystemConfiguration | PredefinedSystemConfiguration} values.
+ * @public
+ */
+export const predefinedSystemConfiguration = Converters.enumeratedValue(allPredefinedSystemConfigurations);
+/**
+ * Validate a {@link Config.Model.ISystemConfiguration | ISystemConfiguration} object.
+ * @param config - The system configuration to validate
+ * @returns `Success` with the validated system configuration if successful,
+ * or `Failure` with an error message if validation fails.
+ * @public
+ */
+export function validateSystemConfiguration(config) {
+    return systemConfiguration.convert(config);
+}
+//# sourceMappingURL=convert.js.map

package/dist/packlets/config/index.browser.js

@@ -0,0 +1,34 @@
+/*
+ * 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.
+ */
+// Browser-safe config exports - excludes Node.js filesystem dependencies
+import * as Model from './json';
+import * as Convert from './convert';
+// Export all modules
+export * from './configInitFactory';
+export * from './common';
+// Export SystemConfiguration class but not as wildcard to avoid pulling in loadFromFile
+export { SystemConfiguration } from './systemConfiguration';
+// Export namespaces
+export { Model, Convert };
+// Excluded from browser:
+// - SystemConfiguration.loadFromFile() method (requires Node.js fs via JsonFile)
+//# sourceMappingURL=index.browser.js.map

package/dist/packlets/config/index.js

@@ -0,0 +1,28 @@
+/*
+ * 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 Model from './json';
+import * as Convert from './convert';
+export * from './configInitFactory';
+export * from './systemConfiguration';
+export * from './common';
+export { Model, Convert };
+//# sourceMappingURL=index.js.map

package/dist/packlets/config/json.js

@@ -0,0 +1,23 @@
+/*
+ * 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 {};
+//# sourceMappingURL=json.js.map

package/dist/packlets/config/predefined/default.js

@@ -0,0 +1,138 @@
+/*
+ * 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.
+ */
+/**
+ * Default qualifier types.
+ * @remarks
+ * The default qualifier types are:
+ * - language: recognizes BCP 47 language tags, accepts a comma-separated list of language tags in the context
+ * - territory: recognizes ISO 3166-1 alpha-2 territory codes, accepts a single code in the context
+ * @public
+ */
+export const DefaultQualifierTypes = [
+    {
+        name: 'language',
+        systemType: 'language',
+        configuration: {
+            allowContextList: true
+        }
+    },
+    {
+        name: 'territory',
+        systemType: 'territory',
+        configuration: {
+            allowContextList: false
+        }
+    }
+];
+/**
+ * Qualifier definitions in which territory is the primary qualifier, with
+ * language as a secondary qualifier.
+ * @remarks
+ * The default qualifiers are:
+ * - currentTerritory(token: geo): territory qualifier, priority 850
+ * - language(token: lang): language qualifier, priority 800
+ * @public
+ */
+export const TerritoryPriorityQualifiers = [
+    {
+        name: 'currentTerritory',
+        token: 'geo',
+        typeName: 'territory',
+        defaultPriority: 850
+    },
+    {
+        name: 'language',
+        token: 'lang',
+        typeName: 'language',
+        defaultPriority: 800
+    }
+];
+/**
+ * Qualifier definitions in which language is the primary qualifier, with
+ * territory as a secondary qualifier.
+ * @remarks
+ * The default qualifiers are:
+ * - language(token: lang): language qualifier, priority 850
+ * - currentTerritory(token: geo): territory qualifier, priority 800
+ * @public
+ */
+export const LanguagePriorityQualifiers = [
+    {
+        name: 'language',
+        token: 'lang',
+        typeName: 'language',
+        defaultPriority: 850
+    },
+    {
+        name: 'currentTerritory',
+        token: 'geo',
+        typeName: 'territory',
+        defaultPriority: 800
+    }
+];
+/**
+ * Default resource types.
+ * @public
+ */
+export const DefaultResourceTypes = [
+    {
+        name: 'json',
+        typeName: 'json'
+    }
+];
+/**
+ * System configuration with territory as the primary qualifier, and
+ * language as a secondary qualifier.
+ * @public
+ */
+export const TerritoryPrioritySystemConfiguration = {
+    name: 'territory-priority',
+    description: 'Territory priority system configuration',
+    qualifierTypes: [...DefaultQualifierTypes],
+    qualifiers: [...TerritoryPriorityQualifiers],
+    resourceTypes: [...DefaultResourceTypes]
+};
+/**
+ * System configuration with language as the primary qualifier, and
+ * territory as a secondary qualifier.
+ * @public
+ */
+export const LanguagePrioritySystemConfiguration = {
+    name: 'language-priority',
+    description: 'Language priority system configuration',
+    qualifierTypes: [...DefaultQualifierTypes],
+    qualifiers: [...LanguagePriorityQualifiers],
+    resourceTypes: [...DefaultResourceTypes]
+};
+/**
+ * The default system configuration gives priority to territory as the primary qualifier,
+ * with language as a secondary qualifier.
+ * @public
+ */
+export const DefaultSystemConfiguration = {
+    name: 'default',
+    description: 'Default system configuration',
+    qualifierTypes: [...DefaultQualifierTypes],
+    qualifiers: [...TerritoryPriorityQualifiers],
+    resourceTypes: [...DefaultResourceTypes]
+};
+//# sourceMappingURL=default.js.map