@logtape/config 1.4.0-dev.1

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright 2024–2025 Hong Minhee
+
+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,47 @@
+@logtape/config
+===============
+
+[![JSR][JSR badge]][JSR]
+[![npm][npm badge]][npm]
+
+This package provides functionality to configure [LogTape] from plain objects,
+such as those loaded from JSON or YAML files.
+
+[JSR]: https://jsr.io/@logtape/config
+[JSR badge]: https://jsr.io/badges/@logtape/config
+[npm]: https://www.npmjs.com/package/@logtape/config
+[npm badge]: https://img.shields.io/npm/v/@logtape/config?logo=npm
+[LogTape]: https://logtape.org/
+
+
+Installation
+------------
+
+The package is available on [JSR] and [npm]:
+
+~~~~ sh
+deno add jsr:@logtape/config
+npm  add     @logtape/config
+pnpm add     @logtape/config
+yarn add     @logtape/config
+bun  add     @logtape/config
+~~~~
+
+
+Usage
+-----
+
+You can configure LogTape using a plain object:
+
+~~~~ typescript
+import { configureFromObject } from "@logtape/config";
+import { readFile } from "node:fs/promises";
+
+const config = JSON.parse(await readFile("./logtape.json", "utf-8"));
+await configureFromObject(config);
+~~~~
+
+For more details, see the [Configuration from objects] section in the LogTape
+manual.
+
+[Configuration from objects]: https://logtape.org/manual/config#configuration-from-objects

package/dist/_virtual/rolldown_runtime.cjs

@@ -0,0 +1,30 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});

package/dist/config.cjs

@@ -0,0 +1,80 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_types = require('./types.cjs');
+const require_loader = require('./loader.cjs');
+const require_shorthands = require('./shorthands.cjs');
+const __logtape_logtape = require_rolldown_runtime.__toESM(require("@logtape/logtape"));
+
+//#region src/config.ts
+/**
+* Configures LogTape from a plain object.
+*
+* @param config Configuration object (typically loaded from JSON/YAML/TOML)
+* @param options Configuration options
+* @throws {ConfigError} If configuration is invalid and onInvalidConfig is "throw"
+*
+* @example
+* ```typescript
+* import { configureFromObject } from "@logtape/config";
+* import { readFile } from "fs/promises";
+*
+* const config = JSON.parse(await readFile("./logtape.json", "utf-8"));
+* await configureFromObject(config);
+* ```
+* @since 1.4.0
+*/
+async function configureFromObject(config, options) {
+	const shorthands = require_shorthands.mergeShorthands(require_shorthands.DEFAULT_SHORTHANDS, options?.shorthands);
+	const onInvalidConfig = options?.onInvalidConfig ?? "throw";
+	const warnings = [];
+	const sinks = {};
+	if (config.sinks) for (const [name, sinkConfig] of Object.entries(config.sinks)) try {
+		sinks[name] = await require_loader.createSink(sinkConfig, shorthands);
+	} catch (e) {
+		if (onInvalidConfig === "throw") throw e;
+		warnings.push(`Failed to create sink '${name}': ${e}`);
+	}
+	const filters = {};
+	if (config.filters) for (const [name, filterConfig] of Object.entries(config.filters)) try {
+		filters[name] = await require_loader.createFilter(filterConfig, shorthands);
+	} catch (e) {
+		if (onInvalidConfig === "throw") throw e;
+		warnings.push(`Failed to create filter '${name}': ${e}`);
+	}
+	const logTapeConfig = {
+		sinks,
+		filters,
+		loggers: []
+	};
+	if (config.loggers) for (const loggerConfig of config.loggers) {
+		const validSinks = [];
+		if (loggerConfig.sinks) for (const sinkName of loggerConfig.sinks) if (sinkName in sinks) validSinks.push(sinkName);
+		else {
+			const msg = `Logger '${Array.isArray(loggerConfig.category) ? loggerConfig.category.join(".") : loggerConfig.category}' references unknown or failed sink '${sinkName}'`;
+			if (onInvalidConfig === "throw") throw new require_types.ConfigError(msg);
+			warnings.push(msg);
+		}
+		const validFilters = [];
+		if (loggerConfig.filters) for (const filterName of loggerConfig.filters) if (filterName in filters) validFilters.push(filterName);
+		else {
+			const msg = `Logger '${Array.isArray(loggerConfig.category) ? loggerConfig.category.join(".") : loggerConfig.category}' references unknown or failed filter '${filterName}'`;
+			if (onInvalidConfig === "throw") throw new require_types.ConfigError(msg);
+			warnings.push(msg);
+		}
+		logTapeConfig.loggers.push({
+			category: loggerConfig.category,
+			sinks: validSinks.length > 0 ? validSinks : void 0,
+			filters: validFilters.length > 0 ? validFilters : void 0,
+			lowestLevel: loggerConfig.lowestLevel,
+			parentSinks: loggerConfig.parentSinks
+		});
+	}
+	if (config.reset) logTapeConfig.reset = true;
+	await (0, __logtape_logtape.configure)(logTapeConfig);
+	if (warnings.length > 0) {
+		const metaLogger = (0, __logtape_logtape.getLogger)(["logtape", "meta"]);
+		for (const warning of warnings) metaLogger.warn(warning);
+	}
+}
+
+//#endregion
+exports.configureFromObject = configureFromObject;

