@maroonedsoftware/appconfig 1.0.0

package/LICENSE

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

package/README.md

@@ -0,0 +1,310 @@
+# @maroonedsoftware/appconfig
+
+A flexible, type-safe configuration management library with support for multiple sources and value transformation.
+
+## Features
+
+- **Type-safe access** - Full TypeScript support with generics
+- **Multiple sources** - Load configuration from JSON files, YAML files, `.env` files, and more
+- **Value transformation** - Resolve environment variables and GCP secrets in configuration values
+- **Deep merging** - Combine configurations from multiple sources with predictable override behavior
+- **Extensible** - Create custom sources and providers for your specific needs
+
+## Installation
+
+```bash
+pnpm add @maroonedsoftware/appconfig
+```
+
+## Usage
+
+### Basic Usage
+
+```typescript
+import { AppConfig } from '@maroonedsoftware/appconfig';
+
+const config = new AppConfig({
+  database: { host: 'localhost', port: 5432 },
+  api: { timeout: 5000 },
+});
+
+const host = config.get('database').host; // Type-safe access
+const port = config.getNumber('port'); // Returns as number
+```
+
+### Using the Builder
+
+The `AppConfigBuilder` allows you to load configuration from multiple sources and apply transformations:
+
+```typescript
+import {
+  AppConfigBuilder,
+  AppConfigSourceJson,
+  AppConfigSourceYaml,
+  AppConfigSourceDotenv,
+  AppConfigProviderDotenv,
+} from '@maroonedsoftware/appconfig';
+
+const config = await new AppConfigBuilder()
+  .addSource(new AppConfigSourceJson('./config.json'))
+  .addSource(new AppConfigSourceYaml('./config.yaml'))
+  .addSource(new AppConfigSourceDotenv('.env'))
+  .addProvider(new AppConfigProviderDotenv())
+  .build<MyConfigType>();
+```
+
+### Environment Variable Resolution
+
+Use `${env:VAR_NAME}` syntax in your JSON config files to reference environment variables:
+
+**config.json:**
+
+```json
+{
+  "database": {
+    "host": "${env:DB_HOST}",
+    "port": "${env:DB_PORT}",
+    "url": "${env:DATABASE_URL}"
+  }
+}
+```
+
+**.env:**
+
+```
+DB_HOST=localhost
+DB_PORT=5432
+DATABASE_URL=postgres://localhost:5432/mydb
+```
+
+**app.ts:**
+
+```typescript
+const config = await new AppConfigBuilder()
+  .addSource(new AppConfigSourceJson('./config.json'))
+  .addSource(new AppConfigSourceDotenv('.env'))
+  .addProvider(new AppConfigProviderDotenv())
+  .build();
+
+// Values are resolved from environment variables
+// Numeric values like DB_PORT are automatically parsed as numbers
+```
+
+### GCP Secret Manager Integration
+
+Use `${gcp:SECRET_NAME}` syntax to resolve secrets from Google Cloud Platform Secret Manager:
+
+**config.json:**
+
+```json
+{
+  "database": {
+    "password": "${gcp:DB_PASSWORD}",
+    "connectionString": "${gcp:DATABASE_CONNECTION_STRING}"
+  },
+  "api": {
+    "key": "${gcp:API_SECRET_KEY}"
+  }
+}
+```
+
+**app.ts:**
+
+```typescript
+import { AppConfigBuilder, AppConfigSourceJson, AppConfigProviderGcpSecrets } from '@maroonedsoftware/appconfig';
+
+const config = await new AppConfigBuilder()
+  .addSource(new AppConfigSourceJson('./config.json'))
+  .addProvider(new AppConfigProviderGcpSecrets('my-gcp-project-id'))
+  .build();
+
+// Secrets are fetched from GCP Secret Manager
+// The provider fetches: projects/my-gcp-project-id/secrets/DB_PASSWORD/versions/latest
+```
+
+> **Note:** The GCP secrets provider requires valid GCP credentials. It uses Application Default Credentials (ADC), so ensure you have authenticated via `gcloud auth application-default login` or have set up a service account.
+
+## API
+
+### AppConfig
+
+The configuration container providing type-safe access to configuration values.
+
+| Method            | Description                                         |
+| ----------------- | --------------------------------------------------- |
+| `get(key)`        | Returns the value for the key with full type safety |
+| `getString(key)`  | Returns the value converted to a string             |
+| `getNumber(key)`  | Returns the value converted to a number             |
+| `getBoolean(key)` | Returns the value converted to a boolean            |
+| `getObject(key)`  | Returns the value cast as an object                 |
+
+### AppConfigBuilder
+
+Builder for constructing `AppConfig` instances from multiple sources.
+
+| Method                  | Description                                                  |
+| ----------------------- | ------------------------------------------------------------ |
+| `addSource(source)`     | Adds a configuration source (later sources override earlier) |
+| `addProvider(provider)` | Adds a provider to transform string values                   |
+| `build<T>()`            | Builds and returns the `AppConfig` instance                  |
+
+### Sources
+
+#### AppConfigSourceJson
+
+Loads configuration from a JSON file.
+
+```typescript
+// Basic usage (ignores missing file by default)
+const source = new AppConfigSourceJson('./config.json');
+
+// Throw error if file is missing
+const source = new AppConfigSourceJson('./config.json', {
+  ignoreMissingFile: false,
+});
+
+// Custom encoding
+const source = new AppConfigSourceJson('./config.json', {
+  encoding: 'utf16le',
+});
+```
+
+#### AppConfigSourceYaml
+
+Loads configuration from a YAML file. Supports both `.yaml` and `.yml` extensions.
+
+```typescript
+// Basic usage (ignores missing file by default)
+const source = new AppConfigSourceYaml('./config.yaml');
+
+// Throw error if file is missing
+const source = new AppConfigSourceYaml('./config.yaml', {
+  ignoreMissingFile: false,
+});
+
+// Custom encoding
+const source = new AppConfigSourceYaml('./config.yaml', {
+  encoding: 'utf16le',
+});
+```
+
+YAML files support all standard YAML features including nested objects, arrays, multiline strings, and anchors:
+
+```yaml
+# config.yaml
+database:
+  host: localhost
+  port: 5432
+  credentials:
+    username: admin
+    password: ${env:DB_PASSWORD}
+
+features:
+  - feature1
+  - feature2
+
+description: |
+  This is a multiline
+  string value
+```
+
+#### AppConfigSourceDotenv
+
+Loads environment variables from a `.env` file.
+
+```typescript
+// Load from default .env file
+const source = new AppConfigSourceDotenv();
+
+// Load from custom path
+const source = new AppConfigSourceDotenv('./config/.env.local');
+```
+
+### Providers
+
+#### AppConfigProviderDotenv
+
+Resolves environment variable references in configuration values.
+
+```typescript
+// Default pattern: ${env:VAR_NAME}
+const provider = new AppConfigProviderDotenv();
+
+// Custom regex pattern
+const provider = new AppConfigProviderDotenv(/\$\{([^}]+)\}/g);
+```
+
+The provider automatically attempts to parse resolved values as JSON, so numeric and boolean environment variables are converted to their proper types.
+
+#### AppConfigProviderGcpSecrets
+
+Resolves GCP Secret Manager references in configuration values.
+
+```typescript
+// Default pattern: ${gcp:SECRET_NAME}
+const provider = new AppConfigProviderGcpSecrets('my-project-id');
+
+// Custom regex pattern
+const provider = new AppConfigProviderGcpSecrets('my-project-id', /\$\{secret:([^}]+)\}/g);
+```
+
+| Parameter   | Type               | Description                                                            |
+| ----------- | ------------------ | ---------------------------------------------------------------------- |
+| `projectId` | `string`           | The GCP project ID where secrets are stored                            |
+| `prefix`    | `string \| RegExp` | Optional regex pattern to match secret references. Default: `${gcp:*}` |
+
+The provider:
+
+- Fetches secrets from GCP Secret Manager using the latest version
+- Automatically attempts to parse secret values as JSON
+- Requires valid GCP credentials (uses Application Default Credentials)
+- Is decorated with `@Injectable()` for dependency injection support
+
+## Custom Sources and Providers
+
+### Creating a Custom Source
+
+```typescript
+import { AppConfigSource } from '@maroonedsoftware/appconfig';
+
+class MyCustomSource implements AppConfigSource {
+  async load(): Promise<Record<string, unknown>> {
+    // Load configuration from your custom source
+    return { key: 'value' };
+  }
+}
+```
+
+### Creating a Custom Provider
+
+```typescript
+import { AppConfigProvider, ObjectVisitorMeta } from '@maroonedsoftware/appconfig';
+
+class MyCustomProvider implements AppConfigProvider {
+  canParse(value: string): boolean {
+    return value.startsWith('custom:');
+  }
+
+  async parse(value: string, meta: ObjectVisitorMeta): Promise<void> {
+    const transformed = value.replace('custom:', '');
+    (meta.owner as Record<string, unknown>)[meta.propertyPath] = transformed;
+  }
+}
+```
+
+## Configuration Merging
+
+When using multiple sources, configurations are deep-merged in the order they are added. Later sources override earlier ones:
+
+```typescript
+const config = await new AppConfigBuilder()
+  .addSource(new AppConfigSourceJson('./defaults.json')) // Base config
+  .addSource(new AppConfigSourceYaml('./config.yaml')) // Overrides defaults
+  .addSource(new AppConfigSourceJson('./local.json')) // Overrides both
+  .addSource(new AppConfigSourceDotenv()) // Overrides all
+  .build();
+```
+
+## License
+
+MIT

