@edumalin/platform 3.0.0

package/dist/cjs/environment/provider/is-platform-environment-provider.d.ts

@@ -0,0 +1,2 @@
+import { type PlatformEnvironmentProvider } from './platform-environment-provider.js';
+export declare function isPlatformEnvironmentProvider(value: unknown): value is PlatformEnvironmentProvider;

package/dist/cjs/environment/provider/is-platform-environment-provider.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPlatformEnvironmentProvider = isPlatformEnvironmentProvider;
+const platform_environment_providers_js_1 = require("./platform-environment-providers.js");
+function isPlatformEnvironmentProvider(value) {
+    return typeof value === 'string' && set.has(value);
+}
+const set = new Set(platform_environment_providers_js_1.platformEnvironmentProviders);

package/dist/cjs/environment/provider/platform-environment-provider.d.ts

@@ -0,0 +1,2 @@
+import { type platformEnvironmentProviders } from './platform-environment-providers.js';
+export type PlatformEnvironmentProvider = (typeof platformEnvironmentProviders)[number];

package/dist/cjs/environment/provider/platform-environment-provider.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/environment/provider/platform-environment-providers.d.ts

@@ -0,0 +1 @@
+export declare const platformEnvironmentProviders: readonly ["aws", "azure", "gcp", "local", "scaleway"];

package/dist/cjs/environment/provider/platform-environment-providers.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.platformEnvironmentProviders = void 0;
+exports.platformEnvironmentProviders = ['aws', 'azure', 'gcp', 'local', 'scaleway'];

package/dist/cjs/environment/provider/validate-platform-environment-provider.d.ts

@@ -0,0 +1,2 @@
+import { type PlatformEnvironmentProvider } from './platform-environment-provider.js';
+export declare function validatePlatformEnvironmentProvider(value: unknown): asserts value is PlatformEnvironmentProvider;

package/dist/cjs/environment/provider/validate-platform-environment-provider.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validatePlatformEnvironmentProvider = validatePlatformEnvironmentProvider;
+const environment_error_js_1 = require("../environment.error.js");
+const is_platform_environment_provider_js_1 = require("./is-platform-environment-provider.js");
+function validatePlatformEnvironmentProvider(value) {
+    if (!(0, is_platform_environment_provider_js_1.isPlatformEnvironmentProvider)(value)) {
+        throw environment_error_js_1.environmentError.invalidPlatformEnvironmentProvider({ value });
+    }
+}

package/dist/cjs/environment/region/as-platform-environment-region.d.ts

@@ -0,0 +1,2 @@
+import { type PlatformEnvironmentRegion } from './platform-environment-region.js';
+export declare function asPlatformEnvironmentRegion(value: unknown): PlatformEnvironmentRegion;

package/dist/cjs/environment/region/as-platform-environment-region.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asPlatformEnvironmentRegion = asPlatformEnvironmentRegion;
+const validate_platform_environment_region_js_1 = require("./validate-platform-environment-region.js");
+function asPlatformEnvironmentRegion(value) {
+    (0, validate_platform_environment_region_js_1.validatePlatformEnvironmentRegion)(value);
+    return value;
+}

package/dist/cjs/environment/region/is-platform-environment-region.d.ts

@@ -0,0 +1,2 @@
+import { type PlatformEnvironmentRegion } from './platform-environment-region.js';
+export declare function isPlatformEnvironmentRegion(value: unknown): value is PlatformEnvironmentRegion;

package/dist/cjs/environment/region/is-platform-environment-region.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPlatformEnvironmentRegion = isPlatformEnvironmentRegion;
+const platform_environment_regions_js_1 = require("./platform-environment-regions.js");
+function isPlatformEnvironmentRegion(value) {
+    return typeof value === 'string' && regions.has(value);
+}
+const regions = new Set(platform_environment_regions_js_1.platformEnvironmentRegions);

package/dist/cjs/environment/region/platform-environment-region.d.ts

@@ -0,0 +1,2 @@
+import { type platformEnvironmentRegions } from './platform-environment-regions.js';
+export type PlatformEnvironmentRegion = (typeof platformEnvironmentRegions)[number];