package/dist/config.d.cts

@@ -0,0 +1,26 @@
+import { ConfigureOptions, LogTapeConfig } from "./types.cjs";
+
+//#region src/config.d.ts
+
+/**
+ * Configures LogTape from a plain object.
+ *
+ * @param config Configuration object (typically loaded from JSON/YAML/TOML)
+ * @param options Configuration options
+ * @throws {ConfigError} If configuration is invalid and onInvalidConfig is "throw"
+ *
+ * @example
+ * ```typescript
+ * import { configureFromObject } from "@logtape/config";
+ * import { readFile } from "fs/promises";
+ *
+ * const config = JSON.parse(await readFile("./logtape.json", "utf-8"));
+ * await configureFromObject(config);
+ * ```
+ * @since 1.4.0
+ */
+declare function configureFromObject(config: LogTapeConfig, options?: ConfigureOptions): Promise<void>;
+//# sourceMappingURL=config.d.ts.map
+//#endregion
+export { configureFromObject };
+//# sourceMappingURL=config.d.cts.map

package/dist/config.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.cts","names":[],"sources":["../src/config.ts"],"sourcesContent":[],"mappings":";;;;;;AAwBA;;;;;AAGU;;;;;;;;;;iBAHY,mBAAA,SACZ,yBACE,mBACT"}

package/dist/config.d.ts

@@ -0,0 +1,26 @@
+import { ConfigureOptions, LogTapeConfig } from "./types.js";
+
+//#region src/config.d.ts
+
+/**
+ * Configures LogTape from a plain object.
+ *
+ * @param config Configuration object (typically loaded from JSON/YAML/TOML)
+ * @param options Configuration options
+ * @throws {ConfigError} If configuration is invalid and onInvalidConfig is "throw"
+ *
+ * @example
+ * ```typescript
+ * import { configureFromObject } from "@logtape/config";
+ * import { readFile } from "fs/promises";
+ *
+ * const config = JSON.parse(await readFile("./logtape.json", "utf-8"));
+ * await configureFromObject(config);
+ * ```
+ * @since 1.4.0
+ */
+declare function configureFromObject(config: LogTapeConfig, options?: ConfigureOptions): Promise<void>;
+//# sourceMappingURL=config.d.ts.map
+//#endregion
+export { configureFromObject };
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","names":[],"sources":["../src/config.ts"],"sourcesContent":[],"mappings":";;;;;;AAwBA;;;;;AAGU;;;;;;;;;;iBAHY,mBAAA,SACZ,yBACE,mBACT"}

package/dist/config.js