package/dist/app.config.builder.d.ts

@@ -0,0 +1,76 @@
+import { AppConfig } from './app.config.js';
+import { AppConfigProvider } from './app.config.provider.js';
+import { AppConfigSource } from './app.config.source.js';
+/**
+ * Builder for constructing AppConfig instances from multiple sources with value transformation.
+ *
+ * The builder allows you to:
+ * - Load configuration from multiple sources (files, environment variables, etc.)
+ * - Merge configurations with later sources overriding earlier ones
+ * - Transform string values using providers (e.g., resolving environment variable references)
+ *
+ * @example
+ * ```typescript
+ * const config = await new AppConfigBuilder()
+ *   .addSource(new AppConfigSourceJson('./config.json'))
+ *   .addSource(new AppConfigSourceDotenv())
+ *   .addProvider(new AppConfigProviderDotenv())
+ *   .build();
+ * ```
+ */
+export declare class AppConfigBuilder {
+    private readonly sources;
+    private readonly providers;
+    /**
+     * Adds a configuration source to the builder.
+     *
+     * Sources are loaded in the order they are added, and later sources override earlier ones
+     * when merging configurations.
+     *
+     * @param source - The configuration source to add.
+     * @returns The builder instance for method chaining.
+     *
+     * @example
+     * ```typescript
+     * builder
+     *   .addSource(new AppConfigSourceJson('./default.json'))
+     *   .addSource(new AppConfigSourceJson('./local.json'));
+     * ```
+     */
+    addSource(source: AppConfigSource): this;
+    /**
+     * Adds a provider to transform string values during configuration building.
+     *
+     * Providers are applied to all string values found in the merged configuration.
+     * The first provider that can parse a value will be used to transform it.
+     *
+     * @param provider - The provider to add.
+     * @returns The builder instance for method chaining.
+     *
+     * @example
+     * ```typescript
+     * builder.addProvider(new AppConfigProviderDotenv());
+     * ```
+     */
+    addProvider(provider: AppConfigProvider): this;
+    /**
+     * Builds the AppConfig instance by loading all sources, merging them, and applying providers.
+     *
+     * The build process:
+     * 1. Loads all sources in parallel
+     * 2. Merges configurations (later sources override earlier ones)
+     * 3. Traverses the merged configuration and applies providers to string values
+     * 4. Returns the final AppConfig instance
+     *
+     * @template T - The type of the configuration object. Defaults to `Record<string, unknown>`.
+     * @returns A promise that resolves to the built AppConfig instance.
+     *
+     * @example
+     * ```typescript
+     * const config = await builder.build<MyConfigType>();
+     * const value = config.get('someKey');
+     * ```
+     */
+    build<T = Record<string, unknown>>(): Promise<AppConfig<T>>;
+}
+//# sourceMappingURL=app.config.builder.d.ts.map