package/dist/cjs/environment/region/platform-environment-region.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/environment/region/platform-environment-regions.d.ts

@@ -0,0 +1 @@
+export declare const platformEnvironmentRegions: readonly ["af-paas", "as-paas", "eu-france", "eu-paas", "na-paas", "local", "sa-paas"];

package/dist/cjs/environment/region/platform-environment-regions.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.platformEnvironmentRegions = void 0;
+exports.platformEnvironmentRegions = [
+    'af-paas',
+    'as-paas',
+    'eu-france',
+    'eu-paas',
+    'na-paas',
+    'local',
+    'sa-paas',
+];

package/dist/cjs/environment/region/validate-platform-environment-region.d.ts

@@ -0,0 +1,2 @@
+import { type PlatformEnvironmentRegion } from './platform-environment-region.js';
+export declare function validatePlatformEnvironmentRegion(value: unknown): asserts value is PlatformEnvironmentRegion;

package/dist/cjs/environment/region/validate-platform-environment-region.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validatePlatformEnvironmentRegion = validatePlatformEnvironmentRegion;
+const environment_error_js_1 = require("../environment.error.js");
+const is_platform_environment_region_js_1 = require("./is-platform-environment-region.js");
+function validatePlatformEnvironmentRegion(value) {
+    if (!(0, is_platform_environment_region_js_1.isPlatformEnvironmentRegion)(value)) {
+        throw environment_error_js_1.environmentError.invalidPlatformEnvironmentRegion({ value });
+    }
+}

package/dist/cjs/environment/type/as-platform-environment-type.d.ts

@@ -0,0 +1,2 @@
+import { type PlatformEnvironmentType } from './platform-environment-type.js';
+export declare function asPlatformEnvironmentType(value: unknown): PlatformEnvironmentType;

package/dist/cjs/environment/type/as-platform-environment-type.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asPlatformEnvironmentType = asPlatformEnvironmentType;
+const validate_platform_environment_type_js_1 = require("./validate-platform-environment-type.js");
+function asPlatformEnvironmentType(value) {
+    (0, validate_platform_environment_type_js_1.validatePlatformEnvironmentType)(value);
+    return value;
+}

package/dist/cjs/environment/type/is-platform-environment-type.d.ts

@@ -0,0 +1,2 @@
+import { type PlatformEnvironmentType } from './platform-environment-type.js';
+export declare function isPlatformEnvironmentType(value: unknown): value is PlatformEnvironmentType;

package/dist/cjs/environment/type/is-platform-environment-type.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPlatformEnvironmentType = isPlatformEnvironmentType;
+const platform_environment_types_js_1 = require("./platform-environment-types.js");
+function isPlatformEnvironmentType(value) {
+    return typeof value === 'string' && set.has(value);
+}
+const set = new Set(platform_environment_types_js_1.platformEnvironmentTypes);

package/dist/cjs/environment/type/platform-environment-type.d.ts

@@ -0,0 +1,2 @@
+import { type platformEnvironmentTypes } from './platform-environment-types.js';
+export type PlatformEnvironmentType = (typeof platformEnvironmentTypes)[number];

package/dist/cjs/environment/type/platform-environment-type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/environment/type/platform-environment-types.d.ts

@@ -0,0 +1 @@
+export declare const platformEnvironmentTypes: readonly ["development", "local", "production", "staging"];

package/dist/cjs/environment/type/platform-environment-types.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.platformEnvironmentTypes = void 0;
+exports.platformEnvironmentTypes = ['development', 'local', 'production', 'staging'];

package/dist/cjs/environment/type/validate-platform-environment-type.d.ts

@@ -0,0 +1,2 @@
+import { type PlatformEnvironmentType } from './platform-environment-type.js';
+export declare function validatePlatformEnvironmentType(value: unknown): asserts value is PlatformEnvironmentType;

package/dist/cjs/environment/type/validate-platform-environment-type.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validatePlatformEnvironmentType = validatePlatformEnvironmentType;
+const environment_error_js_1 = require("../environment.error.js");
+const is_platform_environment_type_js_1 = require("./is-platform-environment-type.js");
+function validatePlatformEnvironmentType(value) {
+    if (!(0, is_platform_environment_type_js_1.isPlatformEnvironmentType)(value)) {
+        throw environment_error_js_1.environmentError.invalidPlatformEnvironmentType({ value });
+    }
+}

