@lorion-org/runtime-config 1.0.0-beta.0

package/dist/index.d.cts

@@ -0,0 +1,101 @@
+type RuntimeConfigKeyStrategy = (scopeId: string, key: string) => string;
+type RuntimeConfigKeyOptions = {
+    keyStrategy?: RuntimeConfigKeyStrategy;
+};
+declare function createRuntimeConfigKey(scopeId: string, key: string, options?: RuntimeConfigKeyOptions): string;
+declare function stripRuntimeConfigScopePrefix(scopeId: string, configKey: string, options?: RuntimeConfigKeyOptions): string | undefined;
+declare function toSnakeUpperCase(input: string): string;
+
+type ConfigVisibility = 'public' | 'private';
+type RuntimeConfigSection = Record<string, unknown>;
+type RuntimeConfigContext = {
+    public?: RuntimeConfigSection;
+    private?: RuntimeConfigSection;
+};
+type RuntimeConfigFragment = RuntimeConfigContext & {
+    contexts?: Record<string, RuntimeConfigContext>;
+};
+type RuntimeConfigFragmentInput = RuntimeConfigFragment & Record<string, unknown>;
+type NamedRuntimeConfigFragment = {
+    scopeId: string;
+    config: RuntimeConfigFragmentInput;
+};
+type RuntimeConfigFragmentMap = Map<string, RuntimeConfigFragment>;
+type SectionedRuntimeConfig = {
+    public: RuntimeConfigSection;
+    private: RuntimeConfigSection;
+};
+type RuntimeConfigNamespaceProjection = RuntimeConfigSection & {
+    public: RuntimeConfigSection;
+};
+type RuntimeEnvVars = Record<string, unknown>;
+declare const runtimeConfigVisibilities: ConfigVisibility[];
+
+type NormalizeRuntimeConfigFragmentOptions = {
+    contextInputKey?: string;
+};
+declare function toRuntimeConfigFragment(config: RuntimeConfigFragmentInput, options?: NormalizeRuntimeConfigFragmentOptions): RuntimeConfigFragment;
+
+type ProjectSectionedRuntimeConfigOptions = RuntimeConfigKeyOptions & NormalizeRuntimeConfigFragmentOptions & {
+    contextOutputKey?: string;
+    includeContexts?: boolean;
+    scopeIds?: string[];
+};
+type ProjectRuntimeConfigFragmentOptions = Omit<ProjectSectionedRuntimeConfigOptions, 'scopeIds'>;
+type ProjectRuntimeConfigNamespacesOptions = {
+    contextInputKey?: string;
+    contextId?: string;
+    namespaceStrategy?: 'nested' | 'flat';
+    scopeIds?: string[];
+};
+type ProjectRuntimeConfigNamespaceOptions = Omit<ProjectRuntimeConfigNamespacesOptions, 'scopeIds'>;
+declare function normalizeRuntimeConfigFragments(fragments: Iterable<NamedRuntimeConfigFragment> | RuntimeConfigFragmentMap, options?: NormalizeRuntimeConfigFragmentOptions): NamedRuntimeConfigFragment[];
+declare function projectSectionedRuntimeConfig(fragments: Iterable<NamedRuntimeConfigFragment> | RuntimeConfigFragmentMap, options?: ProjectSectionedRuntimeConfigOptions): SectionedRuntimeConfig;
+declare function projectRuntimeConfigFragment(scopeId: string, config: RuntimeConfigFragment, options?: ProjectRuntimeConfigFragmentOptions): SectionedRuntimeConfig;
+declare function projectRuntimeConfigNamespace(scopeId: string, config: RuntimeConfigFragment, options?: ProjectRuntimeConfigNamespaceOptions): RuntimeConfigNamespaceProjection;
+declare function projectRuntimeConfigNamespaces(fragments: Iterable<NamedRuntimeConfigFragment> | RuntimeConfigFragmentMap, options?: ProjectRuntimeConfigNamespacesOptions): RuntimeConfigNamespaceProjection;
+
+type ProjectRuntimeConfigEnvVarsOptions = ProjectSectionedRuntimeConfigOptions & {
+    prefix?: string;
+};
+declare function createRuntimeConfigEnvKey(input: {
+    key: string;
+    prefix?: string;
+    scopeId?: string;
+    visibility?: ConfigVisibility;
+}): string;
+declare function toRuntimeEnvVars(runtimeConfig: SectionedRuntimeConfig, prefix?: string): RuntimeEnvVars;
+declare function projectRuntimeConfigEnvVars(fragments: Iterable<NamedRuntimeConfigFragment> | RuntimeConfigFragmentMap, options?: ProjectRuntimeConfigEnvVarsOptions): RuntimeEnvVars;
+declare function injectRuntimeEnvVars(envVars: RuntimeEnvVars, processEnv: Record<string, unknown>): RuntimeEnvVars;
+declare function runtimeEnvVarsToString(envVars: RuntimeEnvVars): string;
+declare function runtimeEnvValueToShellLiteral(value: unknown): string;
+declare function runtimeEnvVarsToShellAssignments(envVars: RuntimeEnvVars): string;
+
+type ResolveRuntimeConfigValueOptions<T = unknown> = RuntimeConfigKeyOptions & {
+    contextId?: string;
+    contextOutputKey?: string;
+    defaultValue?: T;
+};
+type ResolveRuntimeConfigValueFromRuntimeConfigOptions<T = unknown> = ResolveRuntimeConfigValueOptions<T> & {
+    visibility?: ConfigVisibility;
+};
+declare function resolveRuntimeConfigValue<T = unknown>(scopeConfig: RuntimeConfigSection | undefined, scopeId: string, key: string, options?: ResolveRuntimeConfigValueOptions<T>): T | undefined;
+declare function resolveRuntimeConfigValueFromRuntimeConfig<T = unknown>(runtimeConfig: Partial<Record<ConfigVisibility, RuntimeConfigSection | undefined>>, scopeId: string, key: string, options?: ResolveRuntimeConfigValueFromRuntimeConfigOptions<T>): T | undefined;
+
+type GetRuntimeConfigScopeOptions = RuntimeConfigKeyOptions & {
+    contextId?: string;
+    contextOutputKey?: string;
+    keys?: string[];
+    visibility?: ConfigVisibility;
+};
+type GetRuntimeConfigFragmentOptions = RuntimeConfigKeyOptions & {
+    contextId?: string;
+    contextOutputKey?: string;
+    keys?: Partial<Record<ConfigVisibility, string[]>>;
+};
+declare function getRuntimeConfigScope<T extends RuntimeConfigSection = RuntimeConfigSection>(runtimeConfig: Partial<Record<ConfigVisibility, RuntimeConfigSection | undefined>>, scopeId: string, options?: GetRuntimeConfigScopeOptions): T;
+declare function getPublicRuntimeConfigScope<T extends RuntimeConfigSection = RuntimeConfigSection>(runtimeConfig: Partial<Record<ConfigVisibility, RuntimeConfigSection | undefined>>, scopeId: string, options?: Omit<GetRuntimeConfigScopeOptions, 'visibility'>): T;
+declare function getPrivateRuntimeConfigScope<T extends RuntimeConfigSection = RuntimeConfigSection>(runtimeConfig: Partial<Record<ConfigVisibility, RuntimeConfigSection | undefined>>, scopeId: string, options?: Omit<GetRuntimeConfigScopeOptions, 'visibility'>): T;
+declare function getRuntimeConfigFragment(runtimeConfig: Partial<Record<ConfigVisibility, RuntimeConfigSection | undefined>>, scopeId: string, options?: GetRuntimeConfigFragmentOptions): RuntimeConfigContext;
+
+export { type ConfigVisibility, type GetRuntimeConfigFragmentOptions, type GetRuntimeConfigScopeOptions, type NamedRuntimeConfigFragment, type NormalizeRuntimeConfigFragmentOptions, type ProjectRuntimeConfigEnvVarsOptions, type ProjectRuntimeConfigFragmentOptions, type ProjectRuntimeConfigNamespaceOptions, type ProjectRuntimeConfigNamespacesOptions, type ProjectSectionedRuntimeConfigOptions, type ResolveRuntimeConfigValueFromRuntimeConfigOptions, type ResolveRuntimeConfigValueOptions, type RuntimeConfigContext, type RuntimeConfigFragment, type RuntimeConfigFragmentInput, type RuntimeConfigFragmentMap, type RuntimeConfigKeyOptions, type RuntimeConfigKeyStrategy, type RuntimeConfigNamespaceProjection, type RuntimeConfigSection, type RuntimeEnvVars, type SectionedRuntimeConfig, createRuntimeConfigEnvKey, createRuntimeConfigKey, getPrivateRuntimeConfigScope, getPublicRuntimeConfigScope, getRuntimeConfigFragment, getRuntimeConfigScope, injectRuntimeEnvVars, normalizeRuntimeConfigFragments, projectRuntimeConfigEnvVars, projectRuntimeConfigFragment, projectRuntimeConfigNamespace, projectRuntimeConfigNamespaces, projectSectionedRuntimeConfig, resolveRuntimeConfigValue, resolveRuntimeConfigValueFromRuntimeConfig, runtimeConfigVisibilities, runtimeEnvValueToShellLiteral, runtimeEnvVarsToShellAssignments, runtimeEnvVarsToString, stripRuntimeConfigScopePrefix, toRuntimeConfigFragment, toRuntimeEnvVars, toSnakeUpperCase };