@@ -0,0 +1,80 @@
+import { ConfigError } from "./types.js";
+import { createFilter, createSink } from "./loader.js";
+import { DEFAULT_SHORTHANDS, mergeShorthands } from "./shorthands.js";
+import { configure, getLogger } from "@logtape/logtape";
+
+//#region src/config.ts
+/**
+* Configures LogTape from a plain object.
+*
+* @param config Configuration object (typically loaded from JSON/YAML/TOML)
+* @param options Configuration options
+* @throws {ConfigError} If configuration is invalid and onInvalidConfig is "throw"
+*
+* @example
+* ```typescript
+* import { configureFromObject } from "@logtape/config";
+* import { readFile } from "fs/promises";
+*
+* const config = JSON.parse(await readFile("./logtape.json", "utf-8"));
+* await configureFromObject(config);
+* ```
+* @since 1.4.0
+*/
+async function configureFromObject(config, options) {
+	const shorthands = mergeShorthands(DEFAULT_SHORTHANDS, options?.shorthands);
+	const onInvalidConfig = options?.onInvalidConfig ?? "throw";
+	const warnings = [];
+	const sinks = {};
+	if (config.sinks) for (const [name, sinkConfig] of Object.entries(config.sinks)) try {
+		sinks[name] = await createSink(sinkConfig, shorthands);
+	} catch (e) {
+		if (onInvalidConfig === "throw") throw e;
+		warnings.push(`Failed to create sink '${name}': ${e}`);
+	}
+	const filters = {};
+	if (config.filters) for (const [name, filterConfig] of Object.entries(config.filters)) try {
+		filters[name] = await createFilter(filterConfig, shorthands);
+	} catch (e) {
+		if (onInvalidConfig === "throw") throw e;
+		warnings.push(`Failed to create filter '${name}': ${e}`);
+	}
+	const logTapeConfig = {
+		sinks,
+		filters,
+		loggers: []
+	};
+	if (config.loggers) for (const loggerConfig of config.loggers) {
+		const validSinks = [];
+		if (loggerConfig.sinks) for (const sinkName of loggerConfig.sinks) if (sinkName in sinks) validSinks.push(sinkName);
+		else {
+			const msg = `Logger '${Array.isArray(loggerConfig.category) ? loggerConfig.category.join(".") : loggerConfig.category}' references unknown or failed sink '${sinkName}'`;
+			if (onInvalidConfig === "throw") throw new ConfigError(msg);
+			warnings.push(msg);
+		}
+		const validFilters = [];
+		if (loggerConfig.filters) for (const filterName of loggerConfig.filters) if (filterName in filters) validFilters.push(filterName);
+		else {
+			const msg = `Logger '${Array.isArray(loggerConfig.category) ? loggerConfig.category.join(".") : loggerConfig.category}' references unknown or failed filter '${filterName}'`;
+			if (onInvalidConfig === "throw") throw new ConfigError(msg);
+			warnings.push(msg);
+		}
+		logTapeConfig.loggers.push({
+			category: loggerConfig.category,
+			sinks: validSinks.length > 0 ? validSinks : void 0,
+			filters: validFilters.length > 0 ? validFilters : void 0,
+			lowestLevel: loggerConfig.lowestLevel,
+			parentSinks: loggerConfig.parentSinks
+		});
+	}
+	if (config.reset) logTapeConfig.reset = true;
+	await configure(logTapeConfig);
+	if (warnings.length > 0) {
+		const metaLogger = getLogger(["logtape", "meta"]);
+		for (const warning of warnings) metaLogger.warn(warning);
+	}
+}
+
+//#endregion
+export { configureFromObject };
+//# sourceMappingURL=config.js.map