package/dist/cjs/environment/variable/definition/environment-variable-definition-to-resolver.d.ts

@@ -0,0 +1,3 @@
+import { type EnvironmentVariableDefinition } from './environment-variable-definition.js';
+import { type EnvironmentVariableResolver } from './environment-variable-resolver.js';
+export declare function environmentVariableDefinitionToResolver<T, Optional extends boolean>(environmentVariableDefinition: EnvironmentVariableDefinition<T, Optional>): EnvironmentVariableResolver<T>;

package/dist/cjs/environment/variable/definition/environment-variable-definition-to-resolver.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.environmentVariableDefinitionToResolver = environmentVariableDefinitionToResolver;
+const functional_1 = require("@edumalin/platform/functional");
+function environmentVariableDefinitionToResolver(environmentVariableDefinition) {
+    const { defaultValue, description, optional = false, parse = functional_1.identity } = environmentVariableDefinition;
+    return (variableValue, name) => {
+        const value = variableValue !== undefined ? parse(variableValue) : defaultValue;
+        if (value === undefined && !optional) {
+            throw new Error(`missing environment variable "${name}" (${description})`);
+        }
+        return value;
+    };
+}

package/dist/cjs/environment/variable/definition/environment-variable-definition-type.d.ts

@@ -0,0 +1,3 @@
+import { type ReadonlyRecord } from '@edumalin/platform/typescript';
+import { type EnvironmentVariableDefinition } from './environment-variable-definition.js';
+export type EnvironmentVariableDefinitionType<T extends ReadonlyRecord<string, EnvironmentVariableDefinition<unknown, boolean>>> = T extends ReadonlyRecord<string, infer DefinitionType> ? DefinitionType : never;

package/dist/cjs/environment/variable/definition/environment-variable-definition-type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/environment/variable/definition/environment-variable-definition.d.ts

@@ -0,0 +1,7 @@
+export interface EnvironmentVariableDefinition<T = string, Optional extends boolean = false> {
+    readonly defaultValue?: T;
+    readonly description: string;
+    readonly name: string;
+    readonly optional?: Optional;
+    readonly parse?: (variableValue: string) => T;
+}

package/dist/cjs/environment/variable/definition/environment-variable-definition.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/environment/variable/definition/environment-variable-definitions-to-resolvers.d.ts

@@ -0,0 +1,4 @@
+import { type ReadonlyRecord } from '@edumalin/platform/typescript';
+import { type EnvironmentVariableDefinition } from './environment-variable-definition.js';
+import { type EnvironmentVariableEntry } from './environment-variable-entry.js';
+export declare function environmentVariableDefinitionsToResolvers<VariableDefinitions extends ReadonlyRecord<string, EnvironmentVariableDefinition<unknown, boolean>>>(definitions: VariableDefinitions): ReadonlyArray<EnvironmentVariableEntry<VariableDefinitions>>;

package/dist/cjs/environment/variable/definition/environment-variable-definitions-to-resolvers.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.environmentVariableDefinitionsToResolvers = environmentVariableDefinitionsToResolvers;
+const functional_1 = require("@edumalin/platform/functional");
+const environment_variable_definition_to_resolver_js_1 = require("./environment-variable-definition-to-resolver.js");
+function environmentVariableDefinitionsToResolvers(definitions) {
+    return (0, functional_1.objectToEntries)(definitions).map(([propertyKey, variableDefinition]) => {
+        const variableResolver = (0, environment_variable_definition_to_resolver_js_1.environmentVariableDefinitionToResolver)(variableDefinition);
+        return [propertyKey, variableDefinition, variableResolver];
+    });
+}

package/dist/cjs/environment/variable/definition/environment-variable-entries-to-object.d.ts