package/dist/app.config.builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.config.builder.d.ts","sourceRoot":"","sources":["../src/app.config.builder.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAGzD;;;;;;;;;;;;;;;;GAgBG;AACH,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAyB;IACjD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA2B;IAErD;;;;;;;;;;;;;;;OAeG;IACH,SAAS,CAAC,MAAM,EAAE,eAAe;IAKjC;;;;;;;;;;;;;OAaG;IACH,WAAW,CAAC,QAAQ,EAAE,iBAAiB;IAKvC;;;;;;;;;;;;;;;;;OAiBG;IACG,KAAK,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC;CAmBlE"}

package/dist/app.config.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Configuration container that provides type-safe access to configuration values.
+ *
+ * @template T - The type of the configuration object. Defaults to `Record<string, unknown>`.
+ *
+ * @example
+ * ```typescript
+ * const config = new AppConfig({
+ *   database: { host: 'localhost', port: 5432 },
+ *   api: { timeout: 5000 }
+ * });
+ *
+ * const host = config.get('database').host; // Type-safe access
+ * ```
+ */
+export declare class AppConfig<T = Record<string, unknown>> {
+    private readonly config;
+    /**
+     * Creates a new AppConfig instance with the provided configuration.
+     *
+     * @param config - The configuration object to wrap.
+     */
+    constructor(config: T);
+    /**
+     * Retrieves a configuration value by key.
+     *
+     * @template K - The key type, must be a key of T.
+     * @param key - The configuration key to retrieve.
+     * @returns The configuration value for the given key.
+     *
+     * @example
+     * ```typescript
+     * const config = new AppConfig({ port: 3000, host: 'localhost' });
+     * const port = config.get('port'); // Returns 3000, typed as number
+     * ```
+     */
+    get<K extends keyof T>(key: K): T[K];
+    /**
+     * Retrieves a configuration value as a string.
+     *
+     * The value is converted to a string using `String()`. This is useful when
+     * you need to ensure a value is a string regardless of its original type.
+     *
+     * @template K - The key type, must be a key of T.
+     * @param key - The configuration key to retrieve.
+     * @returns The configuration value converted to a string.
+     *
+     * @example
+     * ```typescript
+     * const config = new AppConfig({ port: 3000, enabled: true });
+     * const portStr = config.getString('port'); // Returns "3000"
+     * const enabledStr = config.getString('enabled'); // Returns "true"
+     * ```
+     */
+    getString<K extends keyof T>(key: K): string;
+    /**
+     * Retrieves a configuration value as a number.
+     *
+     * The value is converted to a number using `Number()`. This is useful when
+     * you need to ensure a value is a number regardless of its original type.
+     * Note: Invalid conversions will result in `NaN`.
+     *
+     * @template K - The key type, must be a key of T.
+     * @param key - The configuration key to retrieve.
+     * @returns The configuration value converted to a number.
+     *
+     * @example
+     * ```typescript
+     * const config = new AppConfig({ port: '3000', timeout: '5000' });
+     * const port = config.getNumber('port'); // Returns 3000
+     * const timeout = config.getNumber('timeout'); // Returns 5000
+     * ```
+     */
+    getNumber<K extends keyof T>(key: K): number;
+    /**
+     * Retrieves a configuration value as a boolean.
+     *
+     * The value is converted to a boolean using `Boolean()`. This is useful when
+     * you need to ensure a value is a boolean regardless of its original type.
+     * Note: Only falsy values (false, 0, '', null, undefined, NaN) become false.
+     *
+     * @template K - The key type, must be a key of T.
+     * @param key - The configuration key to retrieve.
+     * @returns The configuration value converted to a boolean.
+     *
+     * @example
+     * ```typescript
+     * const config = new AppConfig({ enabled: 'true', debug: 1 });
+     * const enabled = config.getBoolean('enabled'); // Returns true
+     * const debug = config.getBoolean('debug'); // Returns true
+     * ```
+     */
+    getBoolean<K extends keyof T>(key: K): boolean;
+    /**
+     * Retrieves a configuration value as an object.
+     *
+     * The value is cast to an object type. This is useful when you know a value
+     * is an object and want to access it with object methods.
+     *
+     * @template K - The key type, must be a key of T.
+     * @param key - The configuration key to retrieve.
+     * @returns The configuration value cast as an object.
+     *
+     * @example
+     * ```typescript
+     * const config = new AppConfig({
+     *   database: { host: 'localhost', port: 5432 }
+     * });
+     * const db = config.getObject('database'); // Returns { host: 'localhost', port: 5432 }
+     * ```
+     */
+    getObject<K extends keyof T>(key: K): object;
+}
+//# sourceMappingURL=app.config.d.ts.map