package/dist/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","names":["config: LogTapeConfig","options?: ConfigureOptions","warnings: string[]","sinks: Record<string, Sink>","filters: Record<string, Filter>","logTapeConfig: Config<string, string>","validSinks: string[]","validFilters: string[]"],"sources":["../src/config.ts"],"sourcesContent":["import { configure, getLogger } from \"@logtape/logtape\";\nimport type { Config, Filter, Sink } from \"@logtape/logtape\";\nimport { createFilter, createSink } from \"./loader.ts\";\nimport { DEFAULT_SHORTHANDS, mergeShorthands } from \"./shorthands.ts\";\nimport { ConfigError } from \"./types.ts\";\nimport type { ConfigureOptions, LogTapeConfig } from \"./types.ts\";\n\n/**\n * Configures LogTape from a plain object.\n *\n * @param config Configuration object (typically loaded from JSON/YAML/TOML)\n * @param options Configuration options\n * @throws {ConfigError} If configuration is invalid and onInvalidConfig is \"throw\"\n *\n * @example\n * ```typescript\n * import { configureFromObject } from \"@logtape/config\";\n * import { readFile } from \"fs/promises\";\n *\n * const config = JSON.parse(await readFile(\"./logtape.json\", \"utf-8\"));\n * await configureFromObject(config);\n * ```\n * @since 1.4.0\n */\nexport async function configureFromObject(\n  config: LogTapeConfig,\n  options?: ConfigureOptions,\n): Promise<void> {\n  const shorthands = mergeShorthands(\n    DEFAULT_SHORTHANDS,\n    options?.shorthands,\n  );\n  const onInvalidConfig = options?.onInvalidConfig ?? \"throw\";\n  const warnings: string[] = [];\n\n  // 1. Create sinks\n  const sinks: Record<string, Sink> = {};\n  if (config.sinks) {\n    for (const [name, sinkConfig] of Object.entries(config.sinks)) {\n      try {\n        sinks[name] = await createSink(sinkConfig, shorthands);\n      } catch (e) {\n        if (onInvalidConfig === \"throw\") {\n          throw e;\n        }\n        warnings.push(`Failed to create sink '${name}': ${e}`);\n      }\n    }\n  }\n\n  // 2. Create filters\n  const filters: Record<string, Filter> = {};\n  if (config.filters) {\n    for (const [name, filterConfig] of Object.entries(config.filters)) {\n      try {\n        filters[name] = await createFilter(filterConfig, shorthands);\n      } catch (e) {\n        if (onInvalidConfig === \"throw\") {\n          throw e;\n        }\n        warnings.push(`Failed to create filter '${name}': ${e}`);\n      }\n    }\n  }\n\n  // 3. Configure logtape\n  const logTapeConfig: Config<string, string> = {\n    sinks,\n    filters,\n    loggers: [],\n  };\n\n  if (config.loggers) {\n    for (const loggerConfig of config.loggers) {\n      // Validate sink references\n      const validSinks: string[] = [];\n      if (loggerConfig.sinks) {\n        for (const sinkName of loggerConfig.sinks) {\n          if (sinkName in sinks) {\n            validSinks.push(sinkName);\n          } else {\n            const msg = `Logger '${\n              Array.isArray(loggerConfig.category)\n                ? loggerConfig.category.join(\".\")\n                : loggerConfig.category\n            }' references unknown or failed sink '${sinkName}'`;\n            if (onInvalidConfig === \"throw\") {\n              throw new ConfigError(msg);\n            }\n            warnings.push(msg);\n          }\n        }\n      }\n\n      // Validate filter references\n      const validFilters: string[] = [];\n      if (loggerConfig.filters) {\n        for (const filterName of loggerConfig.filters) {\n          if (filterName in filters) {\n            validFilters.push(filterName);\n          } else {\n            const msg = `Logger '${\n              Array.isArray(loggerConfig.category)\n                ? loggerConfig.category.join(\".\")\n                : loggerConfig.category\n            }' references unknown or failed filter '${filterName}'`;\n            if (onInvalidConfig === \"throw\") {\n              throw new ConfigError(msg);\n            }\n            warnings.push(msg);\n          }\n        }\n      }\n\n      logTapeConfig.loggers.push({\n        category: loggerConfig.category,\n        sinks: validSinks.length > 0 ? validSinks : undefined,\n        filters: validFilters.length > 0 ? validFilters : undefined,\n        lowestLevel: loggerConfig.lowestLevel,\n        parentSinks: loggerConfig.parentSinks,\n      });\n    }\n  }\n\n  if (config.reset) {\n    logTapeConfig.reset = true;\n  }\n\n  await configure(logTapeConfig);\n\n  // 4. Log warnings to meta logger\n  if (warnings.length > 0) {\n    const metaLogger = getLogger([\"logtape\", \"meta\"]);\n    for (const warning of warnings) {\n      metaLogger.warn(warning);\n    }\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAwBA,eAAsB,oBACpBA,QACAC,SACe;CACf,MAAM,aAAa,gBACjB,oBACA,SAAS,WACV;CACD,MAAM,kBAAkB,SAAS,mBAAmB;CACpD,MAAMC,WAAqB,CAAE;CAG7B,MAAMC,QAA8B,CAAE;AACtC,KAAI,OAAO,MACT,MAAK,MAAM,CAAC,MAAM,WAAW,IAAI,OAAO,QAAQ,OAAO,MAAM,CAC3D,KAAI;AACF,QAAM,QAAQ,MAAM,WAAW,YAAY,WAAW;CACvD,SAAQ,GAAG;AACV,MAAI,oBAAoB,QACtB,OAAM;AAER,WAAS,MAAM,yBAAyB,KAAK,KAAK,EAAE,EAAE;CACvD;CAKL,MAAMC,UAAkC,CAAE;AAC1C,KAAI,OAAO,QACT,MAAK,MAAM,CAAC,MAAM,aAAa,IAAI,OAAO,QAAQ,OAAO,QAAQ,CAC/D,KAAI;AACF,UAAQ,QAAQ,MAAM,aAAa,cAAc,WAAW;CAC7D,SAAQ,GAAG;AACV,MAAI,oBAAoB,QACtB,OAAM;AAER,WAAS,MAAM,2BAA2B,KAAK,KAAK,EAAE,EAAE;CACzD;CAKL,MAAMC,gBAAwC;EAC5C;EACA;EACA,SAAS,CAAE;CACZ;AAED,KAAI,OAAO,QACT,MAAK,MAAM,gBAAgB,OAAO,SAAS;EAEzC,MAAMC,aAAuB,CAAE;AAC/B,MAAI,aAAa,MACf,MAAK,MAAM,YAAY,aAAa,MAClC,KAAI,YAAY,MACd,YAAW,KAAK,SAAS;OACpB;GACL,MAAM,OAAO,UACX,MAAM,QAAQ,aAAa,SAAS,GAChC,aAAa,SAAS,KAAK,IAAI,GAC/B,aAAa,SAClB,uCAAuC,SAAS;AACjD,OAAI,oBAAoB,QACtB,OAAM,IAAI,YAAY;AAExB,YAAS,KAAK,IAAI;EACnB;EAKL,MAAMC,eAAyB,CAAE;AACjC,MAAI,aAAa,QACf,MAAK,MAAM,cAAc,aAAa,QACpC,KAAI,cAAc,QAChB,cAAa,KAAK,WAAW;OACxB;GACL,MAAM,OAAO,UACX,MAAM,QAAQ,aAAa,SAAS,GAChC,aAAa,SAAS,KAAK,IAAI,GAC/B,aAAa,SAClB,yCAAyC,WAAW;AACrD,OAAI,oBAAoB,QACtB,OAAM,IAAI,YAAY;AAExB,YAAS,KAAK,IAAI;EACnB;AAIL,gBAAc,QAAQ,KAAK;GACzB,UAAU,aAAa;GACvB,OAAO,WAAW,SAAS,IAAI;GAC/B,SAAS,aAAa,SAAS,IAAI;GACnC,aAAa,aAAa;GAC1B,aAAa,aAAa;EAC3B,EAAC;CACH;AAGH,KAAI,OAAO,MACT,eAAc,QAAQ;AAGxB,OAAM,UAAU,cAAc;AAG9B,KAAI,SAAS,SAAS,GAAG;EACvB,MAAM,aAAa,UAAU,CAAC,WAAW,MAAO,EAAC;AACjD,OAAK,MAAM,WAAW,SACpB,YAAW,KAAK,QAAQ;CAE3B;AACF"}