@@ -0,0 +1,6 @@
+import { type ReadonlyRecord } from '@edumalin/platform/typescript';
+import { type EnvironmentVariables } from '../environment-variables.js';
+import { type EnvironmentVariableDefinition } from './environment-variable-definition.js';
+import { type EnvironmentVariableDefinitionType } from './environment-variable-definition-type.js';
+import { type EnvironmentVariableEntry } from './environment-variable-entry.js';
+export declare function environmentVariableEntriesToObject<VariableDefinitions extends ReadonlyRecord<string, EnvironmentVariableDefinition<unknown, boolean>>>(environmentVariables: EnvironmentVariables, variableNameResolver: (definition: EnvironmentVariableDefinitionType<VariableDefinitions>, propertyKey: keyof VariableDefinitions) => string): (obj: ReadonlyRecord<keyof VariableDefinitions, unknown>, environmentVariableEntry: EnvironmentVariableEntry<VariableDefinitions>) => ReadonlyRecord<keyof VariableDefinitions, unknown>;

package/dist/cjs/environment/variable/definition/environment-variable-entries-to-object.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.environmentVariableEntriesToObject = environmentVariableEntriesToObject;
+function environmentVariableEntriesToObject(environmentVariables, variableNameResolver) {
+    return (obj, [propertyKey, definition, resolver]) => {
+        const variableName = variableNameResolver(definition, propertyKey);
+        const variableString = environmentVariables[variableName];
+        const propertyValue = resolver(variableString, variableName);
+        return {
+            ...obj,
+            [propertyKey]: propertyValue,
+        };
+    };
+}

package/dist/cjs/environment/variable/definition/environment-variable-entry.d.ts

@@ -0,0 +1,9 @@
+import { type ReadonlyRecord } from '@edumalin/platform/typescript';
+import { type EnvironmentVariableDefinition } from './environment-variable-definition.js';
+import { type EnvironmentVariableDefinitionType } from './environment-variable-definition-type.js';
+import { type EnvironmentVariableResolver } from './environment-variable-resolver.js';
+export type EnvironmentVariableEntry<VariableDefinitions extends ReadonlyRecord<string, EnvironmentVariableDefinition<unknown, boolean>>> = readonly [
+    propertyKey: keyof VariableDefinitions,
+    variableDefinition: EnvironmentVariableDefinitionType<VariableDefinitions>,
+    resolver: EnvironmentVariableResolver<unknown>
+];

package/dist/cjs/environment/variable/definition/environment-variable-entry.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/environment/variable/definition/environment-variable-object-property-type.d.ts

@@ -0,0 +1,4 @@
+import { type EnvironmentVariableDefinition } from './environment-variable-definition.js';
+export type EnvironmentVariableObjectPropertyType<VariableDefinition extends EnvironmentVariableDefinition<any, boolean>> = VariableDefinition extends {
+    readonly parse: (variableValue: string) => infer T;
+} ? T : string;

package/dist/cjs/environment/variable/definition/environment-variable-object-property-type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/environment/variable/definition/environment-variable-object-property.d.ts

@@ -0,0 +1,5 @@
+import { type EnvironmentVariableDefinition } from './environment-variable-definition.js';
+import { type EnvironmentVariableObjectPropertyType } from './environment-variable-object-property-type.js';
+export type EnvironmentVariableObjectProperty<VariableDefinition extends EnvironmentVariableDefinition<unknown, boolean>> = VariableDefinition extends {
+    readonly optional: true;
+} ? EnvironmentVariableObjectPropertyType<VariableDefinition> | undefined : EnvironmentVariableObjectPropertyType<VariableDefinition>;

package/dist/cjs/environment/variable/definition/environment-variable-object-property.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/environment/variable/definition/environment-variable-object.d.ts

@@ -0,0 +1,6 @@
+import { type Expand, type ReadonlyRecord } from '@edumalin/platform/typescript';
+import { type EnvironmentVariableDefinition } from './environment-variable-definition.js';
+import { type EnvironmentVariableObjectProperty } from './environment-variable-object-property.js';
+export type EnvironmentVariableObject<VariableDefinitions extends ReadonlyRecord<string, EnvironmentVariableDefinition<unknown, boolean>>> = Expand<{
+    readonly [K in keyof VariableDefinitions]: EnvironmentVariableObjectProperty<VariableDefinitions[K]>;
+}>;

package/dist/cjs/environment/variable/definition/environment-variable-object.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/environment/variable/definition/environment-variable-resolver.d.ts