package/dist/app.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.config.d.ts","sourceRoot":"","sources":["../src/app.config.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,qBAAa,SAAS,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAMpC,OAAO,CAAC,QAAQ,CAAC,MAAM;IALnC;;;;OAIG;gBAC0B,MAAM,EAAE,CAAC;IAEtC;;;;;;;;;;;;OAYG;IACH,GAAG,CAAC,CAAC,SAAS,MAAM,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IAIpC;;;;;;;;;;;;;;;;OAgBG;IACH,SAAS,CAAC,CAAC,SAAS,MAAM,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,MAAM;IAI5C;;;;;;;;;;;;;;;;;OAiBG;IACH,SAAS,CAAC,CAAC,SAAS,MAAM,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,MAAM;IAI5C;;;;;;;;;;;;;;;;;OAiBG;IACH,UAAU,CAAC,CAAC,SAAS,MAAM,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,OAAO;IAI9C;;;;;;;;;;;;;;;;;OAiBG;IACH,SAAS,CAAC,CAAC,SAAS,MAAM,CAAC,EAAE,GAAG,EAAE,CAAC,GAAG,MAAM;CAG7C"}

package/dist/app.config.provider.d.ts

@@ -0,0 +1,43 @@
+import { ObjectVisitorMeta } from './object.visitor.js';
+/**
+ * Interface for providers that transform string values in configuration.
+ *
+ * Providers are used by AppConfigBuilder to transform string values found in the
+ * configuration. For example, a provider might resolve environment variable references
+ * or perform other string transformations.
+ *
+ * @example
+ * ```typescript
+ * class MyProvider implements AppConfigProvider {
+ *   canParse(value: string): boolean {
+ *     return value.startsWith('custom:');
+ *   }
+ *
+ *   async parse(value: string, meta: ObjectVisitorMeta): Promise<void> {
+ *     // Transform the value
+ *     meta.owner[meta.propertyPath] = transformedValue;
+ *   }
+ * }
+ * ```
+ */
+export interface AppConfigProvider {
+    /**
+     * Determines whether this provider can parse the given string value.
+     *
+     * @param value - The string value to check.
+     * @returns `true` if this provider can parse the value, `false` otherwise.
+     */
+    canParse(value: string): boolean;
+    /**
+     * Parses and transforms the given string value.
+     *
+     * The provider should update the value in the configuration object using
+     * the provided metadata.
+     *
+     * @param value - The string value to parse and transform.
+     * @param meta - Metadata about the value's location in the configuration object.
+     * @returns A promise that resolves when the transformation is complete.
+     */
+    parse(value: string, meta: ObjectVisitorMeta): Promise<void>;
+}
+//# sourceMappingURL=app.config.provider.d.ts.map