package/dist/index.d.ts

@@ -0,0 +1,101 @@
+type RuntimeConfigKeyStrategy = (scopeId: string, key: string) => string;
+type RuntimeConfigKeyOptions = {
+    keyStrategy?: RuntimeConfigKeyStrategy;
+};
+declare function createRuntimeConfigKey(scopeId: string, key: string, options?: RuntimeConfigKeyOptions): string;
+declare function stripRuntimeConfigScopePrefix(scopeId: string, configKey: string, options?: RuntimeConfigKeyOptions): string | undefined;
+declare function toSnakeUpperCase(input: string): string;
+
+type ConfigVisibility = 'public' | 'private';
+type RuntimeConfigSection = Record<string, unknown>;
+type RuntimeConfigContext = {
+    public?: RuntimeConfigSection;
+    private?: RuntimeConfigSection;
+};
+type RuntimeConfigFragment = RuntimeConfigContext & {
+    contexts?: Record<string, RuntimeConfigContext>;
+};
+type RuntimeConfigFragmentInput = RuntimeConfigFragment & Record<string, unknown>;
+type NamedRuntimeConfigFragment = {
+    scopeId: string;
+    config: RuntimeConfigFragmentInput;
+};
+type RuntimeConfigFragmentMap = Map<string, RuntimeConfigFragment>;
+type SectionedRuntimeConfig = {
+    public: RuntimeConfigSection;
+    private: RuntimeConfigSection;
+};
+type RuntimeConfigNamespaceProjection = RuntimeConfigSection & {
+    public: RuntimeConfigSection;
+};
+type RuntimeEnvVars = Record<string, unknown>;
+declare const runtimeConfigVisibilities: ConfigVisibility[];
+
+type NormalizeRuntimeConfigFragmentOptions = {
+    contextInputKey?: string;
+};
+declare function toRuntimeConfigFragment(config: RuntimeConfigFragmentInput, options?: NormalizeRuntimeConfigFragmentOptions): RuntimeConfigFragment;
+
+type ProjectSectionedRuntimeConfigOptions = RuntimeConfigKeyOptions & NormalizeRuntimeConfigFragmentOptions & {
+    contextOutputKey?: string;
+    includeContexts?: boolean;
+    scopeIds?: string[];
+};
+type ProjectRuntimeConfigFragmentOptions = Omit<ProjectSectionedRuntimeConfigOptions, 'scopeIds'>;
+type ProjectRuntimeConfigNamespacesOptions = {
+    contextInputKey?: string;
+    contextId?: string;
+    namespaceStrategy?: 'nested' | 'flat';
+    scopeIds?: string[];
+};
+type ProjectRuntimeConfigNamespaceOptions = Omit<ProjectRuntimeConfigNamespacesOptions, 'scopeIds'>;
+declare function normalizeRuntimeConfigFragments(fragments: Iterable<NamedRuntimeConfigFragment> | RuntimeConfigFragmentMap, options?: NormalizeRuntimeConfigFragmentOptions): NamedRuntimeConfigFragment[];
+declare function projectSectionedRuntimeConfig(fragments: Iterable<NamedRuntimeConfigFragment> | RuntimeConfigFragmentMap, options?: ProjectSectionedRuntimeConfigOptions): SectionedRuntimeConfig;
+declare function projectRuntimeConfigFragment(scopeId: string, config: RuntimeConfigFragment, options?: ProjectRuntimeConfigFragmentOptions): SectionedRuntimeConfig;
+declare function projectRuntimeConfigNamespace(scopeId: string, config: RuntimeConfigFragment, options?: ProjectRuntimeConfigNamespaceOptions): RuntimeConfigNamespaceProjection;
+declare function projectRuntimeConfigNamespaces(fragments: Iterable<NamedRuntimeConfigFragment> | RuntimeConfigFragmentMap, options?: ProjectRuntimeConfigNamespacesOptions): RuntimeConfigNamespaceProjection;
+
+type ProjectRuntimeConfigEnvVarsOptions = ProjectSectionedRuntimeConfigOptions & {
+    prefix?: string;
+};
+declare function createRuntimeConfigEnvKey(input: {
+    key: string;
+    prefix?: string;
+    scopeId?: string;
+    visibility?: ConfigVisibility;
+}): string;
+declare function toRuntimeEnvVars(runtimeConfig: SectionedRuntimeConfig, prefix?: string): RuntimeEnvVars;
+declare function projectRuntimeConfigEnvVars(fragments: Iterable<NamedRuntimeConfigFragment> | RuntimeConfigFragmentMap, options?: ProjectRuntimeConfigEnvVarsOptions): RuntimeEnvVars;
+declare function injectRuntimeEnvVars(envVars: RuntimeEnvVars, processEnv: Record<string, unknown>): RuntimeEnvVars;
+declare function runtimeEnvVarsToString(envVars: RuntimeEnvVars): string;
+declare function runtimeEnvValueToShellLiteral(value: unknown): string;
+declare function runtimeEnvVarsToShellAssignments(envVars: RuntimeEnvVars): string;
+
+type ResolveRuntimeConfigValueOptions<T = unknown> = RuntimeConfigKeyOptions & {
+    contextId?: string;
+    contextOutputKey?: string;
+    defaultValue?: T;
+};
+type ResolveRuntimeConfigValueFromRuntimeConfigOptions<T = unknown> = ResolveRuntimeConfigValueOptions<T> & {
+    visibility?: ConfigVisibility;
+};
+declare function resolveRuntimeConfigValue<T = unknown>(scopeConfig: RuntimeConfigSection | undefined, scopeId: string, key: string, options?: ResolveRuntimeConfigValueOptions<T>): T | undefined;
+declare function resolveRuntimeConfigValueFromRuntimeConfig<T = unknown>(runtimeConfig: Partial<Record<ConfigVisibility, RuntimeConfigSection | undefined>>, scopeId: string, key: string, options?: ResolveRuntimeConfigValueFromRuntimeConfigOptions<T>): T | undefined;
+
+type GetRuntimeConfigScopeOptions = RuntimeConfigKeyOptions & {
+    contextId?: string;
+    contextOutputKey?: string;
+    keys?: string[];
+    visibility?: ConfigVisibility;
+};
+type GetRuntimeConfigFragmentOptions = RuntimeConfigKeyOptions & {
+    contextId?: string;
+    contextOutputKey?: string;
+    keys?: Partial<Record<ConfigVisibility, string[]>>;
+};
+declare function getRuntimeConfigScope<T extends RuntimeConfigSection = RuntimeConfigSection>(runtimeConfig: Partial<Record<ConfigVisibility, RuntimeConfigSection | undefined>>, scopeId: string, options?: GetRuntimeConfigScopeOptions): T;
+declare function getPublicRuntimeConfigScope<T extends RuntimeConfigSection = RuntimeConfigSection>(runtimeConfig: Partial<Record<ConfigVisibility, RuntimeConfigSection | undefined>>, scopeId: string, options?: Omit<GetRuntimeConfigScopeOptions, 'visibility'>): T;
+declare function getPrivateRuntimeConfigScope<T extends RuntimeConfigSection = RuntimeConfigSection>(runtimeConfig: Partial<Record<ConfigVisibility, RuntimeConfigSection | undefined>>, scopeId: string, options?: Omit<GetRuntimeConfigScopeOptions, 'visibility'>): T;
+declare function getRuntimeConfigFragment(runtimeConfig: Partial<Record<ConfigVisibility, RuntimeConfigSection | undefined>>, scopeId: string, options?: GetRuntimeConfigFragmentOptions): RuntimeConfigContext;
+
+export { type ConfigVisibility, type GetRuntimeConfigFragmentOptions, type GetRuntimeConfigScopeOptions, type NamedRuntimeConfigFragment, type NormalizeRuntimeConfigFragmentOptions, type ProjectRuntimeConfigEnvVarsOptions, type ProjectRuntimeConfigFragmentOptions, type ProjectRuntimeConfigNamespaceOptions, type ProjectRuntimeConfigNamespacesOptions, type ProjectSectionedRuntimeConfigOptions, type ResolveRuntimeConfigValueFromRuntimeConfigOptions, type ResolveRuntimeConfigValueOptions, type RuntimeConfigContext, type RuntimeConfigFragment, type RuntimeConfigFragmentInput, type RuntimeConfigFragmentMap, type RuntimeConfigKeyOptions, type RuntimeConfigKeyStrategy, type RuntimeConfigNamespaceProjection, type RuntimeConfigSection, type RuntimeEnvVars, type SectionedRuntimeConfig, createRuntimeConfigEnvKey, createRuntimeConfigKey, getPrivateRuntimeConfigScope, getPublicRuntimeConfigScope, getRuntimeConfigFragment, getRuntimeConfigScope, injectRuntimeEnvVars, normalizeRuntimeConfigFragments, projectRuntimeConfigEnvVars, projectRuntimeConfigFragment, projectRuntimeConfigNamespace, projectRuntimeConfigNamespaces, projectSectionedRuntimeConfig, resolveRuntimeConfigValue, resolveRuntimeConfigValueFromRuntimeConfig, runtimeConfigVisibilities, runtimeEnvValueToShellLiteral, runtimeEnvVarsToShellAssignments, runtimeEnvVarsToString, stripRuntimeConfigScopePrefix, toRuntimeConfigFragment, toRuntimeEnvVars, toSnakeUpperCase };