@@ -0,0 +1,3 @@
+export interface EnvironmentVariableResolver<T> {
+    (value: string | undefined, name: string): T;
+}

package/dist/cjs/environment/variable/definition/environment-variable-resolver.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/environment/variable/environment-variables-to-platform-environment.d.ts

@@ -0,0 +1,3 @@
+import { type PlatformEnvironment } from '../platform-environment.js';
+import { type EnvironmentVariables } from './environment-variables.js';
+export declare function environmentVariablesToPlatformEnvironment(): (environmentVariables: EnvironmentVariables) => PlatformEnvironment;

package/dist/cjs/environment/variable/environment-variables-to-platform-environment.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.environmentVariablesToPlatformEnvironment = environmentVariablesToPlatformEnvironment;
+const as_platform_environment_id_1 = require("../id/as-platform-environment-id");
+const as_platform_environment_provider_1 = require("../provider/as-platform-environment-provider");
+const as_platform_environment_region_js_1 = require("../region/as-platform-environment-region.js");
+const as_platform_environment_type_js_1 = require("../type/as-platform-environment-type.js");
+const environment_variables_to_value_js_1 = require("./environment-variables-to-value.js");
+function environmentVariablesToPlatformEnvironment() {
+    return (0, environment_variables_to_value_js_1.environmentVariablesToValue)({
+        id: {
+            description: 'Edumalin platform environment identifier',
+            name: 'EDU_ENV_ID',
+            parse: as_platform_environment_id_1.asPlatformEnvironmentId,
+        },
+        name: {
+            description: 'Edumalin platform environment name',
+            name: 'EDU_ENV_NAME',
+        },
+        provider: {
+            description: 'Edumalin platform environment provider',
+            name: 'EDU_ENV_PROVIDER',
+            parse: as_platform_environment_provider_1.asPlatformEnvironmentProvider,
+        },
+        region: {
+            description: 'Edumalin platform environment region',
+            name: 'EDU_ENV_REGION',
+            parse: as_platform_environment_region_js_1.asPlatformEnvironmentRegion,
+        },
+        type: {
+            description: 'Edumalin platform environment type',
+            name: 'EDU_ENV_TYPE',
+            parse: as_platform_environment_type_js_1.asPlatformEnvironmentType,
+        },
+    });
+}

package/dist/cjs/environment/variable/environment-variables-to-value.d.ts

@@ -0,0 +1,5 @@
+import { type ReadonlyRecord } from '@edumalin/platform/typescript';
+import { type EnvironmentVariableDefinition } from './definition/environment-variable-definition.js';
+import { type EnvironmentVariableObject } from './definition/environment-variable-object.js';
+import { type EnvironmentVariables } from './environment-variables.js';
+export declare function environmentVariablesToValue<VariableDefinitions extends ReadonlyRecord<string, EnvironmentVariableDefinition<any, boolean>>>(definitions: VariableDefinitions): (environmentVariables: EnvironmentVariables) => EnvironmentVariableObject<VariableDefinitions>;

package/dist/cjs/environment/variable/environment-variables-to-value.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.environmentVariablesToValue = environmentVariablesToValue;
+const environment_variable_definitions_to_resolvers_js_1 = require("./definition/environment-variable-definitions-to-resolvers.js");
+const environment_variable_entries_to_object_js_1 = require("./definition/environment-variable-entries-to-object.js");
+function environmentVariablesToValue(definitions) {
+    return environmentVariables => {
+        const variableResolvers = (0, environment_variable_definitions_to_resolvers_js_1.environmentVariableDefinitionsToResolvers)(definitions);
+        const object = variableResolvers.reduce((0, environment_variable_entries_to_object_js_1.environmentVariableEntriesToObject)(environmentVariables, definition => definition.name), {});
+        return object;
+    };
+}

package/dist/cjs/environment/variable/environment-variables-to-values.d.ts