package/dist/app.config.provider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.config.provider.d.ts","sourceRoot":"","sources":["../src/app.config.provider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;;;OAKG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;IAEjC;;;;;;;;;OASG;IACH,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9D"}

package/dist/app.config.source.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Interface for configuration sources that can load configuration data.
+ *
+ * Sources are used by AppConfigBuilder to load configuration from various places
+ * such as files, environment variables, remote APIs, etc.
+ *
+ * @example
+ * ```typescript
+ * class MySource implements AppConfigSource {
+ *   async load(): Promise<Record<string, unknown>> {
+ *     // Load configuration from somewhere
+ *     return { key: 'value' };
+ *   }
+ * }
+ * ```
+ */
+export interface AppConfigSource {
+    /**
+     * Loads configuration data from the source.
+     *
+     * @returns A promise that resolves to the configuration object.
+     */
+    load(): Promise<Record<string, unknown>>;
+}
+//# sourceMappingURL=app.config.source.d.ts.map

package/dist/app.config.source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.config.source.d.ts","sourceRoot":"","sources":["../src/app.config.source.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,IAAI,IAAI,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;CAC1C"}

package/dist/app.config.source.options.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Options for configuring AppConfigSourceFile behavior.
+ */
+export interface AppConfigSourceFileOptions {
+    /**
+     * If `true`, returns an empty object when the file doesn't exist instead of throwing.
+     * Defaults to `true`.
+     */
+    ignoreMissingFile?: boolean;
+    /**
+     * The file encoding to use when reading the file.
+     * Defaults to `'utf8'`.
+     */
+    encoding?: BufferEncoding;
+}
+//# sourceMappingURL=app.config.source.options.d.ts.map