package/dist/index.js

@@ -0,0 +1,319 @@
+// src/key.ts
+function upperFirst(input) {
+  return input ? input[0].toUpperCase() + input.slice(1) : input;
+}
+function uncapitalize(input) {
+  return input ? input[0].toLowerCase() + input.slice(1) : input;
+}
+function camelCase(input) {
+  return input.replace(/['\u2019]/g, "").split(/[^A-Za-z0-9]+|(?=[A-Z][a-z])/).map((part) => part.trim()).filter(Boolean).map((part) => part.toLowerCase()).map((part, index) => index === 0 ? part : upperFirst(part)).join("");
+}
+function createRuntimeConfigKey(scopeId, key, options = {}) {
+  return options.keyStrategy?.(scopeId, key) ?? camelCase(`${scopeId} ${key}`);
+}
+function stripRuntimeConfigScopePrefix(scopeId, configKey, options = {}) {
+  const prefix = createRuntimeConfigKey(scopeId, "", options);
+  if (!prefix || !configKey.startsWith(prefix) || configKey.length <= prefix.length) {
+    return void 0;
+  }
+  return uncapitalize(configKey.slice(prefix.length));
+}
+function toSnakeUpperCase(input) {
+  return input.replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[^a-zA-Z0-9]+/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "").toUpperCase();
+}
+
+// src/fragment.ts
+var isObject = (value) => {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+function toRuntimeConfigFragment(config, options = {}) {
+  const contextInputKey = options.contextInputKey ?? "contexts";
+  const contexts = contextInputKey === "contexts" ? config.contexts : config.contexts ?? config[contextInputKey];
+  return {
+    ...isObject(config.public) ? { public: config.public } : {},
+    ...isObject(config.private) ? { private: config.private } : {},
+    ...isObject(contexts) ? { contexts } : {}
+  };
+}
+
+// src/types.ts
+var runtimeConfigVisibilities = ["public", "private"];
+
+// src/project.ts
+function normalizeRuntimeConfigFragments(fragments, options = {}) {
+  const entries = fragments instanceof Map ? Array.from(fragments.entries()).map(([scopeId, config]) => ({ scopeId, config })) : Array.from(fragments);
+  return entries.map((fragment) => ({
+    scopeId: fragment.scopeId.trim(),
+    config: toRuntimeConfigFragment(fragment.config, options)
+  })).filter((fragment) => fragment.scopeId.length > 0).sort((left, right) => left.scopeId.localeCompare(right.scopeId));
+}
+function filterFragments(input) {
+  const scopeIdSet = input.scopeIds ? new Set(input.scopeIds.map((id) => id.trim()).filter(Boolean)) : void 0;
+  return normalizeRuntimeConfigFragments(input.fragments, {
+    ...input.contextInputKey ? { contextInputKey: input.contextInputKey } : {}
+  }).filter((fragment) => !scopeIdSet || scopeIdSet.has(fragment.scopeId));
+}
+function getSection(config, visibility) {
+  return config?.[visibility];
+}
+function assignDefined(target, key, value) {
+  if (value !== void 0) {
+    target[key] = value;
+  }
+}
+function projectSectionedRuntimeConfig(fragments, options = {}) {
+  const result = {
+    public: {},
+    private: {}
+  };
+  const contextOutputKey = options.contextOutputKey ?? "__contexts";
+  const filteredFragments = filterFragments({
+    fragments,
+    ...options.contextInputKey ? { contextInputKey: options.contextInputKey } : {},
+    ...options.scopeIds ? { scopeIds: options.scopeIds } : {}
+  });
+  for (const fragment of filteredFragments) {
+    for (const visibility of runtimeConfigVisibilities) {
+      const section = getSection(fragment.config, visibility);
+      if (!section) continue;
+      for (const [key, value] of Object.entries(section)) {
+        assignDefined(
+          result[visibility],
+          createRuntimeConfigKey(fragment.scopeId, key, options),
+          value
+        );
+      }
+    }
+    if (options.includeContexts === false) continue;
+    for (const [contextId, context] of Object.entries(fragment.config.contexts ?? {})) {
+      for (const visibility of runtimeConfigVisibilities) {
+        const section = getSection(context, visibility);
+        if (!section) continue;
+        const contexts = result[visibility][contextOutputKey] ?? {};
+        const contextValues = contexts[contextId] ?? {};
+        for (const [key, value] of Object.entries(section)) {
+          assignDefined(
+            contextValues,
+            createRuntimeConfigKey(fragment.scopeId, key, options),
+            value
+          );
+        }
+        contexts[contextId] = contextValues;
+        result[visibility][contextOutputKey] = contexts;
+      }
+    }
+  }
+  return result;
+}
+function projectRuntimeConfigFragment(scopeId, config, options = {}) {
+  return projectSectionedRuntimeConfig(/* @__PURE__ */ new Map([[scopeId, config]]), options);
+}
+function projectRuntimeConfigNamespace(scopeId, config, options = {}) {
+  return projectRuntimeConfigNamespaces([{ scopeId, config }], options);
+}
+function projectRuntimeConfigNamespaces(fragments, options = {}) {
+  const result = {
+    public: {}
+  };
+  const namespaceStrategy = options.namespaceStrategy ?? "nested";
+  const filteredFragments = filterFragments({
+    fragments,
+    ...options.contextInputKey ? { contextInputKey: options.contextInputKey } : {},
+    ...options.scopeIds ? { scopeIds: options.scopeIds } : {}
+  });
+  for (const fragment of filteredFragments) {
+    const context = options.contextId ? fragment.config.contexts?.[options.contextId] : void 0;
+    const publicSection = {
+      ...fragment.config.public ?? {},
+      ...context?.public ?? {}
+    };
+    const privateSection = {
+      ...fragment.config.private ?? {},
+      ...context?.private ?? {}
+    };
+    if (namespaceStrategy === "flat") {
+      Object.assign(result.public, publicSection);
+      Object.assign(result, privateSection);
+      continue;
+    }
+    if (Object.keys(publicSection).length) {
+      result.public[fragment.scopeId] = {
+        ...result.public[fragment.scopeId] ?? {},
+        ...publicSection
+      };
+    }
+    if (Object.keys(privateSection).length) {
+      result[fragment.scopeId] = {
+        ...result[fragment.scopeId] ?? {},
+        ...privateSection
+      };
+    }
+  }
+  return result;
+}
+
+// src/env.ts
+function createRuntimeConfigEnvKey(input) {
+  return toSnakeUpperCase(
+    [input.prefix ?? "APP", input.visibility, input.scopeId, input.key].filter(Boolean).join("_")
+  );
+}
+function toRuntimeEnvVars(runtimeConfig, prefix = "APP") {
+  const envVars = {};
+  for (const visibility of runtimeConfigVisibilities) {
+    for (const [key, value] of Object.entries(runtimeConfig[visibility])) {
+      if (key.startsWith("__")) continue;
+      envVars[createRuntimeConfigEnvKey({ prefix, visibility, key })] = value;
+    }
+  }
+  return envVars;
+}
+function projectRuntimeConfigEnvVars(fragments, options = {}) {
+  const { prefix = "APP", ...projectOptions } = options;
+  return toRuntimeEnvVars(
+    projectSectionedRuntimeConfig(fragments, {
+      ...projectOptions,
+      includeContexts: false
+    }),
+    prefix
+  );
+}
+function injectRuntimeEnvVars(envVars, processEnv) {
+  const items = {};
+  for (const key of Object.keys(envVars)) {
+    items[key] = processEnv[key] ?? envVars[key];
+  }
+  return items;
+}
+function runtimeEnvVarsToString(envVars) {
+  return Object.entries(envVars).map(([key, value]) => `${key}=${String(value)}`).join("\n");
+}
+function runtimeEnvValueToShellLiteral(value) {
+  const json = JSON.stringify(value) ?? "undefined";
+  return `'${json.replace(/'/g, "'\\''")}'`;
+}
+function runtimeEnvVarsToShellAssignments(envVars) {
+  return Object.entries(envVars).map(([key, value]) => `${key}=${runtimeEnvValueToShellLiteral(value)}`).join("\n");
+}
+
+// src/resolve.ts
+function resolveRuntimeConfigValue(scopeConfig, scopeId, key, options = {}) {
+  const configKey = createRuntimeConfigKey(scopeId, key, options);
+  const contextOutputKey = options.contextOutputKey ?? "__contexts";
+  if (options.contextId) {
+    const contexts = scopeConfig?.[contextOutputKey];
+    const contextValue = contexts?.[options.contextId]?.[configKey];
+    if (contextValue !== void 0) {
+      return contextValue;
+    }
+  }
+  const globalValue = scopeConfig?.[configKey];
+  if (globalValue !== void 0) {
+    return globalValue;
+  }
+  return options.defaultValue;
+}
+function resolveRuntimeConfigValueFromRuntimeConfig(runtimeConfig, scopeId, key, options = {}) {
+  const { visibility = "public", ...resolveOptions } = options;
+  return resolveRuntimeConfigValue(runtimeConfig[visibility], scopeId, key, resolveOptions);
+}
+
+// src/scope.ts
+function assignDefined2(target, key, value) {
+  if (value !== void 0) {
+    target[key] = value;
+  }
+}
+function collectRuntimeConfigScopeValues(input) {
+  const values = {};
+  for (const [configKey, value] of Object.entries(input.scopeConfig ?? {})) {
+    if (configKey.startsWith("__")) continue;
+    const key = stripRuntimeConfigScopePrefix(input.scopeId, configKey, input.options);
+    if (key) assignDefined2(values, key, value);
+  }
+  return values;
+}
+function getRuntimeConfigScope(runtimeConfig, scopeId, options = {}) {
+  const {
+    contextId,
+    contextOutputKey = "__contexts",
+    keys,
+    visibility = "public",
+    ...keyOptions
+  } = options;
+  const scopeConfig = runtimeConfig[visibility];
+  if (keys) {
+    return Object.fromEntries(
+      keys.map((key) => {
+        const value = resolveRuntimeConfigValue(scopeConfig, scopeId, key, {
+          ...keyOptions,
+          ...contextId ? { contextId } : {},
+          contextOutputKey
+        });
+        return [key, value];
+      }).filter(([, value]) => value !== void 0)
+    );
+  }
+  const values = collectRuntimeConfigScopeValues({
+    scopeConfig,
+    scopeId,
+    options: keyOptions
+  });
+  if (!contextId) return values;
+  const contexts = scopeConfig?.[contextOutputKey];
+  const contextValues = collectRuntimeConfigScopeValues({
+    scopeConfig: contexts?.[contextId],
+    scopeId,
+    options: keyOptions
+  });
+  return {
+    ...values,
+    ...contextValues
+  };
+}
+function getPublicRuntimeConfigScope(runtimeConfig, scopeId, options = {}) {
+  return getRuntimeConfigScope(runtimeConfig, scopeId, {
+    ...options,
+    visibility: "public"
+  });
+}
+function getPrivateRuntimeConfigScope(runtimeConfig, scopeId, options = {}) {
+  return getRuntimeConfigScope(runtimeConfig, scopeId, {
+    ...options,
+    visibility: "private"
+  });
+}
+function getRuntimeConfigFragment(runtimeConfig, scopeId, options = {}) {
+  const { keys, ...scopeOptions } = options;
+  const publicOptions = keys?.public ? { ...scopeOptions, keys: keys.public } : scopeOptions;
+  const privateOptions = keys?.private ? { ...scopeOptions, keys: keys.private } : scopeOptions;
+  return {
+    public: getPublicRuntimeConfigScope(runtimeConfig, scopeId, publicOptions),
+    private: getPrivateRuntimeConfigScope(runtimeConfig, scopeId, privateOptions)
+  };
+}
+export {
+  createRuntimeConfigEnvKey,
+  createRuntimeConfigKey,
+  getPrivateRuntimeConfigScope,
+  getPublicRuntimeConfigScope,
+  getRuntimeConfigFragment,
+  getRuntimeConfigScope,
+  injectRuntimeEnvVars,
+  normalizeRuntimeConfigFragments,
+  projectRuntimeConfigEnvVars,
+  projectRuntimeConfigFragment,
+  projectRuntimeConfigNamespace,
+  projectRuntimeConfigNamespaces,
+  projectSectionedRuntimeConfig,
+  resolveRuntimeConfigValue,
+  resolveRuntimeConfigValueFromRuntimeConfig,
+  runtimeConfigVisibilities,
+  runtimeEnvValueToShellLiteral,
+  runtimeEnvVarsToShellAssignments,
+  runtimeEnvVarsToString,
+  stripRuntimeConfigScopePrefix,
+  toRuntimeConfigFragment,
+  toRuntimeEnvVars,
+  toSnakeUpperCase
+};

package/examples/context-input-key.ts

@@ -0,0 +1,46 @@
+import {
+  projectSectionedRuntimeConfig,
+  resolveRuntimeConfigValue,
+} from '@lorion-org/runtime-config';
+
+const runtimeConfig = projectSectionedRuntimeConfig(
+  [
+    {
+      scopeId: 'billing',
+      config: {
+        public: {
+          apiBase: '/api/billing',
+        },
+        tenants: {
+          tenantA: {
+            public: {
+              apiBase: '/tenant-a/billing',
+            },
+          },
+        },
+      },
+    },
+  ],
+  {
+    contextInputKey: 'tenants',
+    contextOutputKey: '__tenants',
+  },
+);
+
+console.log(runtimeConfig.public);
+// {
+//   billingApiBase: '/api/billing',
+//   __tenants: {
+//     tenantA: {
+//       billingApiBase: '/tenant-a/billing'
+//     }
+//   }
+// }
+
+console.log(
+  resolveRuntimeConfigValue(runtimeConfig.public, 'billing', 'apiBase', {
+    contextId: 'tenantA',
+    contextOutputKey: '__tenants',
+  }),
+);
+// '/tenant-a/billing'

package/examples/env-vars.ts

@@ -0,0 +1,25 @@
+import {
+  runtimeEnvVarsToShellAssignments,
+  runtimeEnvVarsToString,
+  toRuntimeEnvVars,
+} from '@lorion-org/runtime-config';
+
+const envVars = toRuntimeEnvVars(
+  {
+    public: {
+      billingApiBase: '/api/billing',
+    },
+    private: {
+      billingApiSecret: 'secret',
+    },
+  },
+  'APP',
+);
+
+console.log(runtimeEnvVarsToString(envVars));
+// APP_PUBLIC_BILLING_API_BASE=/api/billing
+// APP_PRIVATE_BILLING_API_SECRET=secret
+
+console.log(runtimeEnvVarsToShellAssignments(envVars));
+// APP_PUBLIC_BILLING_API_BASE='"/api/billing"'
+// APP_PRIVATE_BILLING_API_SECRET='"secret"'

package/examples/namespaced-runtime-config.ts

@@ -0,0 +1,50 @@
+import {
+  projectRuntimeConfigNamespace,
+  projectRuntimeConfigNamespaces,
+} from '@lorion-org/runtime-config';
+
+const billingRuntimeConfig = projectRuntimeConfigNamespace('billing', {
+  public: {
+    apiBase: '/api/billing',
+  },
+  private: {
+    token: 'billing-token',
+  },
+});
+
+console.log(billingRuntimeConfig.public.billing);
+// { apiBase: '/api/billing' }
+
+console.log(billingRuntimeConfig.billing);
+// { token: 'billing-token' }
+
+const combinedRuntimeConfig = projectRuntimeConfigNamespaces([
+  {
+    scopeId: 'billing',
+    config: {
+      public: {
+        apiBase: '/api/billing',
+      },
+      private: {
+        token: 'billing-token',
+      },
+    },
+  },
+  {
+    scopeId: 'mail',
+    config: {
+      public: {
+        apiBase: '/api/mail',
+      },
+    },
+  },
+]);
+
+console.log(combinedRuntimeConfig.public.billing);
+// { apiBase: '/api/billing' }
+
+console.log(combinedRuntimeConfig.public.mail);
+// { apiBase: '/api/mail' }
+
+console.log(combinedRuntimeConfig.billing);
+// { token: 'billing-token' }

package/examples/scope-view.ts

@@ -0,0 +1,32 @@
+import {
+  getPrivateRuntimeConfigScope,
+  getPublicRuntimeConfigScope,
+  projectRuntimeConfigFragment,
+  toRuntimeEnvVars,
+} from '@lorion-org/runtime-config';
+
+const runtimeConfig = projectRuntimeConfigFragment('auth', {
+  public: {
+    url: 'https://auth.example.test',
+    realm: 'main',
+  },
+  private: {
+    clientSecret: 'secret',
+  },
+});
+
+console.log(runtimeConfig.public.authUrl);
+// 'https://auth.example.test'
+
+console.log(toRuntimeEnvVars(runtimeConfig, 'APP'));
+// {
+//   APP_PUBLIC_AUTH_URL: 'https://auth.example.test',
+//   APP_PUBLIC_AUTH_REALM: 'main',
+//   APP_PRIVATE_AUTH_CLIENT_SECRET: 'secret'
+// }
+
+console.log(getPublicRuntimeConfigScope(runtimeConfig, 'auth'));
+// { url: 'https://auth.example.test', realm: 'main' }
+
+console.log(getPrivateRuntimeConfigScope(runtimeConfig, 'auth'));
+// { clientSecret: 'secret' }