@@ -0,0 +1,7 @@
+import { type ReadonlyRecord } from '@edumalin/platform/typescript';
+import { type EnvironmentVariableDefinition } from './definition/environment-variable-definition.js';
+import { type EnvironmentVariableObject } from './definition/environment-variable-object.js';
+import { type EnvironmentVariables } from './environment-variables.js';
+import { type IndexedEnvironmentVariableDefinitions } from './indexed/indexed-environment-variable-definitions.js';
+export declare function environmentVariablesToValues<VariableDefinitions extends ReadonlyRecord<string, EnvironmentVariableDefinition<unknown, boolean>>>(definitions: IndexedEnvironmentVariableDefinitions<VariableDefinitions>): (environmentVariables: EnvironmentVariables) => ReadonlyArray<EnvironmentVariableObject<VariableDefinitions>>;
+export declare function environmentVariablesToValues<VariableDefinitions extends ReadonlyRecord<string, EnvironmentVariableDefinition<unknown, boolean>>, KeyType, ValueType>(definitions: IndexedEnvironmentVariableDefinitions<VariableDefinitions>, project: (variableObject: EnvironmentVariableObject<VariableDefinitions>) => readonly [key: KeyType, value: ValueType]): (environmentVariables: EnvironmentVariables) => ReadonlyMap<KeyType, ValueType>;

package/dist/cjs/environment/variable/environment-variables-to-values.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.environmentVariablesToValues = environmentVariablesToValues;
+const get_indexed_environment_variables_count_js_1 = require("./indexed/get-indexed-environment-variables-count.js");
+const index_to_indexed_environment_variables_js_1 = require("./indexed/index-to-indexed-environment-variables.js");
+function environmentVariablesToValues(definitions, project) {
+    return environmentVariables => {
+        const length = (0, get_indexed_environment_variables_count_js_1.getIndexedEnvironmentVariablesCount)(environmentVariables, definitions);
+        const toEnvironmentVariables = (0, index_to_indexed_environment_variables_js_1.indexToIndexedEnvironmentVariables)(environmentVariables, definitions);
+        const variableDefinitions = Array.from({ length })
+            .map((_, index) => index)
+            .map(toEnvironmentVariables);
+        return project !== undefined ? new Map(variableDefinitions.map(project)) : variableDefinitions;
+    };
+}

package/dist/cjs/environment/variable/environment-variables.d.ts

@@ -0,0 +1,2 @@
+import { type ReadonlyRecord } from '@edumalin/platform/typescript';
+export type EnvironmentVariables = ReadonlyRecord<string, string | undefined>;

package/dist/cjs/environment/variable/environment-variables.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/environment/variable/indexed/get-indexed-environment-variables-count.d.ts

@@ -0,0 +1,5 @@
+import { type ReadonlyRecord } from '@edumalin/platform/typescript';
+import { type EnvironmentVariableDefinition } from '../definition/environment-variable-definition.js';
+import { type EnvironmentVariables } from '../environment-variables.js';
+import { type IndexedEnvironmentVariableDefinitions } from './indexed-environment-variable-definitions.js';
+export declare function getIndexedEnvironmentVariablesCount<VariableDefinitions extends ReadonlyRecord<string, EnvironmentVariableDefinition<any, boolean>>>(environmentVariables: EnvironmentVariables, variableDefinitions: IndexedEnvironmentVariableDefinitions<VariableDefinitions>): number;

package/dist/cjs/environment/variable/indexed/get-indexed-environment-variables-count.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIndexedEnvironmentVariablesCount = getIndexedEnvironmentVariablesCount;
+function getIndexedEnvironmentVariablesCount(environmentVariables, variableDefinitions) {
+    const { definitions, prefix } = variableDefinitions;
+    const requiredSuffixes = Object.values(definitions)
+        .filter(({ optional }) => optional !== true)
+        .map(({ name }) => name);
+    let count = 0;
+    let validIteration = false;
+    do {
+        const countString = count.toString();
+        const baseVariableName = `${prefix}_${countString}_`;
+        const variableNames = requiredSuffixes.map(suffix => baseVariableName + suffix);
+        validIteration = variableNames.every(variableName => environmentVariables[variableName] !== undefined);
+        if (validIteration) {
+            ++count;
+        }
+    } while (validIteration);
+    return count;
+}

package/dist/cjs/environment/variable/indexed/index-to-indexed-environment-variables.d.ts