package/dist/env.cjs

@@ -0,0 +1,35 @@
+
+//#region src/env.ts
+/**
+* Expands environment variables in a configuration object.
+*
+* @param config Configuration object
+* @param options Expansion options
+* @returns Configuration with expanded environment variables
+* @since 1.4.0
+*/
+function expandEnvVars(config, options) {
+	const pattern = options?.pattern ?? /\$\{([^}:]+)(?::([^}]+))?\}/g;
+	function replace(value) {
+		return value.replace(pattern, (_, key, defaultValue) => {
+			let val;
+			if (typeof globalThis.process?.env === "object") val = globalThis.process.env[key];
+			else if (typeof Deno !== "undefined") val = Deno.env.get(key);
+			return val ?? defaultValue ?? "";
+		});
+	}
+	function walk(obj) {
+		if (typeof obj === "string") return replace(obj);
+		if (Array.isArray(obj)) return obj.map(walk);
+		if (obj !== null && typeof obj === "object") {
+			const result = {};
+			for (const [key, value] of Object.entries(obj)) result[key] = walk(value);
+			return result;
+		}
+		return obj;
+	}
+	return walk(config);
+}
+
+//#endregion
+exports.expandEnvVars = expandEnvVars;

package/dist/env.d.cts

@@ -0,0 +1,17 @@
+import { EnvExpansionOptions } from "./types.cjs";
+
+//#region src/env.d.ts
+
+/**
+ * Expands environment variables in a configuration object.
+ *
+ * @param config Configuration object
+ * @param options Expansion options
+ * @returns Configuration with expanded environment variables
+ * @since 1.4.0
+ */
+declare function expandEnvVars<T extends object>(config: T, options?: EnvExpansionOptions): T;
+//# sourceMappingURL=env.d.ts.map
+//#endregion
+export { expandEnvVars };
+//# sourceMappingURL=env.d.cts.map

package/dist/env.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.cts","names":[],"sources":["../src/env.ts"],"sourcesContent":[],"mappings":";;;;;;AAUA;;;;;AAGI;iBAHY,wCACN,aACE,sBACT"}

package/dist/env.d.ts

