tyfigo 0.1.0-next.f085cb0.0 → 0.1.0

package/README.md

@@ -2,22 +2,203 @@
 
 # tyfigo
 
-**Import YAML, TOML, JSON5, INI and .env files into TypeScript with full type inference.**
+**Typed, validated application config for TypeScript.**
 
 [![GitHub](https://img.shields.io/github/license/imranbarbhuiya/tyfigo)](https://github.com/imranbarbhuiya/tyfigo/blob/main/LICENSE)
 [![npm](https://img.shields.io/npm/v/tyfigo?color=crimson&logo=npm&style=flat-square)](https://www.npmjs.com/package/tyfigo)
 
 </div>
 
-> [!WARNING]
-> tyfigo is in early development and not usable yet.
+`import config from './app.config.yaml'` gives you the config for the current environment: the base file merged with
+`app.<env>.config.yaml` and your local overrides, `${PLACEHOLDERS}` filled in from `.env` files and the real environment, and
+the result deep-frozen. The type comes from the file through a TypeScript 7.1 content mapper that runs inside `tsc` and the
+editor, so there is no codegen step, and a wrong key or value in any layer is reported at its line in the config file. Add a
+Standard Schema (Zod, Valibot, ArkType, …) or an Effect Schema when you need ranges, URLs, enums or required variables.
+
+Read the documentation at [tyfigo.vercel.app](https://tyfigo.vercel.app).
 
 ## Install
 
+tyfigo needs TypeScript 7.1, the first release with content mappers, and Node 24 or later (or Bun).
+
 ```bash
 npm i tyfigo
+npm i -D typescript@7.1.0-beta
+```
+
+## Register the content mapper
+
+```jsonc
+// tsconfig.json
+{
+	"compilerOptions": {
+		"module": "nodenext",
+		"strict": true,
+		"noEmit": true,
+		"allowImportingTsExtensions": true,
+		"skipLibCheck": true,
+		"types": ["node"],
+	},
+	"contentMappers": [
+		{
+			"package": "tyfigo",
+			"extensions": [
+				".config.yaml",
+				".config.yml",
+				".config.toml",
+				".config.jsonc",
+				".config.json5",
+				".config.ini",
+				".config.properties",
+				".config.xml",
+			],
+		},
+	],
+	"include": ["src", "config"],
+}
+```
+
+`tsc` runs content mappers only with `--runExternalCode`:
+
+```json
+{
+	"scripts": {
+		"typecheck": "tsc --noEmit --runExternalCode"
+	}
+}
+```
+
+Including `config` makes tsc check environment and local files even when no code imports them directly. TypeScript 7 defaults `types` to `[]`, so list `node` (or `bun`) yourself. `skipLibCheck` keeps tsc from checking the bundler types that the plugin declarations reference, which you only have installed for the bundler you use.
+
+## Example
+
+```yaml
+# config/app.config.yaml
+server:
+    host: localhost
+    port: ${PORT:-3000}
+database:
+    url: ${DATABASE_URL}
+    pool:
+        max: 5
+features: [search]
+```
+
+```yaml
+# config/app.production.config.yaml
+server:
+    port: 8080
+    hostname: 0.0.0.0
+database:
+    pool:
+        max: twenty
+features: [search, 42]
+```
+
+```ts
+// src/main.ts
+import config from '../config/app.config.yaml';
+
+const port: string = config.server.port;
 ```
 
+The type of `config` comes from the base file, widened so other environments can change values:
+
+```ts
+// const config: {
+//   readonly server: { readonly host: string; readonly port: number };
+//   readonly database: { readonly url: string; readonly pool: { readonly max: number } };
+//   readonly features: readonly string[];
+// }
+```
+
+and `tsc --noEmit --runExternalCode` reports each mistake at its line in the YAML or the code:
+
+```txt
+config/app.production.config.yaml(3,5): error TS2353: Object literal may only specify known properties, and 'hostname' does not exist in type '{ readonly host?: string | undefined; readonly port?: number | undefined; }'.
+config/app.production.config.yaml(6,9): error TS2322: Type 'string' is not assignable to type 'number'.
+config/app.production.config.yaml(7,20): error TS2322: Type 'number' is not assignable to type 'string'.
+src/main.ts(3,7): error TS2322: Type 'number' is not assignable to type 'string'.
+```
+
+`database.url` has no default, so set `DATABASE_URL` (in `.env` or the environment) before you run the example. Without it, the import fails
+with `Environment variable 'DATABASE_URL' is not set (missing-variable)`.
+
+Layers are read in this order, each one winning over the last: `app.config.yaml`, `app.<env>.config.yaml`,
+`app.local.config.yaml`, `app.<env>.local.config.yaml`. The environment is `NODE_ENV` unless you pass `environment`.
+Placeholders (`${VAR}`, `${VAR:-default}`, `${VAR:?message}`) read `.env`, `.env.local`, `.env.<env>` and `.env.<env>.local`,
+with real environment variables on top. tyfigo never writes `process.env`.
+
+## Schemas
+
+`loadConfig` validates a config import and `loadEnv` validates environment variables, with any Standard Schema or an Effect
+Schema. Errors list every issue with the `file:line:column` the value came from.
+
+```ts
+import { loadConfig, loadEnv } from 'tyfigo';
+import { z } from 'zod';
+
+import config from '../config/app.config.yaml';
+
+const Config = z.object({
+	server: z.object({ host: z.string(), port: z.number().int().positive() }),
+	database: z.object({ url: z.url({ protocol: /^postgres$/ }) }),
+});
+
+const settings = loadConfig(config, Config);
+const env = loadEnv(z.object({ NODE_ENV: z.enum(['development', 'production', 'test']).default('development') }));
+```
+
+`loadConfigAsync` and `loadEnvAsync` take async schemas.
+
+## Effect
+
+`tyfigo/effect` has the same loaders returning Effects that fail with a typed `ConfigError`, plus `ConfigService`, layers and a
+`ConfigProvider` that reads a config file. See [Effect](https://tyfigo.vercel.app/docs/effect).
+
+## Runtimes and bundlers
+
+| Target                       | Setup                                                                                                | Example                                                                        |
+| ---------------------------- | ---------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------ |
+| Node 24+                     | `node --import tyfigo/register src/main.ts`                                                          | [node](https://github.com/imranbarbhuiya/tyfigo/tree/main/examples/node)       |
+| Bun                          | `preload = ["tyfigo/bun"]` in `bunfig.toml`; `plugins: [tyfigo()]` from `tyfigo/bun` in `Bun.build`  | [bun](https://github.com/imranbarbhuiya/tyfigo/tree/main/examples/bun)         |
+| nub                          | `"preload": ["tyfigo/register"]` in `nub.jsonc`                                                      | [nub](https://github.com/imranbarbhuiya/tyfigo/tree/main/examples/nub)         |
+| Vite and Vitest              | `plugins: [tyfigo()]` from `tyfigo/vite`                                                             | [vite](https://github.com/imranbarbhuiya/tyfigo/tree/main/examples/vite)       |
+| Next.js (webpack, Turbopack) | `export default withTyfigo({})` from `tyfigo/next`                                                   | [next](https://github.com/imranbarbhuiya/tyfigo/tree/main/examples/next)       |
+| esbuild and tsup             | `plugins: [tyfigo()]` (tsup: `esbuildPlugins`) from `tyfigo/esbuild`                                 | [esbuild](https://github.com/imranbarbhuiya/tyfigo/tree/main/examples/esbuild) |
+| Rollup                       | `plugins: [tyfigo({ target: 'server' })]` from `tyfigo/rollup` (defaults to browser)                 |                                                                                |
+| Rolldown and tsdown          | `plugins: [tyfigo()]` from `tyfigo/rolldown`                                                         |                                                                                |
+| webpack                      | `plugins: [tyfigo()]` from `tyfigo/webpack`                                                          | [webpack](https://github.com/imranbarbhuiya/tyfigo/tree/main/examples/webpack) |
+| Rspack and Rsbuild           | `plugins: [tyfigo()]` from `tyfigo/rspack` or `tyfigo/rsbuild`                                       | [rspack](https://github.com/imranbarbhuiya/tyfigo/tree/main/examples/rspack)   |
+| Jest                         | `'tyfigo/jest'` as the `transform` for config files, with their extensions in `moduleFileExtensions` | [jest](https://github.com/imranbarbhuiya/tyfigo/tree/main/examples/jest)       |
+
+Browser builds get the base and environment files inlined, and a `${VAR}` placeholder or an import of `loadEnv` in a client bundle
+fails the build. Server bundles fix the environment when they build: they inline the base, environment and local files, ignore
+`NODE_ENV` at run time for picking layers, and read `.env` files and environment variables when they start. See
+[Browser builds](https://tyfigo.vercel.app/docs/browser-builds).
+
+## Formats
+
+tyfigo reads seven formats under eight suffixes, since YAML takes both `.config.yaml` and `.config.yml`.
+
+| Suffix                        | Format        |
+| ----------------------------- | ------------- |
+| `.config.yaml`, `.config.yml` | YAML          |
+| `.config.toml`                | TOML          |
+| `.config.jsonc`               | JSONC         |
+| `.config.json5`               | JSON5         |
+| `.config.ini`                 | INI           |
+| `.config.properties`          | `.properties` |
+| `.config.xml`                 | XML           |
+
+## tyfigo and Motherload
+
+[Motherload](https://motherload.dev) also imports data files through TypeScript 7.1 content mappers, but it is a general data
+loader: import any `.yaml`, `.toml`, `.csv`, `.md` or other data file and get its contents, typed as `as const` would type them. tyfigo only claims `*.config.*` files and is for the settings your app reads at start-up: widened
+types, layered environment files checked against the base, placeholders and schema validation. They can share a project,
+since TypeScript gives each extension one owner and the longest suffix wins, so tyfigo can own `.config.yaml` while
+Motherload owns `.yaml`. See [tyfigo and Motherload](https://tyfigo.vercel.app/docs#tyfigo-and-motherload).
+
 ## Buy me some doughnuts
 
 If you want to support me by donating, you can do so by using any of the following methods. Thank you very much in advance!

package/dist/bun.d.mts

@@ -0,0 +1,7 @@
+import { BunPlugin } from "bun";
+/**
+ * The tyfigo Bun plugin. Importing `tyfigo/bun` (a `bunfig.toml` `preload`) registers it for the runtime and `bun test`; pass
+ * `tyfigo()` in `plugins` to use it with `Bun.build`, where a `browser` target inlines the config and a server target inlines the config files and reads `.env` files when it runs.
+ */
+export declare const tyfigo: () => BunPlugin;
+//# sourceMappingURL=bun.d.mts.map

package/dist/bun.mjs

@@ -0,0 +1,36 @@
+import { n as formatProblems } from "./problems-BNAqmOzL.mjs";
+import { t as configSuffixes } from "./formats-D_dKXoPf.mjs";
+import { t as load } from "./load-DxIjRpX6.mjs";
+import { extname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { plugin } from "bun";
+// src/bun.ts
+const runtime = fileURLToPath(new URL(`runtime/index${extname(import.meta.url)}`, import.meta.url));
+const filter = new RegExp(`[^/\\\\](?:${configSuffixes.map((suffix) => suffix.replaceAll(".", "\\.")).join("|")})$`);
+/**
+* The tyfigo Bun plugin. Importing `tyfigo/bun` (a `bunfig.toml` `preload`) registers it for the runtime and `bun test`; pass
+* `tyfigo()` in `plugins` to use it with `Bun.build`, where a `browser` target inlines the config and a server target inlines the config files and reads `.env` files when it runs.
+*/
+const tyfigo = () => ({
+	name: "tyfigo",
+	setup(build) {
+		const config = build.config;
+		const target = config?.target === "browser" ? "browser" : "server";
+		build.onLoad({ filter }, ({ path }) => {
+			const result = load(path, {
+				target,
+				runtime,
+				bundle: config !== void 0
+			});
+			if (result.problems.length > 0) throw new Error(`Invalid config ${path}\n${formatProblems(result.problems)}`);
+			return {
+				contents: result.code,
+				loader: "js"
+			};
+		});
+	}
+});
+plugin(tyfigo());
+export { tyfigo };
+
+//# sourceMappingURL=bun.mjs.map

package/dist/bun.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"bun.mjs","names":[],"sources":["../src/bun.ts"],"sourcesContent":["import { extname } from 'node:path';\nimport { fileURLToPath } from 'node:url';\n\nimport { plugin } from 'bun';\n\nimport { configSuffixes, formatProblems } from './core/index.ts';\nimport { load } from './runtime/index.ts';\n\nimport type { BunPlugin } from 'bun';\n\n// The runtime next to this module, so it resolves from config files outside the dependency tree: `.ts` in this repo, `.mjs` once built.\nconst runtime = fileURLToPath(new URL(`runtime/index${extname(import.meta.url)}`, import.meta.url));\n\nconst filter = new RegExp(`[^/\\\\\\\\](?:${configSuffixes.map((suffix) => suffix.replaceAll('.', '\\\\.')).join('|')})$`);\n\n/**\n * The tyfigo Bun plugin. Importing `tyfigo/bun` (a `bunfig.toml` `preload`) registers it for the runtime and `bun test`; pass\n * `tyfigo()` in `plugins` to use it with `Bun.build`, where a `browser` target inlines the config and a server target inlines the config files and reads `.env` files when it runs.\n */\nexport const tyfigo = (): BunPlugin => ({\n\tname: 'tyfigo',\n\tsetup(build) {\n\t\tconst config = build.config as typeof build.config | undefined;\n\t\tconst target = config?.target === 'browser' ? 'browser' : 'server';\n\t\tbuild.onLoad({ filter }, ({ path }) => {\n\t\t\tconst result = load(path, { target, runtime, bundle: config !== undefined });\n\t\t\tif (result.problems.length > 0) {\n\t\t\t\tthrow new Error(`Invalid config ${path}\\n${formatProblems(result.problems)}`);\n\t\t\t}\n\t\t\treturn { contents: result.code, loader: 'js' };\n\t\t});\n\t},\n});\n\nvoid plugin(tyfigo());\n"],"mappings":";;;;;;;AAWA,MAAM,UAAU,cAAc,IAAI,IAAI,gBAAgB,QAAQ,YAAY,GAAG,KAAK,YAAY,GAAG,CAAC;AAElG,MAAM,SAAS,IAAI,OAAO,cAAc,eAAe,KAAK,WAAW,OAAO,WAAW,KAAK,KAAK,CAAC,CAAC,CAAC,KAAK,GAAG,EAAE,GAAG;;;;;AAMnH,MAAa,gBAA2B;CACvC,MAAM;CACN,MAAM,OAAO;EACZ,MAAM,SAAS,MAAM;EACrB,MAAM,SAAS,QAAQ,WAAW,YAAY,YAAY;EAC1D,MAAM,OAAO,EAAE,OAAO,IAAI,EAAE,WAAW;GACtC,MAAM,SAAS,KAAK,MAAM;IAAE;IAAQ;IAAS,QAAQ,WAAW,KAAA;GAAU,CAAC;GAC3E,IAAI,OAAO,SAAS,SAAS,GAC5B,MAAM,IAAI,MAAM,kBAAkB,KAAK,IAAI,eAAe,OAAO,QAAQ,GAAG;GAE7E,OAAO;IAAE,UAAU,OAAO;IAAM,QAAQ;GAAK;EAC9C,CAAC;CACF;AACD;AAEK,OAAO,OAAO,CAAC"}

package/dist/effect.browser-Bhr-Yr7t.d.mts

@@ -0,0 +1,61 @@
+import "./index-jUM0zKD5.mjs";
+import { a as LooseInput, o as SchemaInput, r as ConfigValidationError, s as SchemaOutput } from "./schema-BsuU_Hup.mjs";
+import { ConfigProvider, Context, Effect, Layer, Schema } from "effect";
+import { StandardSchemaV1 } from "@standard-schema/spec";
+/**
+ * A Standard Schema or any Effect Schema, including one that needs services to decode.
+ */
+type EffectConfigSchema = StandardSchemaV1 | Schema.Top;
+/**
+ * The services an Effect Schema needs to decode, or `never` for a Standard Schema.
+ */
+type SchemaServices<S> = S extends StandardSchemaV1 ? never : S extends Schema.Top ? S['DecodingServices'] : never;
+/**
+ * The error of every tyfigo Effect: a config or the environment does not match its schema, or a config file could not
+ * be resolved. It is the same class the Promise API throws, tagged `ConfigValidationError`.
+ */
+declare const ConfigError: typeof ConfigValidationError;
+type ConfigError = ConfigValidationError;
+/**
+ * Validates a config import (or any value) with a Standard Schema or an Effect Schema. Effect Schemas are decoded by
+ * Effect itself, so schemas that need services or decode asynchronously work, and so do async Standard Schemas.
+ */
+declare const loadConfig: <S extends EffectConfigSchema>(config: LooseInput<SchemaInput<S>>, schema: S) => Effect.Effect<SchemaOutput<S>, ConfigError, SchemaServices<S>>;
+/**
+ * A layer that provides `service` with the validated config.
+ */
+declare const layerConfig: <I, S extends EffectConfigSchema>(service: Context.Key<I, SchemaOutput<S>>, config: LooseInput<SchemaInput<S>>, schema: S) => Layer.Layer<I, ConfigError, SchemaServices<S>>;
+/**
+ * Defines a service class for a validated config, with a `layer` that provides it.
+ *
+ * @example
+ * ```ts
+ * class AppConfig extends ConfigService<AppConfig>()('app/AppConfig', config, schema) {}
+ *
+ * const program = Effect.gen(function* () {
+ * 	const { port } = yield* AppConfig;
+ * }).pipe(Effect.provide(AppConfig.layer));
+ * ```
+ */
+declare const ConfigService: <Self>() => <const Identifier extends string, S extends EffectConfigSchema>(id: Identifier, config: LooseInput<SchemaInput<S>>, schema: S) => Context.ServiceClass<Self, Identifier, SchemaOutput<S>> & {
+  layer: Layer.Layer<Self, ConfigValidationError, Exclude<SchemaServices<S>, import("effect/Scope").Scope>>;
+};
+interface ConfigProviderLayerOptions {
+  /**
+   * Whether the config files win over the provider already installed (by default the environment variables). Defaults to
+   * `true`; with `false` the config files only fill in paths the current provider does not have.
+   */
+  readonly asPrimary?: boolean | undefined;
+}
+/**
+ * A `ConfigProvider` that reads a config import (or any object): nested keys are path segments and array items are
+ * numeric segments, so `Config.Number('port').pipe(Config.nested('server'))` reads `server.port`. Empty strings are kept.
+ */
+declare const configProvider: (config: unknown) => ConfigProvider.ConfigProvider;
+/**
+ * Installs {@link configProvider} for a config import on top of the current `ConfigProvider`, which falls back to the
+ * environment variables for paths the config does not have.
+ */
+declare const layerConfigProvider: (config: unknown, options?: ConfigProviderLayerOptions) => Layer.Layer<never>;
+export { ConfigService as a, layerConfig as c, ConfigError as i, loadConfig as l, configProvider as n, EffectConfigSchema as o, layerConfigProvider as r, SchemaServices as s, ConfigProviderLayerOptions as t };
+//# sourceMappingURL=effect.browser-Bhr-Yr7t.d.mts.map

package/dist/effect.browser-CO87TEE_.mjs

@@ -0,0 +1,50 @@
+import { n as decodeConfig, t as ConfigValidationError } from "./schema-DcD4N9N-.mjs";
+import { ConfigProvider, Context, Layer } from "effect";
+// src/effect/load.ts
+/**
+* The error of every tyfigo Effect: a config or the environment does not match its schema, or a config file could not
+* be resolved. It is the same class the Promise API throws, tagged `ConfigValidationError`.
+*/
+const ConfigError = ConfigValidationError;
+/**
+* Validates a config import (or any value) with a Standard Schema or an Effect Schema. Effect Schemas are decoded by
+* Effect itself, so schemas that need services or decode asynchronously work, and so do async Standard Schemas.
+*/
+const loadConfig = (config, schema) => decodeConfig(config, schema, {
+	async: true,
+	native: true
+});
+/**
+* A layer that provides `service` with the validated config.
+*/
+const layerConfig = (service, config, schema) => Layer.effect(service, loadConfig(config, schema));
+/**
+* Defines a service class for a validated config, with a `layer` that provides it.
+*
+* @example
+* ```ts
+* class AppConfig extends ConfigService<AppConfig>()('app/AppConfig', config, schema) {}
+*
+* const program = Effect.gen(function* () {
+* 	const { port } = yield* AppConfig;
+* }).pipe(Effect.provide(AppConfig.layer));
+* ```
+*/
+const ConfigService = () => (id, config, schema) => {
+	const service = Context.Service()(id);
+	return Object.assign(service, { layer: Layer.effect(service, loadConfig(config, schema)) });
+};
+// src/effect/provider.ts
+/**
+* A `ConfigProvider` that reads a config import (or any object): nested keys are path segments and array items are
+* numeric segments, so `Config.Number('port').pipe(Config.nested('server'))` reads `server.port`. Empty strings are kept.
+*/
+const configProvider = (config) => ConfigProvider.fromUnknown(config, { preserveEmptyStrings: true });
+/**
+* Installs {@link configProvider} for a config import on top of the current `ConfigProvider`, which falls back to the
+* environment variables for paths the config does not have.
+*/
+const layerConfigProvider = (config, options = {}) => ConfigProvider.layerAdd(configProvider(config), { asPrimary: options.asPrimary ?? true });
+export { layerConfig as a, ConfigService as i, layerConfigProvider as n, loadConfig as o, ConfigError as r, configProvider as t };
+
+//# sourceMappingURL=effect.browser-CO87TEE_.mjs.map

package/dist/effect.browser-CO87TEE_.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect.browser-CO87TEE_.mjs","names":[],"sources":["../src/effect/load.ts","../src/effect/provider.ts"],"sourcesContent":["import { Context, Layer } from 'effect';\n\nimport { ConfigValidationError, decodeConfig } from '../schema.ts';\n\nimport type { ConfigSchema, LooseInput, SchemaInput, SchemaOutput } from '../schema.ts';\nimport type { StandardSchemaV1 } from '@standard-schema/spec';\nimport type { Effect, Schema } from 'effect';\n\n/**\n * A Standard Schema or any Effect Schema, including one that needs services to decode.\n */\nexport type EffectConfigSchema = StandardSchemaV1 | Schema.Top;\n\n/**\n * The services an Effect Schema needs to decode, or `never` for a Standard Schema.\n */\nexport type SchemaServices<S> = S extends StandardSchemaV1\n\t? never\n\t: S extends Schema.Top\n\t\t? S['DecodingServices']\n\t\t: never;\n\n/**\n * The error of every tyfigo Effect: a config or the environment does not match its schema, or a config file could not\n * be resolved. It is the same class the Promise API throws, tagged `ConfigValidationError`.\n */\nexport const ConfigError = ConfigValidationError;\nexport type ConfigError = ConfigValidationError;\n\n/**\n * Validates a config import (or any value) with a Standard Schema or an Effect Schema. Effect Schemas are decoded by\n * Effect itself, so schemas that need services or decode asynchronously work, and so do async Standard Schemas.\n */\nexport const loadConfig = <S extends EffectConfigSchema>(\n\tconfig: LooseInput<SchemaInput<S>>,\n\tschema: S,\n): Effect.Effect<SchemaOutput<S>, ConfigError, SchemaServices<S>> =>\n\tdecodeConfig(config, schema as ConfigSchema, { async: true, native: true }) as Effect.Effect<\n\t\tSchemaOutput<S>,\n\t\tConfigError,\n\t\tSchemaServices<S>\n\t>;\n\n/**\n * A layer that provides `service` with the validated config.\n */\nexport const layerConfig = <I, S extends EffectConfigSchema>(\n\tservice: Context.Key<I, SchemaOutput<S>>,\n\tconfig: LooseInput<SchemaInput<S>>,\n\tschema: S,\n): Layer.Layer<I, ConfigError, SchemaServices<S>> => Layer.effect(service, loadConfig(config, schema));\n\n/**\n * Defines a service class for a validated config, with a `layer` that provides it.\n *\n * @example\n * ```ts\n * class AppConfig extends ConfigService<AppConfig>()('app/AppConfig', config, schema) {}\n *\n * const program = Effect.gen(function* () {\n * \tconst { port } = yield* AppConfig;\n * }).pipe(Effect.provide(AppConfig.layer));\n * ```\n */\nexport const ConfigService =\n\t<Self>() =>\n\t<const Identifier extends string, S extends EffectConfigSchema>(\n\t\tid: Identifier,\n\t\tconfig: LooseInput<SchemaInput<S>>,\n\t\tschema: S,\n\t) => {\n\t\tconst service = Context.Service<Self, SchemaOutput<S>>()(id);\n\t\treturn Object.assign(service, {\n\t\t\tlayer: Layer.effect(service, loadConfig(config, schema)),\n\t\t});\n\t};\n","import { ConfigProvider } from 'effect';\n\nimport type { Layer } from 'effect';\n\nexport interface ConfigProviderLayerOptions {\n\t/**\n\t * Whether the config files win over the provider already installed (by default the environment variables). Defaults to\n\t * `true`; with `false` the config files only fill in paths the current provider does not have.\n\t */\n\treadonly asPrimary?: boolean | undefined;\n}\n\n/**\n * A `ConfigProvider` that reads a config import (or any object): nested keys are path segments and array items are\n * numeric segments, so `Config.Number('port').pipe(Config.nested('server'))` reads `server.port`. Empty strings are kept.\n */\nexport const configProvider = (config: unknown): ConfigProvider.ConfigProvider =>\n\tConfigProvider.fromUnknown(config, { preserveEmptyStrings: true });\n\n/**\n * Installs {@link configProvider} for a config import on top of the current `ConfigProvider`, which falls back to the\n * environment variables for paths the config does not have.\n */\nexport const layerConfigProvider = (config: unknown, options: ConfigProviderLayerOptions = {}): Layer.Layer<never> =>\n\tConfigProvider.layerAdd(configProvider(config), { asPrimary: options.asPrimary ?? true });\n"],"mappings":";;;;;;;AA0BA,MAAa,cAAc;;;;;AAO3B,MAAa,cACZ,QACA,WAEA,aAAa,QAAQ,QAAwB;CAAE,OAAO;CAAM,QAAQ;AAAK,CAAC;;;;AAS3E,MAAa,eACZ,SACA,QACA,WACoD,MAAM,OAAO,SAAS,WAAW,QAAQ,MAAM,CAAC;;;;;;;;;;;;;AAcrG,MAAa,uBAGX,IACA,QACA,WACI;CACJ,MAAM,UAAU,QAAQ,QAA+B,CAAC,CAAC,EAAE;CAC3D,OAAO,OAAO,OAAO,SAAS,EAC7B,OAAO,MAAM,OAAO,SAAS,WAAW,QAAQ,MAAM,CAAC,EACxD,CAAC;AACF;;;;;;AC3DD,MAAa,kBAAkB,WAC9B,eAAe,YAAY,QAAQ,EAAE,sBAAsB,KAAK,CAAC;;;;;AAMlE,MAAa,uBAAuB,QAAiB,UAAsC,CAAC,MAC3F,eAAe,SAAS,eAAe,MAAM,GAAG,EAAE,WAAW,QAAQ,aAAa,KAAK,CAAC"}

package/dist/effect.browser.d.mts

@@ -0,0 +1,5 @@
+import { a as LocatedSpan, c as Path, i as ResolvedLayer, l as Span, n as ResolveOptions, o as Problem, r as ResolvedConfig, s as ProblemCode } from "./index-jUM0zKD5.mjs";
+import { t as ConfigSource } from "./source-BWf_Y0YZ.mjs";
+import { a as LooseInput, i as LoadEnvOptions, n as ConfigSchema, o as SchemaInput, r as ConfigValidationError, s as SchemaOutput, t as ConfigIssue } from "./schema-BsuU_Hup.mjs";
+import { a as ConfigService, c as layerConfig, i as ConfigError, l as loadConfig, n as configProvider, o as EffectConfigSchema, r as layerConfigProvider, s as SchemaServices, t as ConfigProviderLayerOptions } from "./effect.browser-Bhr-Yr7t.mjs";
+export { ConfigError, type ConfigIssue, ConfigProviderLayerOptions, type ConfigSchema, ConfigService, type ConfigSource, ConfigValidationError, EffectConfigSchema, type LoadEnvOptions, type LocatedSpan, type LooseInput, type Path, type Problem, type ProblemCode, type ResolveOptions, type ResolvedConfig, type ResolvedLayer, type SchemaInput, type SchemaOutput, SchemaServices, type Span, configProvider, layerConfig, layerConfigProvider, loadConfig };

package/dist/effect.browser.mjs

@@ -0,0 +1,3 @@
+import { t as ConfigValidationError } from "./schema-DcD4N9N-.mjs";
+import { a as layerConfig, i as ConfigService, n as layerConfigProvider, o as loadConfig, r as ConfigError, t as configProvider } from "./effect.browser-CO87TEE_.mjs";
+export { ConfigError, ConfigService, ConfigValidationError, configProvider, layerConfig, layerConfigProvider, loadConfig };

package/dist/effect.d.mts

@@ -1,79 +1,25 @@
-import { d as ResolvedLayer, f as LocatedSpan, g as Span, h as Path, l as ResolveOptions, m as ProblemCode, p as Problem, r as ConfigSource, u as ResolvedConfig } from "./resolve-BeFHJeZb.mjs";
-import { a as LooseInput, i as LoadEnvOptions, n as ConfigSchema, o as SchemaInput, r as ConfigValidationError, s as SchemaOutput, t as ConfigIssue } from "./schema-CNquZBC8.mjs";
-import { ConfigProvider, Context, Effect, Layer, Schema } from "effect";
-import { StandardSchemaV1 } from "@standard-schema/spec";
-/**
- * A Standard Schema or any Effect Schema, including one that needs services to decode.
- */
-export type EffectConfigSchema = StandardSchemaV1 | Schema.Top;
-/**
- * The services an Effect Schema needs to decode, or `never` for a Standard Schema.
- */
-export type SchemaServices<S> = S extends StandardSchemaV1 ? never : S extends Schema.Top ? S['DecodingServices'] : never;
-/**
- * The error of every tyfigo Effect: a config or the environment does not match its schema, or a config file could not
- * be resolved. It is the same class the Promise API throws, tagged `ConfigValidationError`.
- */
-export declare const ConfigError: typeof ConfigValidationError;
-export type ConfigError = ConfigValidationError;
-/**
- * Validates a config import (or any value) with a Standard Schema or an Effect Schema. Effect Schemas are decoded by
- * Effect itself, so schemas that need services or decode asynchronously work, and so do async Standard Schemas.
- */
-export declare const loadConfig: <S extends EffectConfigSchema>(config: LooseInput<SchemaInput<S>>, schema: S) => Effect.Effect<SchemaOutput<S>, ConfigError, SchemaServices<S>>;
+import { a as LocatedSpan, c as Path, i as ResolvedLayer, l as Span, n as ResolveOptions, o as Problem, r as ResolvedConfig, s as ProblemCode } from "./index-jUM0zKD5.mjs";
+import { t as ConfigSource } from "./source-BWf_Y0YZ.mjs";
+import { a as LooseInput, i as LoadEnvOptions, n as ConfigSchema, o as SchemaInput, r as ConfigValidationError, s as SchemaOutput, t as ConfigIssue } from "./schema-BsuU_Hup.mjs";
+import { a as ConfigService, c as layerConfig, i as ConfigError, l as loadConfig, n as configProvider, o as EffectConfigSchema, r as layerConfigProvider, s as SchemaServices, t as ConfigProviderLayerOptions } from "./effect.browser-Bhr-Yr7t.mjs";
+import { ConfigProvider, Context, Effect, Layer } from "effect";
 /**
  * Validates `.env`, `.env.local`, `.env.<environment>` and `.env.<environment>.local` with the real environment on top.
  * Never writes `process.env`.
  */
 export declare const loadEnv: <S extends EffectConfigSchema>(schema: S, options?: LoadEnvOptions) => Effect.Effect<SchemaOutput<S>, ConfigError, SchemaServices<S>>;
-/**
- * A layer that provides `service` with the validated config.
- */
-export declare const layerConfig: <I, S extends EffectConfigSchema>(service: Context.Key<I, SchemaOutput<S>>, config: LooseInput<SchemaInput<S>>, schema: S) => Layer.Layer<I, ConfigError, SchemaServices<S>>;
 /**
  * A layer that provides `service` with the validated environment variables.
  */
 export declare const layerEnv: <I, S extends EffectConfigSchema>(service: Context.Key<I, SchemaOutput<S>>, schema: S, options?: LoadEnvOptions) => Layer.Layer<I, ConfigError, SchemaServices<S>>;
-/**
- * Defines a service class for a validated config, with a `layer` that provides it.
- *
- * @example
- * ```ts
- * class AppConfig extends ConfigService<AppConfig>()('app/AppConfig', config, schema) {}
- *
- * const program = Effect.gen(function* () {
- * 	const { port } = yield* AppConfig;
- * }).pipe(Effect.provide(AppConfig.layer));
- * ```
- */
-export declare const ConfigService: <Self>() => <const Identifier extends string, S extends EffectConfigSchema>(id: Identifier, config: LooseInput<SchemaInput<S>>, schema: S) => Context.ServiceClass<Self, Identifier, SchemaOutput<S>> & {
-  layer: Layer.Layer<Self, ConfigValidationError, Exclude<SchemaServices<S>, import("effect/Scope").Scope>>;
-};
-export interface ConfigProviderLayerOptions {
-  /**
-   * Whether the config files win over the provider already installed (by default the environment variables). Defaults to
-   * `true`; with `false` the config files only fill in paths the current provider does not have.
-   */
-  readonly asPrimary?: boolean | undefined;
-}
-/**
- * A `ConfigProvider` that reads a config import (or any object): nested keys are path segments and array items are
- * numeric segments, so `Config.Number('port').pipe(Config.nested('server'))` reads `server.port`. Empty strings are kept.
- */
-export declare const configProvider: (config: unknown) => ConfigProvider.ConfigProvider;
 /**
  * Resolves a config file with its layers, `.env` files and placeholders, like a config import does, and returns a
  * `ConfigProvider` over the merged value.
  */
 export declare const configProviderFromFile: (file: string, options?: ResolveOptions | undefined) => Effect.Effect<ConfigProvider.ConfigProvider, ConfigValidationError, never>;
-/**
- * Installs {@link configProvider} for a config import on top of the current `ConfigProvider`, which falls back to the
- * environment variables for paths the config does not have.
- */
-export declare const layerConfigProvider: (config: unknown, options?: ConfigProviderLayerOptions) => Layer.Layer<never>;
 /**
  * Installs {@link configProviderFromFile} on top of the current `ConfigProvider`.
  */
 export declare const layerConfigProviderFromFile: (file: string, options?: ResolveOptions & ConfigProviderLayerOptions) => Layer.Layer<never, ConfigError>;
-export { type ConfigIssue, type ConfigSchema, type ConfigSource, ConfigValidationError, type LoadEnvOptions, type LocatedSpan, type LooseInput, type Path, type Problem, type ProblemCode, type ResolveOptions, type ResolvedConfig, type ResolvedLayer, type SchemaInput, type SchemaOutput, type Span };
+export { ConfigError, type ConfigIssue, ConfigProviderLayerOptions, type ConfigSchema, ConfigService, type ConfigSource, ConfigValidationError, EffectConfigSchema, type LoadEnvOptions, type LocatedSpan, type LooseInput, type Path, type Problem, type ProblemCode, type ResolveOptions, type ResolvedConfig, type ResolvedLayer, type SchemaInput, type SchemaOutput, SchemaServices, type Span, configProvider, layerConfig, layerConfigProvider, loadConfig };
 //# sourceMappingURL=effect.d.mts.map

package/dist/effect.mjs

@@ -1,20 +1,9 @@
-import { o as resolveConfig } from "./resolve-CDWA58rz.mjs";
-import { n as decodeConfig, r as decodeEnv, t as ConfigValidationError } from "./schema-C31aywfc.mjs";
-import { ConfigProvider, Context, Effect, Layer } from "effect";
-// src/effect/load.ts
-/**
-* The error of every tyfigo Effect: a config or the environment does not match its schema, or a config file could not
-* be resolved. It is the same class the Promise API throws, tagged `ConfigValidationError`.
-*/
-const ConfigError = ConfigValidationError;
-/**
-* Validates a config import (or any value) with a Standard Schema or an Effect Schema. Effect Schemas are decoded by
-* Effect itself, so schemas that need services or decode asynchronously work, and so do async Standard Schemas.
-*/
-const loadConfig = (config, schema) => decodeConfig(config, schema, {
-	async: true,
-	native: true
-});
+import { t as ConfigValidationError } from "./schema-DcD4N9N-.mjs";
+import { t as decodeEnv } from "./env-Bd-1Atoz.mjs";
+import { a as layerConfig, i as ConfigService, n as layerConfigProvider, o as loadConfig, r as ConfigError, t as configProvider } from "./effect.browser-CO87TEE_.mjs";
+import { t as resolveConfig } from "./resolve-D3geHCGs.mjs";
+import { ConfigProvider, Effect, Layer } from "effect";
+// src/effect/env.ts
 /**
 * Validates `.env`, `.env.local`, `.env.<environment>` and `.env.<environment>.local` with the real environment on top.
 * Never writes `process.env`.
@@ -25,35 +14,10 @@ const loadEnv = (schema, options = {}) => decodeEnv(schema, {
 	native: true
 });
 /**
-* A layer that provides `service` with the validated config.
-*/
-const layerConfig = (service, config, schema) => Layer.effect(service, loadConfig(config, schema));
-/**
 * A layer that provides `service` with the validated environment variables.
 */
 const layerEnv = (service, schema, options = {}) => Layer.effect(service, loadEnv(schema, options));
-/**
-* Defines a service class for a validated config, with a `layer` that provides it.
-*
-* @example
-* ```ts
-* class AppConfig extends ConfigService<AppConfig>()('app/AppConfig', config, schema) {}
-*
-* const program = Effect.gen(function* () {
-* 	const { port } = yield* AppConfig;
-* }).pipe(Effect.provide(AppConfig.layer));
-* ```
-*/
-const ConfigService = () => (id, config, schema) => {
-	const service = Context.Service()(id);
-	return Object.assign(service, { layer: Layer.effect(service, loadConfig(config, schema)) });
-};
-// src/effect/provider.ts
-/**
-* A `ConfigProvider` that reads a config import (or any object): nested keys are path segments and array items are
-* numeric segments, so `Config.Number('port').pipe(Config.nested('server'))` reads `server.port`. Empty strings are kept.
-*/
-const configProvider = (config) => ConfigProvider.fromUnknown(config, { preserveEmptyStrings: true });
+// src/effect/file-provider.ts
 /**
 * Resolves a config file with its layers, `.env` files and placeholders, like a config import does, and returns a
 * `ConfigProvider` over the merged value.
@@ -71,11 +35,6 @@ const configProviderFromFile = Effect.fn("configProviderFromFile")(function* (fi
 	return configProvider(result.value);
 });
 /**
-* Installs {@link configProvider} for a config import on top of the current `ConfigProvider`, which falls back to the
-* environment variables for paths the config does not have.
-*/
-const layerConfigProvider = (config, options = {}) => ConfigProvider.layerAdd(configProvider(config), { asPrimary: options.asPrimary ?? true });
-/**
 * Installs {@link configProviderFromFile} on top of the current `ConfigProvider`.
 */
 const layerConfigProviderFromFile = (file, options = {}) => ConfigProvider.layerAdd(configProviderFromFile(file, options), { asPrimary: options.asPrimary ?? true });

package/dist/effect.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"effect.mjs","names":[],"sources":["../src/effect/load.ts","../src/effect/provider.ts"],"sourcesContent":["import { Context, Layer } from 'effect';\n\nimport { ConfigValidationError, decodeConfig, decodeEnv } from '../schema.ts';\n\nimport type { ConfigSchema, LoadEnvOptions, LooseInput, SchemaInput, SchemaOutput } from '../schema.ts';\nimport type { StandardSchemaV1 } from '@standard-schema/spec';\nimport type { Effect, Schema } from 'effect';\n\n/**\n * A Standard Schema or any Effect Schema, including one that needs services to decode.\n */\nexport type EffectConfigSchema = StandardSchemaV1 | Schema.Top;\n\n/**\n * The services an Effect Schema needs to decode, or `never` for a Standard Schema.\n */\nexport type SchemaServices<S> = S extends StandardSchemaV1\n\t? never\n\t: S extends Schema.Top\n\t\t? S['DecodingServices']\n\t\t: never;\n\n/**\n * The error of every tyfigo Effect: a config or the environment does not match its schema, or a config file could not\n * be resolved. It is the same class the Promise API throws, tagged `ConfigValidationError`.\n */\nexport const ConfigError = ConfigValidationError;\nexport type ConfigError = ConfigValidationError;\n\n/**\n * Validates a config import (or any value) with a Standard Schema or an Effect Schema. Effect Schemas are decoded by\n * Effect itself, so schemas that need services or decode asynchronously work, and so do async Standard Schemas.\n */\nexport const loadConfig = <S extends EffectConfigSchema>(\n\tconfig: LooseInput<SchemaInput<S>>,\n\tschema: S,\n): Effect.Effect<SchemaOutput<S>, ConfigError, SchemaServices<S>> =>\n\tdecodeConfig(config, schema as ConfigSchema, { async: true, native: true }) as Effect.Effect<\n\t\tSchemaOutput<S>,\n\t\tConfigError,\n\t\tSchemaServices<S>\n\t>;\n\n/**\n * Validates `.env`, `.env.local`, `.env.<environment>` and `.env.<environment>.local` with the real environment on top.\n * Never writes `process.env`.\n */\nexport const loadEnv = <S extends EffectConfigSchema>(\n\tschema: S,\n\toptions: LoadEnvOptions = {},\n): Effect.Effect<SchemaOutput<S>, ConfigError, SchemaServices<S>> =>\n\tdecodeEnv(schema as ConfigSchema, { ...options, async: true, native: true }) as Effect.Effect<\n\t\tSchemaOutput<S>,\n\t\tConfigError,\n\t\tSchemaServices<S>\n\t>;\n\n/**\n * A layer that provides `service` with the validated config.\n */\nexport const layerConfig = <I, S extends EffectConfigSchema>(\n\tservice: Context.Key<I, SchemaOutput<S>>,\n\tconfig: LooseInput<SchemaInput<S>>,\n\tschema: S,\n): Layer.Layer<I, ConfigError, SchemaServices<S>> => Layer.effect(service, loadConfig(config, schema));\n\n/**\n * A layer that provides `service` with the validated environment variables.\n */\nexport const layerEnv = <I, S extends EffectConfigSchema>(\n\tservice: Context.Key<I, SchemaOutput<S>>,\n\tschema: S,\n\toptions: LoadEnvOptions = {},\n): Layer.Layer<I, ConfigError, SchemaServices<S>> => Layer.effect(service, loadEnv(schema, options));\n\n/**\n * Defines a service class for a validated config, with a `layer` that provides it.\n *\n * @example\n * ```ts\n * class AppConfig extends ConfigService<AppConfig>()('app/AppConfig', config, schema) {}\n *\n * const program = Effect.gen(function* () {\n * \tconst { port } = yield* AppConfig;\n * }).pipe(Effect.provide(AppConfig.layer));\n * ```\n */\nexport const ConfigService =\n\t<Self>() =>\n\t<const Identifier extends string, S extends EffectConfigSchema>(\n\t\tid: Identifier,\n\t\tconfig: LooseInput<SchemaInput<S>>,\n\t\tschema: S,\n\t) => {\n\t\tconst service = Context.Service<Self, SchemaOutput<S>>()(id);\n\t\treturn Object.assign(service, {\n\t\t\tlayer: Layer.effect(service, loadConfig(config, schema)),\n\t\t});\n\t};\n","import { ConfigProvider, Effect } from 'effect';\n\nimport { resolveConfig } from '../core/resolve.ts';\nimport { ConfigValidationError } from '../schema.ts';\n\nimport type { ResolveOptions } from '../core/resolve.ts';\nimport type { ConfigError } from './load.ts';\nimport type { Layer } from 'effect';\n\nexport interface ConfigProviderLayerOptions {\n\t/**\n\t * Whether the config files win over the provider already installed (by default the environment variables). Defaults to\n\t * `true`; with `false` the config files only fill in paths the current provider does not have.\n\t */\n\treadonly asPrimary?: boolean | undefined;\n}\n\n/**\n * A `ConfigProvider` that reads a config import (or any object): nested keys are path segments and array items are\n * numeric segments, so `Config.Number('port').pipe(Config.nested('server'))` reads `server.port`. Empty strings are kept.\n */\nexport const configProvider = (config: unknown): ConfigProvider.ConfigProvider =>\n\tConfigProvider.fromUnknown(config, { preserveEmptyStrings: true });\n\n/**\n * Resolves a config file with its layers, `.env` files and placeholders, like a config import does, and returns a\n * `ConfigProvider` over the merged value.\n */\nexport const configProviderFromFile = Effect.fn('configProviderFromFile')(function* (\n\tfile: string,\n\toptions: ResolveOptions = {},\n): Effect.fn.Return<ConfigProvider.ConfigProvider, ConfigError> {\n\tconst result = yield* resolveConfig(file, options);\n\tif (result.problems.length > 0) {\n\t\treturn yield* new ConfigValidationError({\n\t\t\tsubject: `config ${result.file}`,\n\t\t\tissues: result.problems.map((problem) => ({\n\t\t\t\tpath: [],\n\t\t\t\tmessage: `${problem.message} (${problem.code})`,\n\t\t\t\tlocation: `${problem.file}:${problem.line}:${problem.column}`,\n\t\t\t})),\n\t\t});\n\t}\n\treturn configProvider(result.value);\n});\n\n/**\n * Installs {@link configProvider} for a config import on top of the current `ConfigProvider`, which falls back to the\n * environment variables for paths the config does not have.\n */\nexport const layerConfigProvider = (config: unknown, options: ConfigProviderLayerOptions = {}): Layer.Layer<never> =>\n\tConfigProvider.layerAdd(configProvider(config), { asPrimary: options.asPrimary ?? true });\n\n/**\n * Installs {@link configProviderFromFile} on top of the current `ConfigProvider`.\n */\nexport const layerConfigProviderFromFile = (\n\tfile: string,\n\toptions: ResolveOptions & ConfigProviderLayerOptions = {},\n): Layer.Layer<never, ConfigError> =>\n\tConfigProvider.layerAdd(configProviderFromFile(file, options), { asPrimary: options.asPrimary ?? true });\n"],"mappings":";;;;;;;;AA0BA,MAAa,cAAc;;;;;AAO3B,MAAa,cACZ,QACA,WAEA,aAAa,QAAQ,QAAwB;CAAE,OAAO;CAAM,QAAQ;AAAK,CAAC;;;;;AAU3E,MAAa,WACZ,QACA,UAA0B,CAAC,MAE3B,UAAU,QAAwB;CAAE,GAAG;CAAS,OAAO;CAAM,QAAQ;AAAK,CAAC;;;;AAS5E,MAAa,eACZ,SACA,QACA,WACoD,MAAM,OAAO,SAAS,WAAW,QAAQ,MAAM,CAAC;;;;AAKrG,MAAa,YACZ,SACA,QACA,UAA0B,CAAC,MACyB,MAAM,OAAO,SAAS,QAAQ,QAAQ,OAAO,CAAC;;;;;;;;;;;;;AAcnG,MAAa,uBAGX,IACA,QACA,WACI;CACJ,MAAM,UAAU,QAAQ,QAA+B,CAAC,CAAC,EAAE;CAC3D,OAAO,OAAO,OAAO,SAAS,EAC7B,OAAO,MAAM,OAAO,SAAS,WAAW,QAAQ,MAAM,CAAC,EACxD,CAAC;AACF;;;;;;AC7ED,MAAa,kBAAkB,WAC9B,eAAe,YAAY,QAAQ,EAAE,sBAAsB,KAAK,CAAC;;;;;AAMlE,MAAa,yBAAyB,OAAO,GAAG,wBAAwB,CAAC,CAAC,WACzE,MACA,UAA0B,CAAC,GACoC;CAC/D,MAAM,SAAS,OAAO,cAAc,MAAM,OAAO;CACjD,IAAI,OAAO,SAAS,SAAS,GAC5B,OAAO,OAAO,IAAI,sBAAsB;EACvC,SAAS,UAAU,OAAO;EAC1B,QAAQ,OAAO,SAAS,KAAK,aAAa;GACzC,MAAM,CAAC;GACP,SAAS,GAAG,QAAQ,QAAQ,IAAI,QAAQ,KAAK;GAC7C,UAAU,GAAG,QAAQ,KAAK,GAAG,QAAQ,KAAK,GAAG,QAAQ;EACtD,EAAE;CACH,CAAC;CAEF,OAAO,eAAe,OAAO,KAAK;AACnC,CAAC;;;;;AAMD,MAAa,uBAAuB,QAAiB,UAAsC,CAAC,MAC3F,eAAe,SAAS,eAAe,MAAM,GAAG,EAAE,WAAW,QAAQ,aAAa,KAAK,CAAC;;;;AAKzF,MAAa,+BACZ,MACA,UAAuD,CAAC,MAExD,eAAe,SAAS,uBAAuB,MAAM,OAAO,GAAG,EAAE,WAAW,QAAQ,aAAa,KAAK,CAAC"}
+{"version":3,"file":"effect.mjs","names":[],"sources":["../src/effect/env.ts","../src/effect/file-provider.ts"],"sourcesContent":["import { Layer } from 'effect';\n\nimport { decodeEnv } from '../env.ts';\n\nimport type { ConfigSchema, LoadEnvOptions, SchemaOutput } from '../schema.ts';\nimport type { ConfigError, EffectConfigSchema, SchemaServices } from './load.ts';\nimport type { Context, Effect } from 'effect';\n\n/**\n * Validates `.env`, `.env.local`, `.env.<environment>` and `.env.<environment>.local` with the real environment on top.\n * Never writes `process.env`.\n */\nexport const loadEnv = <S extends EffectConfigSchema>(\n\tschema: S,\n\toptions: LoadEnvOptions = {},\n): Effect.Effect<SchemaOutput<S>, ConfigError, SchemaServices<S>> =>\n\tdecodeEnv(schema as ConfigSchema, { ...options, async: true, native: true }) as Effect.Effect<\n\t\tSchemaOutput<S>,\n\t\tConfigError,\n\t\tSchemaServices<S>\n\t>;\n\n/**\n * A layer that provides `service` with the validated environment variables.\n */\nexport const layerEnv = <I, S extends EffectConfigSchema>(\n\tservice: Context.Key<I, SchemaOutput<S>>,\n\tschema: S,\n\toptions: LoadEnvOptions = {},\n): Layer.Layer<I, ConfigError, SchemaServices<S>> => Layer.effect(service, loadEnv(schema, options));\n","import { ConfigProvider, Effect } from 'effect';\n\nimport { configProvider } from './provider.ts';\n\nimport { resolveConfig } from '../core/resolve.ts';\nimport { ConfigValidationError } from '../schema.ts';\n\nimport type { ResolveOptions } from '../core/resolve.ts';\nimport type { ConfigError } from './load.ts';\nimport type { ConfigProviderLayerOptions } from './provider.ts';\nimport type { Layer } from 'effect';\n\n/**\n * Resolves a config file with its layers, `.env` files and placeholders, like a config import does, and returns a\n * `ConfigProvider` over the merged value.\n */\nexport const configProviderFromFile = Effect.fn('configProviderFromFile')(function* (\n\tfile: string,\n\toptions: ResolveOptions = {},\n): Effect.fn.Return<ConfigProvider.ConfigProvider, ConfigError> {\n\tconst result = yield* resolveConfig(file, options);\n\tif (result.problems.length > 0) {\n\t\treturn yield* new ConfigValidationError({\n\t\t\tsubject: `config ${result.file}`,\n\t\t\tissues: result.problems.map((problem) => ({\n\t\t\t\tpath: [],\n\t\t\t\tmessage: `${problem.message} (${problem.code})`,\n\t\t\t\tlocation: `${problem.file}:${problem.line}:${problem.column}`,\n\t\t\t})),\n\t\t});\n\t}\n\treturn configProvider(result.value);\n});\n\n/**\n * Installs {@link configProviderFromFile} on top of the current `ConfigProvider`.\n */\nexport const layerConfigProviderFromFile = (\n\tfile: string,\n\toptions: ResolveOptions & ConfigProviderLayerOptions = {},\n): Layer.Layer<never, ConfigError> =>\n\tConfigProvider.layerAdd(configProviderFromFile(file, options), { asPrimary: options.asPrimary ?? true });\n"],"mappings":";;;;;;;;;;AAYA,MAAa,WACZ,QACA,UAA0B,CAAC,MAE3B,UAAU,QAAwB;CAAE,GAAG;CAAS,OAAO;CAAM,QAAQ;AAAK,CAAC;;;;AAS5E,MAAa,YACZ,SACA,QACA,UAA0B,CAAC,MACyB,MAAM,OAAO,SAAS,QAAQ,QAAQ,OAAO,CAAC;;;;;;ACbnG,MAAa,yBAAyB,OAAO,GAAG,wBAAwB,CAAC,CAAC,WACzE,MACA,UAA0B,CAAC,GACoC;CAC/D,MAAM,SAAS,OAAO,cAAc,MAAM,OAAO;CACjD,IAAI,OAAO,SAAS,SAAS,GAC5B,OAAO,OAAO,IAAI,sBAAsB;EACvC,SAAS,UAAU,OAAO;EAC1B,QAAQ,OAAO,SAAS,KAAK,aAAa;GACzC,MAAM,CAAC;GACP,SAAS,GAAG,QAAQ,QAAQ,IAAI,QAAQ,KAAK;GAC7C,UAAU,GAAG,QAAQ,KAAK,GAAG,QAAQ,KAAK,GAAG,QAAQ;EACtD,EAAE;CACH,CAAC;CAEF,OAAO,eAAe,OAAO,KAAK;AACnC,CAAC;;;;AAKD,MAAa,+BACZ,MACA,UAAuD,CAAC,MAExD,eAAe,SAAS,uBAAuB,MAAM,OAAO,GAAG,EAAE,WAAW,QAAQ,aAAa,KAAK,CAAC"}

package/dist/env-Bd-1Atoz.mjs

@@ -0,0 +1,27 @@
+import { n as processEnv, r as readEnv } from "./env-R3_XPW_u.mjs";
+import { r as validate } from "./schema-DcD4N9N-.mjs";
+import { Effect } from "effect";
+import { join } from "node:path";
+import process from "node:process";
+// src/env.ts
+const decodeEnv = Effect.fn("decodeEnv")(function* (schema, options) {
+	const env = options.env ?? processEnv();
+	const environment = options.environment ?? (env.NODE_ENV || void 0);
+	const result = yield* readEnv(join(options.cwd ?? process.cwd(), ".env"), {
+		environment,
+		env
+	});
+	return yield* validate(schema, result.variables, {
+		subject: "environment variables",
+		async: options.async,
+		native: options.native,
+		issues: result.problems.map((problem) => ({
+			path: [],
+			message: problem.message,
+			location: `${problem.file}:${problem.line}:${problem.column}`
+		}))
+	});
+});
+export { decodeEnv as t };
+
+//# sourceMappingURL=env-Bd-1Atoz.mjs.map

package/dist/env-Bd-1Atoz.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"env-Bd-1Atoz.mjs","names":[],"sources":["../src/env.ts"],"sourcesContent":["import { join } from 'node:path';\nimport process from 'node:process';\n\nimport { Effect } from 'effect';\n\nimport { processEnv, readEnv } from './core/env.ts';\nimport { validate } from './schema.ts';\n\nimport type { ConfigSchema, LoadEnvOptions } from './schema.ts';\n\nexport const decodeEnv = Effect.fn('decodeEnv')(function* <S extends ConfigSchema>(\n\tschema: S,\n\toptions: LoadEnvOptions & { readonly async: boolean; readonly native?: boolean | undefined },\n) {\n\tconst env = options.env ?? processEnv();\n\tconst environment = options.environment ?? (env.NODE_ENV || undefined);\n\tconst result = yield* readEnv(join(options.cwd ?? process.cwd(), '.env'), { environment, env });\n\treturn yield* validate(schema, result.variables, {\n\t\tsubject: 'environment variables',\n\t\tasync: options.async,\n\t\tnative: options.native,\n\t\tissues: result.problems.map((problem) => ({\n\t\t\tpath: [],\n\t\t\tmessage: problem.message,\n\t\t\tlocation: `${problem.file}:${problem.line}:${problem.column}`,\n\t\t})),\n\t});\n});\n"],"mappings":";;;;;;AAUA,MAAa,YAAY,OAAO,GAAG,WAAW,CAAC,CAAC,WAC/C,QACA,SACC;CACD,MAAM,MAAM,QAAQ,OAAO,WAAW;CACtC,MAAM,cAAc,QAAQ,gBAAgB,IAAI,YAAY,KAAA;CAC5D,MAAM,SAAS,OAAO,QAAQ,KAAK,QAAQ,OAAO,QAAQ,IAAI,GAAG,MAAM,GAAG;EAAE;EAAa;CAAI,CAAC;CAC9F,OAAO,OAAO,SAAS,QAAQ,OAAO,WAAW;EAChD,SAAS;EACT,OAAO,QAAQ;EACf,QAAQ,QAAQ;EAChB,QAAQ,OAAO,SAAS,KAAK,aAAa;GACzC,MAAM,CAAC;GACP,SAAS,QAAQ;GACjB,UAAU,GAAG,QAAQ,KAAK,GAAG,QAAQ,KAAK,GAAG,QAAQ;EACtD,EAAE;CACH,CAAC;AACF,CAAC"}