@@ -0,0 +1,6 @@
+import { type ReadonlyRecord } from '@edumalin/platform/typescript';
+import { type EnvironmentVariableDefinition } from '../definition/environment-variable-definition.js';
+import { type EnvironmentVariableObject } from '../definition/environment-variable-object.js';
+import { type EnvironmentVariables } from '../environment-variables.js';
+import { type IndexedEnvironmentVariableDefinitions } from './indexed-environment-variable-definitions.js';
+export declare function indexToIndexedEnvironmentVariables<VariableDefinitions extends ReadonlyRecord<string, EnvironmentVariableDefinition<any, boolean>>>(environmentVariables: EnvironmentVariables, variableDefinitions: IndexedEnvironmentVariableDefinitions<VariableDefinitions>): (index: number) => EnvironmentVariableObject<VariableDefinitions>;

package/dist/cjs/environment/variable/indexed/index-to-indexed-environment-variables.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.indexToIndexedEnvironmentVariables = indexToIndexedEnvironmentVariables;
+const environment_variable_definitions_to_resolvers_js_1 = require("../definition/environment-variable-definitions-to-resolvers.js");
+const environment_variable_entries_to_object_js_1 = require("../definition/environment-variable-entries-to-object.js");
+function indexToIndexedEnvironmentVariables(environmentVariables, variableDefinitions) {
+    const { definitions } = variableDefinitions;
+    const variableResolvers = (0, environment_variable_definitions_to_resolvers_js_1.environmentVariableDefinitionsToResolvers)(definitions);
+    return index => {
+        const indexString = index.toString();
+        const prefix = `${variableDefinitions.prefix}_${indexString}_`;
+        const object = variableResolvers.reduce((0, environment_variable_entries_to_object_js_1.environmentVariableEntriesToObject)(environmentVariables, definition => prefix + definition.name), {});
+        return object;
+    };
+}

package/dist/cjs/environment/variable/indexed/indexed-environment-variable-definitions.d.ts

@@ -0,0 +1,6 @@
+import { type ReadonlyRecord } from '@edumalin/platform/typescript';
+import { type EnvironmentVariableDefinition } from '../definition/environment-variable-definition.js';
+export interface IndexedEnvironmentVariableDefinitions<VariableDefinitions extends ReadonlyRecord<string, EnvironmentVariableDefinition<any, boolean>>> {
+    readonly definitions: VariableDefinitions;
+    readonly prefix: string;
+}

package/dist/cjs/environment/variable/indexed/indexed-environment-variable-definitions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/environment/variable/platform-environment-to-environment-variables.d.ts

@@ -0,0 +1,3 @@
+import { type PlatformEnvironment } from '../platform-environment.js';
+import { type EnvironmentVariables } from './environment-variables.js';
+export declare function platformEnvironmentToEnvironmentVariables(platformEnvironment: PlatformEnvironment): EnvironmentVariables;

package/dist/cjs/environment/variable/platform-environment-to-environment-variables.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.platformEnvironmentToEnvironmentVariables = platformEnvironmentToEnvironmentVariables;
+function platformEnvironmentToEnvironmentVariables(platformEnvironment) {
+    const { id, name, provider, region, type } = platformEnvironment;
+    return {
+        EDU_ENV_ID: id,
+        EDU_ENV_NAME: name,
+        EDU_ENV_PROVIDER: provider,
+        EDU_ENV_REGION: region,
+        EDU_ENV_TYPE: type,
+    };
+}

package/dist/cjs/error/creator/error-creator.d.ts

@@ -0,0 +1,4 @@
+import { type TypeCreator } from '@edumalin/platform/typescript';
+export type ErrorCreator<ErrorCode extends string, TypeCreatorType extends TypeCreator<any, any>> = {
+    readonly code: ErrorCode;
+} & TypeCreatorType;

package/dist/cjs/error/creator/error-creator.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/error/creator/error-from-creator.d.ts

@@ -0,0 +1,3 @@
+import { type TypeCreator } from '@edumalin/platform/typescript';
+import { type ErrorCreator } from './error-creator.js';
+export type ErrorFromCreator<CreatorType extends ErrorCreator<string, TypeCreator<any, any>>> = ReturnType<CreatorType>;