@@ -0,0 +1,17 @@
+import { EnvExpansionOptions } from "./types.js";
+
+//#region src/env.d.ts
+
+/**
+ * Expands environment variables in a configuration object.
+ *
+ * @param config Configuration object
+ * @param options Expansion options
+ * @returns Configuration with expanded environment variables
+ * @since 1.4.0
+ */
+declare function expandEnvVars<T extends object>(config: T, options?: EnvExpansionOptions): T;
+//# sourceMappingURL=env.d.ts.map
+//#endregion
+export { expandEnvVars };
+//# sourceMappingURL=env.d.ts.map

package/dist/env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.d.ts","names":[],"sources":["../src/env.ts"],"sourcesContent":[],"mappings":";;;;;;AAUA;;;;;AAGI;iBAHY,wCACN,aACE,sBACT"}

package/dist/env.js

@@ -0,0 +1,35 @@
+//#region src/env.ts
+/**
+* Expands environment variables in a configuration object.
+*
+* @param config Configuration object
+* @param options Expansion options
+* @returns Configuration with expanded environment variables
+* @since 1.4.0
+*/
+function expandEnvVars(config, options) {
+	const pattern = options?.pattern ?? /\$\{([^}:]+)(?::([^}]+))?\}/g;
+	function replace(value) {
+		return value.replace(pattern, (_, key, defaultValue) => {
+			let val;
+			if (typeof globalThis.process?.env === "object") val = globalThis.process.env[key];
+			else if (typeof Deno !== "undefined") val = Deno.env.get(key);
+			return val ?? defaultValue ?? "";
+		});
+	}
+	function walk(obj) {
+		if (typeof obj === "string") return replace(obj);
+		if (Array.isArray(obj)) return obj.map(walk);
+		if (obj !== null && typeof obj === "object") {
+			const result = {};
+			for (const [key, value] of Object.entries(obj)) result[key] = walk(value);
+			return result;
+		}
+		return obj;
+	}
+	return walk(config);
+}
+
+//#endregion
+export { expandEnvVars };
+//# sourceMappingURL=env.js.map

package/dist/env.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.js","names":["config: T","options?: EnvExpansionOptions","value: string","val: string | undefined","obj: unknown","result: Record<string, unknown>"],"sources":["../src/env.ts"],"sourcesContent":["import type { EnvExpansionOptions } from \"./types.ts\";\n\n/**\n * Expands environment variables in a configuration object.\n *\n * @param config Configuration object\n * @param options Expansion options\n * @returns Configuration with expanded environment variables\n * @since 1.4.0\n */\nexport function expandEnvVars<T extends object>(\n  config: T,\n  options?: EnvExpansionOptions,\n): T {\n  const pattern = options?.pattern ?? /\\$\\{([^}:]+)(?::([^}]+))?\\}/g;\n\n  function replace(value: string): string {\n    return value.replace(pattern, (_, key, defaultValue) => {\n      let val: string | undefined;\n      // deno-lint-ignore no-explicit-any\n      if (typeof (globalThis as any).process?.env === \"object\") {\n        // Node.js / Bun\n        // deno-lint-ignore no-explicit-any\n        val = (globalThis as any).process.env[key];\n      } else if (typeof Deno !== \"undefined\") {\n        // Deno\n        val = Deno.env.get(key);\n      }\n\n      return val ?? defaultValue ?? \"\";\n    });\n  }\n\n  function walk(obj: unknown): unknown {\n    if (typeof obj === \"string\") {\n      return replace(obj);\n    }\n    if (Array.isArray(obj)) {\n      return obj.map(walk);\n    }\n    if (obj !== null && typeof obj === \"object\") {\n      const result: Record<string, unknown> = {};\n      for (const [key, value] of Object.entries(obj)) {\n        result[key] = walk(value);\n      }\n      return result;\n    }\n    return obj;\n  }\n\n  return walk(config) as T;\n}\n"],"mappings":";;;;;;;;;AAUA,SAAgB,cACdA,QACAC,SACG;CACH,MAAM,UAAU,SAAS,WAAW;CAEpC,SAAS,QAAQC,OAAuB;AACtC,SAAO,MAAM,QAAQ,SAAS,CAAC,GAAG,KAAK,iBAAiB;GACtD,IAAIC;AAEJ,cAAY,WAAmB,SAAS,QAAQ,SAG9C,OAAO,WAAmB,QAAQ,IAAI;mBACtB,SAAS,YAEzB,OAAM,KAAK,IAAI,IAAI,IAAI;AAGzB,UAAO,OAAO,gBAAgB;EAC/B,EAAC;CACH;CAED,SAAS,KAAKC,KAAuB;AACnC,aAAW,QAAQ,SACjB,QAAO,QAAQ,IAAI;AAErB,MAAI,MAAM,QAAQ,IAAI,CACpB,QAAO,IAAI,IAAI,KAAK;AAEtB,MAAI,QAAQ,eAAe,QAAQ,UAAU;GAC3C,MAAMC,SAAkC,CAAE;AAC1C,QAAK,MAAM,CAAC,KAAK,MAAM,IAAI,OAAO,QAAQ,IAAI,CAC5C,QAAO,OAAO,KAAK,MAAM;AAE3B,UAAO;EACR;AACD,SAAO;CACR;AAED,QAAO,KAAK,OAAO;AACpB"}