package/dist/app.config.source.options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.config.source.options.d.ts","sourceRoot":"","sources":["../src/app.config.source.options.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACzC;;;OAGG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B;;;OAGG;IACH,QAAQ,CAAC,EAAE,cAAc,CAAC;CAC3B"}

package/dist/helpers.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Attempts to parse a string as JSON, returning the original string if parsing fails.
+ *
+ * @param text - The text to parse.
+ * @returns The parsed JSON value, or the original text if parsing fails.
+ */
+export declare function tryParseJson(text: string): unknown;
+//# sourceMappingURL=helpers.d.ts.map

package/dist/helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../src/helpers.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAMlD"}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { AppConfig } from './app.config.js';
+export { AppConfigBuilder } from './app.config.builder.js';
+export type { AppConfigProvider } from './app.config.provider.js';
+export type { AppConfigSource } from './app.config.source.js';
+export { AppConfigSourceDotenv } from './sources/app.config.source.dotenv.js';
+export { AppConfigSourceJson } from './sources/app.config.source.json.js';
+export { AppConfigSourceYaml } from './sources/app.config.source.yaml.js';
+export { AppConfigProviderDotenv } from './providers/app.config.provider.dotenv.js';
+export { AppConfigProviderGcpSecrets } from './providers/app.config.provider.gcp.secrets.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,YAAY,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAClE,YAAY,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,qBAAqB,EAAE,MAAM,uCAAuC,CAAC;AAC9E,OAAO,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAC1E,OAAO,EAAE,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AAC1E,OAAO,EAAE,uBAAuB,EAAE,MAAM,2CAA2C,CAAC;AACpF,OAAO,EAAE,2BAA2B,EAAE,MAAM,gDAAgD,CAAC"}