package/dist/cjs/error/creator/error-from-creator.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/error/index.d.ts

@@ -0,0 +1,14 @@
+export { catchPlatformError } from './operator/catch-platform-error.js';
+export { createErrorType } from './type/create-error-type.js';
+export { type ErrorFromType } from './type/error-from-type.js';
+export { type ErrorType } from './type/error-type.js';
+export { errorProperties } from './properties/error-properties.js';
+export { type ErrorPropertiesFromErrorDefinitions } from './properties/error-properties-from-error-definitions.js';
+export { type ErrorPropertiesSchema } from './properties/error-properties-schema.js';
+export { isErrorOfType } from './is-error-of-type.js';
+export { isError } from './is-error.js';
+export { isPlatformError } from './is-platform-error.js';
+export { mapPlatformError } from './operator/map-platform-error.js';
+export { type PlatformError } from './platform-error.js';
+export { PlatformErrorInstance } from './platform-error-instance.js';
+export { platformErrorToPlatformErrorInstance } from './platform-error-to-platform-error-instance.js';

package/dist/cjs/error/index.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.platformErrorToPlatformErrorInstance = exports.PlatformErrorInstance = exports.mapPlatformError = exports.isPlatformError = exports.isError = exports.isErrorOfType = exports.errorProperties = exports.createErrorType = exports.catchPlatformError = void 0;
+var catch_platform_error_js_1 = require("./operator/catch-platform-error.js");
+Object.defineProperty(exports, "catchPlatformError", { enumerable: true, get: function () { return catch_platform_error_js_1.catchPlatformError; } });
+var create_error_type_js_1 = require("./type/create-error-type.js");
+Object.defineProperty(exports, "createErrorType", { enumerable: true, get: function () { return create_error_type_js_1.createErrorType; } });
+var error_properties_js_1 = require("./properties/error-properties.js");
+Object.defineProperty(exports, "errorProperties", { enumerable: true, get: function () { return error_properties_js_1.errorProperties; } });
+var is_error_of_type_js_1 = require("./is-error-of-type.js");
+Object.defineProperty(exports, "isErrorOfType", { enumerable: true, get: function () { return is_error_of_type_js_1.isErrorOfType; } });
+var is_error_js_1 = require("./is-error.js");
+Object.defineProperty(exports, "isError", { enumerable: true, get: function () { return is_error_js_1.isError; } });
+var is_platform_error_js_1 = require("./is-platform-error.js");
+Object.defineProperty(exports, "isPlatformError", { enumerable: true, get: function () { return is_platform_error_js_1.isPlatformError; } });
+var map_platform_error_js_1 = require("./operator/map-platform-error.js");
+Object.defineProperty(exports, "mapPlatformError", { enumerable: true, get: function () { return map_platform_error_js_1.mapPlatformError; } });
+var platform_error_instance_js_1 = require("./platform-error-instance.js");
+Object.defineProperty(exports, "PlatformErrorInstance", { enumerable: true, get: function () { return platform_error_instance_js_1.PlatformErrorInstance; } });
+var platform_error_to_platform_error_instance_js_1 = require("./platform-error-to-platform-error-instance.js");
+Object.defineProperty(exports, "platformErrorToPlatformErrorInstance", { enumerable: true, get: function () { return platform_error_to_platform_error_instance_js_1.platformErrorToPlatformErrorInstance; } });

package/dist/cjs/error/is-error-of-type.d.ts

@@ -0,0 +1,7 @@
+import { type TypeCreator } from '@edumalin/platform/typescript';
+import { type ErrorCreator } from './creator/error-creator.js';
+import { type ErrorFromCreator } from './creator/error-from-creator.js';
+import { type ErrorFromType } from './type/error-from-type.js';
+import { type ErrorType as GenericErrorType } from './type/error-type.js';
+export declare function isErrorOfType<ErrorType extends GenericErrorType>(errorType: ErrorType): (error: unknown) => error is ErrorFromType<ErrorType>;
+export declare function isErrorOfType<ErrorCreatorType extends ErrorCreator<string, TypeCreator<any, any>>>(errorType: ErrorCreatorType): (error: unknown) => error is ErrorFromCreator<ErrorCreatorType>;