package/dist/loader.cjs

@@ -0,0 +1,94 @@
+const require_parser = require('./parser.cjs');
+const require_types = require('./types.cjs');
+
+//#region src/loader.ts
+/**
+* Loads a module and extracts the specified export.
+*
+* @param parsed Parsed module reference
+* @param shorthands Shorthand registry for resolving shorthands
+* @param type Type of shorthand (sinks, filters, formatters)
+* @returns The loaded module export
+* @since 1.4.0
+*/
+async function loadModuleExport(parsed, shorthands, type) {
+	if (parsed.isShorthand) {
+		const registry = shorthands[type];
+		const resolved = registry ? registry[parsed.shorthandName] : void 0;
+		if (!resolved) throw new require_types.ConfigError(`Unknown ${type.slice(0, -1)} shorthand: #${parsed.shorthandName}`);
+		const resolvedParsed = require_parser.parseModuleReference(resolved);
+		return loadModuleExport(resolvedParsed, shorthands, type);
+	}
+	if (!parsed.modulePath) throw new require_types.ConfigError("Module path is missing");
+	let mod;
+	try {
+		mod = await import(parsed.modulePath);
+	} catch (e) {
+		throw new require_types.ConfigError(`Failed to load module ${parsed.modulePath}: ${e}`);
+	}
+	const exportName = parsed.exportName ?? "default";
+	const exported = mod[exportName];
+	if (exported === void 0) throw new require_types.ConfigError(`Module ${parsed.modulePath} does not have export '${exportName}'`);
+	return exported;
+}
+/**
+* Creates a sink from configuration.
+*
+* @param config Sink configuration
+* @param shorthands Shorthand registry
+* @returns The created sink
+* @since 1.4.0
+*/
+async function createSink(config, shorthands) {
+	const parsed = require_parser.parseModuleReference(config.type);
+	const factory = await loadModuleExport(parsed, shorthands, "sinks");
+	let sink;
+	if (parsed.isFactory) {
+		if (typeof factory !== "function") throw new require_types.ConfigError(`Export ${parsed.exportName} in ${parsed.modulePath} is not a function, but invoked as factory`);
+		const options = { ...config };
+		delete options.type;
+		if (options.formatter) if (typeof options.formatter === "string") {
+			const fmtParsed = require_parser.parseModuleReference(options.formatter);
+			const fmtFactory = await loadModuleExport(fmtParsed, shorthands, "formatters");
+			if (fmtParsed.isFactory) {
+				if (typeof fmtFactory !== "function") throw new require_types.ConfigError(`Formatter ${options.formatter} is not a function`);
+				options.formatter = fmtFactory({});
+			} else options.formatter = fmtFactory;
+		} else {
+			const fmtConfig = options.formatter;
+			const fmtParsed = require_parser.parseModuleReference(fmtConfig.type);
+			const fmtFactory = await loadModuleExport(fmtParsed, shorthands, "formatters");
+			if (fmtParsed.isFactory) {
+				if (typeof fmtFactory !== "function") throw new require_types.ConfigError(`Formatter ${fmtConfig.type} is not a function`);
+				const fmtOptions = { ...fmtConfig };
+				delete fmtOptions.type;
+				options.formatter = fmtFactory(fmtOptions);
+			} else options.formatter = fmtFactory;
+		}
+		sink = factory(options);
+	} else sink = factory;
+	return sink;
+}
+/**
+* Creates a filter from configuration.
+*
+* @param config Filter configuration
+* @param shorthands Shorthand registry
+* @returns The created filter
+* @since 1.4.0
+*/
+async function createFilter(config, shorthands) {
+	const parsed = require_parser.parseModuleReference(config.type);
+	const factory = await loadModuleExport(parsed, shorthands, "filters");
+	if (parsed.isFactory) {
+		if (typeof factory !== "function") throw new require_types.ConfigError(`Export ${parsed.exportName} in ${parsed.modulePath} is not a function, but invoked as factory`);
+		const options = { ...config };
+		delete options.type;
+		return factory(options);
+	}
+	return factory;
+}
+
+//#endregion
+exports.createFilter = createFilter;
+exports.createSink = createSink;

package/dist/loader.js

@@ -0,0 +1,94 @@
+import { parseModuleReference } from "./parser.js";
+import { ConfigError } from "./types.js";
+
+//#region src/loader.ts
+/**
+* Loads a module and extracts the specified export.
+*
+* @param parsed Parsed module reference
+* @param shorthands Shorthand registry for resolving shorthands
+* @param type Type of shorthand (sinks, filters, formatters)
+* @returns The loaded module export
+* @since 1.4.0
+*/
+async function loadModuleExport(parsed, shorthands, type) {
+	if (parsed.isShorthand) {
+		const registry = shorthands[type];
+		const resolved = registry ? registry[parsed.shorthandName] : void 0;
+		if (!resolved) throw new ConfigError(`Unknown ${type.slice(0, -1)} shorthand: #${parsed.shorthandName}`);
+		const resolvedParsed = parseModuleReference(resolved);
+		return loadModuleExport(resolvedParsed, shorthands, type);
+	}
+	if (!parsed.modulePath) throw new ConfigError("Module path is missing");
+	let mod;
+	try {
+		mod = await import(parsed.modulePath);
+	} catch (e) {
+		throw new ConfigError(`Failed to load module ${parsed.modulePath}: ${e}`);
+	}
+	const exportName = parsed.exportName ?? "default";
+	const exported = mod[exportName];
+	if (exported === void 0) throw new ConfigError(`Module ${parsed.modulePath} does not have export '${exportName}'`);
+	return exported;
+}
+/**
+* Creates a sink from configuration.
+*
+* @param config Sink configuration
+* @param shorthands Shorthand registry
+* @returns The created sink
+* @since 1.4.0
+*/
+async function createSink(config, shorthands) {
+	const parsed = parseModuleReference(config.type);
+	const factory = await loadModuleExport(parsed, shorthands, "sinks");
+	let sink;
+	if (parsed.isFactory) {
+		if (typeof factory !== "function") throw new ConfigError(`Export ${parsed.exportName} in ${parsed.modulePath} is not a function, but invoked as factory`);
+		const options = { ...config };
+		delete options.type;
+		if (options.formatter) if (typeof options.formatter === "string") {
+			const fmtParsed = parseModuleReference(options.formatter);
+			const fmtFactory = await loadModuleExport(fmtParsed, shorthands, "formatters");
+			if (fmtParsed.isFactory) {
+				if (typeof fmtFactory !== "function") throw new ConfigError(`Formatter ${options.formatter} is not a function`);
+				options.formatter = fmtFactory({});
+			} else options.formatter = fmtFactory;
+		} else {
+			const fmtConfig = options.formatter;
+			const fmtParsed = parseModuleReference(fmtConfig.type);
+			const fmtFactory = await loadModuleExport(fmtParsed, shorthands, "formatters");
+			if (fmtParsed.isFactory) {
+				if (typeof fmtFactory !== "function") throw new ConfigError(`Formatter ${fmtConfig.type} is not a function`);
+				const fmtOptions = { ...fmtConfig };
+				delete fmtOptions.type;
+				options.formatter = fmtFactory(fmtOptions);
+			} else options.formatter = fmtFactory;
+		}
+		sink = factory(options);
+	} else sink = factory;
+	return sink;
+}
+/**
+* Creates a filter from configuration.
+*
+* @param config Filter configuration
+* @param shorthands Shorthand registry
+* @returns The created filter
+* @since 1.4.0
+*/
+async function createFilter(config, shorthands) {
+	const parsed = parseModuleReference(config.type);
+	const factory = await loadModuleExport(parsed, shorthands, "filters");
+	if (parsed.isFactory) {
+		if (typeof factory !== "function") throw new ConfigError(`Export ${parsed.exportName} in ${parsed.modulePath} is not a function, but invoked as factory`);
+		const options = { ...config };
+		delete options.type;
+		return factory(options);
+	}
+	return factory;
+}
+
+//#endregion
+export { createFilter, createSink };
+//# sourceMappingURL=loader.js.map