stratal 0.0.21 → 0.0.23

package/dist/locale-url-nZrZxqJP.mjs

@@ -0,0 +1,44 @@
+//#region src/router/locale-url.ts
+/**
+* Pure helpers for locale-aware URL path manipulation.
+*
+* Each function takes config explicitly so it can run anywhere (no DI, no request
+* context). For ergonomic DI-driven access, see {@link LocaleUrlService} which
+* binds these to the resolved {@link LocalePathService} config.
+*/
+/**
+* Whether a locale should be URL-prefixed under the given config.
+*
+* - No config → always prefix (caller didn't opt into locale-aware URLs).
+* - `prefixDefaultLocale: true` → every locale, including the default, is prefixed.
+* - Otherwise → only non-default locales are prefixed.
+*/
+function shouldPrefixLocale(locale, config) {
+	if (!config) return true;
+	if (config.prefixDefaultLocale === true) return true;
+	return locale !== config.defaultLocale;
+}
+/**
+* Prepend `/{locale}` to a pathname, respecting `prefixDefaultLocale`.
+* Returns the pathname unchanged when the locale shouldn't be prefixed.
+*/
+function applyLocalePrefix(pathname, locale, config) {
+	if (!shouldPrefixLocale(locale, config)) return pathname;
+	return pathname === "/" ? `/${locale}` : `/${locale}${pathname}`;
+}
+/**
+* Strip a known-locale prefix from the start of a pathname.
+* Returns the pathname unchanged if the first segment isn't in `knownLocales`.
+*/
+function stripLocalePrefix(pathname, knownLocales) {
+	const segments = pathname.split("/").filter(Boolean);
+	if (segments.length > 0 && knownLocales.includes(segments[0])) {
+		const rest = segments.slice(1).join("/");
+		return rest ? `/${rest}` : "/";
+	}
+	return pathname;
+}
+//#endregion
+export { shouldPrefixLocale as n, stripLocalePrefix as r, applyLocalePrefix as t };
+
+//# sourceMappingURL=locale-url-nZrZxqJP.mjs.map

package/dist/locale-url-nZrZxqJP.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"locale-url-nZrZxqJP.mjs","names":[],"sources":["../src/router/locale-url.ts"],"sourcesContent":["import type { LocaleUrlConfig } from './types'\n\n/**\n * Pure helpers for locale-aware URL path manipulation.\n *\n * Each function takes config explicitly so it can run anywhere (no DI, no request\n * context). For ergonomic DI-driven access, see {@link LocaleUrlService} which\n * binds these to the resolved {@link LocalePathService} config.\n */\n\n/**\n * Whether a locale should be URL-prefixed under the given config.\n *\n * - No config → always prefix (caller didn't opt into locale-aware URLs).\n * - `prefixDefaultLocale: true` → every locale, including the default, is prefixed.\n * - Otherwise → only non-default locales are prefixed.\n */\nexport function shouldPrefixLocale(locale: string, config: LocaleUrlConfig | undefined): boolean {\n  if (!config) return true\n  if (config.prefixDefaultLocale === true) return true\n  return locale !== config.defaultLocale\n}\n\n/**\n * Prepend `/{locale}` to a pathname, respecting `prefixDefaultLocale`.\n * Returns the pathname unchanged when the locale shouldn't be prefixed.\n */\nexport function applyLocalePrefix(pathname: string, locale: string, config: LocaleUrlConfig | undefined): string {\n  if (!shouldPrefixLocale(locale, config)) return pathname\n  return pathname === '/' ? `/${locale}` : `/${locale}${pathname}`\n}\n\n/**\n * Strip a known-locale prefix from the start of a pathname.\n * Returns the pathname unchanged if the first segment isn't in `knownLocales`.\n */\nexport function stripLocalePrefix(pathname: string, knownLocales: readonly string[]): string {\n  const segments = pathname.split('/').filter(Boolean)\n  if (segments.length > 0 && knownLocales.includes(segments[0])) {\n    const rest = segments.slice(1).join('/')\n    return rest ? `/${rest}` : '/'\n  }\n  return pathname\n}\n"],"mappings":";;;;;;;;;;;;;;;AAiBA,SAAgB,mBAAmB,QAAgB,QAA8C;CAC/F,IAAI,CAAC,QAAQ,OAAO;CACpB,IAAI,OAAO,wBAAwB,MAAM,OAAO;CAChD,OAAO,WAAW,OAAO;AAC3B;;;;;AAMA,SAAgB,kBAAkB,UAAkB,QAAgB,QAA6C;CAC/G,IAAI,CAAC,mBAAmB,QAAQ,MAAM,GAAG,OAAO;CAChD,OAAO,aAAa,MAAM,IAAI,WAAW,IAAI,SAAS;AACxD;;;;;AAMA,SAAgB,kBAAkB,UAAkB,cAAyC;CAC3F,MAAM,WAAW,SAAS,MAAM,GAAG,EAAE,OAAO,OAAO;CACnD,IAAI,SAAS,SAAS,KAAK,aAAa,SAAS,SAAS,EAAE,GAAG;EAC7D,MAAM,OAAO,SAAS,MAAM,CAAC,EAAE,KAAK,GAAG;EACvC,OAAO,OAAO,IAAI,SAAS;CAC7B;CACA,OAAO;AACT"}

package/dist/locale-url.service-C2EWmGdq.mjs

@@ -0,0 +1,41 @@
+import { t as __exportAll } from "./chunk-BBjsoOtd.mjs";
+import { d as inject, s as Singleton, v as ROUTER_TOKENS } from "./di-DseMn-z9.mjs";
+import { n as __decorateParam, t as __decorate } from "./decorate-CuAoSZvs.mjs";
+import { n as shouldPrefixLocale, r as stripLocalePrefix, t as applyLocalePrefix } from "./locale-url-nZrZxqJP.mjs";
+//#region src/router/services/locale-url.service.ts
+var locale_url_service_exports = /* @__PURE__ */ __exportAll({ LocaleUrlService: () => LocaleUrlService });
+let LocaleUrlService = class LocaleUrlService {
+	localePath;
+	constructor(localePath) {
+		this.localePath = localePath;
+	}
+	/** Whether path-based locale detection is enabled — i.e., locales have URL-distinct path variants. */
+	get pathEnabled() {
+		return this.localePath.enabled;
+	}
+	/** Whether the given locale should get a URL prefix under the current config. */
+	shouldPrefix(locale) {
+		return shouldPrefixLocale(locale, this.toUrlConfig());
+	}
+	/** Prepend `/{locale}` to a pathname, respecting `prefixDefaultLocale`. */
+	applyPrefix(pathname, locale) {
+		return applyLocalePrefix(pathname, locale, this.toUrlConfig());
+	}
+	/** Strip a known-locale prefix from the start of a pathname. */
+	stripPrefix(pathname) {
+		return stripLocalePrefix(pathname, this.localePath.localePathConfig?.allLocales ?? []);
+	}
+	toUrlConfig() {
+		const config = this.localePath.localePathConfig;
+		if (!config) return void 0;
+		return {
+			defaultLocale: config.defaultLocale,
+			prefixDefaultLocale: this.localePath.prefixDefaultLocale
+		};
+	}
+};
+LocaleUrlService = __decorate([Singleton(), __decorateParam(0, inject(ROUTER_TOKENS.LocalePathService))], LocaleUrlService);
+//#endregion
+export { locale_url_service_exports as n, LocaleUrlService as t };
+
+//# sourceMappingURL=locale-url.service-C2EWmGdq.mjs.map

package/dist/locale-url.service-C2EWmGdq.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"locale-url.service-C2EWmGdq.mjs","names":[],"sources":["../src/router/services/locale-url.service.ts"],"sourcesContent":["import { inject } from '../../di'\nimport { Singleton } from '../../di/decorators'\nimport { applyLocalePrefix, shouldPrefixLocale, stripLocalePrefix } from '../locale-url'\nimport { ROUTER_TOKENS } from '../router.tokens'\nimport type { LocaleUrlConfig } from '../types'\nimport { type LocalePathService } from './locale-path.service'\n\n/**\n * DI-friendly wrapper around the pure locale-url helpers.\n *\n * Binds {@link LocalePathService} config so consumers can call `applyPrefix`,\n * `stripPrefix`, and `shouldPrefix` without passing config every time.\n *\n * Useful for canonical URL generation, sitemap builders, redirect middleware,\n * hreflang link emission, and anywhere else a request handler needs to compute\n * locale-aware path variants.\n */\n@Singleton()\nexport class LocaleUrlService {\n  constructor(\n    @inject(ROUTER_TOKENS.LocalePathService) private readonly localePath: LocalePathService,\n  ) { }\n\n  /** Whether path-based locale detection is enabled — i.e., locales have URL-distinct path variants. */\n  get pathEnabled(): boolean {\n    return this.localePath.enabled\n  }\n\n  /** Whether the given locale should get a URL prefix under the current config. */\n  shouldPrefix(locale: string): boolean {\n    return shouldPrefixLocale(locale, this.toUrlConfig())\n  }\n\n  /** Prepend `/{locale}` to a pathname, respecting `prefixDefaultLocale`. */\n  applyPrefix(pathname: string, locale: string): string {\n    return applyLocalePrefix(pathname, locale, this.toUrlConfig())\n  }\n\n  /** Strip a known-locale prefix from the start of a pathname. */\n  stripPrefix(pathname: string): string {\n    const known = this.localePath.localePathConfig?.allLocales ?? []\n    return stripLocalePrefix(pathname, known)\n  }\n\n  private toUrlConfig(): LocaleUrlConfig | undefined {\n    const config = this.localePath.localePathConfig\n    if (!config) return undefined\n    return { defaultLocale: config.defaultLocale, prefixDefaultLocale: this.localePath.prefixDefaultLocale }\n  }\n}\n"],"mappings":";;;;;;AAkBO,IAAA,mBAAA,MAAM,iBAAiB;CAEgC;CAD5D,YACE,YACA;EAD0D,KAAA,aAAA;CACxD;;CAGJ,IAAI,cAAuB;EACzB,OAAO,KAAK,WAAW;CACzB;;CAGA,aAAa,QAAyB;EACpC,OAAO,mBAAmB,QAAQ,KAAK,YAAY,CAAC;CACtD;;CAGA,YAAY,UAAkB,QAAwB;EACpD,OAAO,kBAAkB,UAAU,QAAQ,KAAK,YAAY,CAAC;CAC/D;;CAGA,YAAY,UAA0B;EAEpC,OAAO,kBAAkB,UADX,KAAK,WAAW,kBAAkB,cAAc,CAAC,CACvB;CAC1C;CAEA,cAAmD;EACjD,MAAM,SAAS,KAAK,WAAW;EAC/B,IAAI,CAAC,QAAQ,OAAO,KAAA;EACpB,OAAO;GAAE,eAAe,OAAO;GAAe,qBAAqB,KAAK,WAAW;EAAoB;CACzG;AACF;+BAhCC,UAAU,GAAA,gBAAA,GAGN,OAAO,cAAc,iBAAiB,CAAA,CAAA,GAAA,gBAAA"}

package/dist/logger/index.d.mts

@@ -1,2 +1,2 @@
-import { a as LogEntry, c as LOG_LEVEL_PRIORITY, i as LoggerService, l as LogLevel, n as PrettyFormatter, o as InternalLogContext, r as JsonFormatter, s as LogContext, t as ConsoleTransport, u as LOGGER_TOKENS } from "../index-DBd_2wv8.mjs";
-export { ConsoleTransport, InternalLogContext, JsonFormatter, LOGGER_TOKENS, LOG_LEVEL_PRIORITY, LogContext, LogEntry, LogLevel, LoggerService, PrettyFormatter };
+import { a as InternalLogContext, c as LogLevel, i as LogEntry, l as LOGGER_TOKENS, n as JsonFormatter, o as LogContext, r as LoggerService, s as LOG_LEVEL_PRIORITY, t as PrettyFormatter } from "../index-BUt92sAE.mjs";
+export { InternalLogContext, JsonFormatter, LOGGER_TOKENS, LOG_LEVEL_PRIORITY, LogContext, LogEntry, LogLevel, LoggerService, PrettyFormatter };

package/dist/logger/index.mjs

@@ -1,2 +1,170 @@
-import { c as LOG_LEVEL_PRIORITY, i as LoggerService, l as LogLevel, n as PrettyFormatter, r as JsonFormatter, t as ConsoleTransport, u as LOGGER_TOKENS } from "../logger-DlV7NtvD.mjs";
-export { ConsoleTransport, JsonFormatter, LOGGER_TOKENS, LOG_LEVEL_PRIORITY, LogLevel, LoggerService, PrettyFormatter };
+import { c as Transient, d as inject } from "../di-DseMn-z9.mjs";
+import { n as __decorateParam, t as __decorate } from "../decorate-CuAoSZvs.mjs";
+//#region src/logger/logger.tokens.ts
+const LOGGER_TOKENS = {
+	LoggerService: Symbol.for("stratal:logger:service"),
+	Formatter: Symbol.for("stratal:logger:formatter"),
+	LogLevelOptions: Symbol.for("stratal:logger:log:level:options")
+};
+//#endregion
+//#region src/logger/contracts/log-level.ts
+/**
+* Log severity levels
+* Ordered from least to most severe
+*/
+let LogLevel = /* @__PURE__ */ function(LogLevel) {
+	LogLevel["DEBUG"] = "debug";
+	LogLevel["INFO"] = "info";
+	LogLevel["WARN"] = "warn";
+	LogLevel["ERROR"] = "error";
+	return LogLevel;
+}({});
+/**
+* Map log levels to numeric priorities (for filtering)
+* Higher numbers = more severe = higher priority
+*/
+const LOG_LEVEL_PRIORITY = {
+	["debug"]: 0,
+	["info"]: 1,
+	["warn"]: 2,
+	["error"]: 3
+};
+//#endregion
+//#region src/logger/services/logger.service.ts
+let LoggerService = class LoggerService {
+	logLevel;
+	formatter;
+	constructor(logLevel, formatter) {
+		this.logLevel = logLevel;
+		this.formatter = formatter;
+	}
+	debug(message, context) {
+		this.log("debug", message, context);
+	}
+	info(message, context) {
+		this.log("info", message, context);
+	}
+	warn(message, context) {
+		this.log("warn", message, context);
+	}
+	error(message, errorOrContext, maybeContext) {
+		let context;
+		let error;
+		if (errorOrContext instanceof Error) {
+			error = errorOrContext;
+			context = maybeContext;
+		} else context = errorOrContext;
+		this.log("error", message, context, error);
+	}
+	log(level, message, userContext, error) {
+		if (LOG_LEVEL_PRIORITY[level] < LOG_LEVEL_PRIORITY[this.logLevel]) return;
+		const entry = {
+			level,
+			message,
+			context: this.enrichContext(userContext ?? {}),
+			error: error ? this.serializeError(error) : void 0
+		};
+		const formatted = this.formatter.format(entry);
+		this.writeToConsole(level, formatted);
+	}
+	writeToConsole(level, formatted) {
+		switch (level) {
+			case "debug":
+				console.debug(formatted);
+				break;
+			case "info":
+				console.info(formatted);
+				break;
+			case "warn":
+				console.warn(formatted);
+				break;
+			case "error":
+				console.error(formatted);
+				break;
+		}
+	}
+	enrichContext(userContext) {
+		return {
+			...userContext,
+			timestamp: Date.now()
+		};
+	}
+	serializeError(error) {
+		return {
+			message: error.message,
+			stack: error.stack,
+			name: error.name
+		};
+	}
+};
+LoggerService = __decorate([
+	Transient(),
+	__decorateParam(0, inject(LOGGER_TOKENS.LogLevelOptions)),
+	__decorateParam(1, inject(LOGGER_TOKENS.Formatter))
+], LoggerService);
+//#endregion
+//#region src/logger/formatters/json-formatter.ts
+/**
+* JSON Formatter
+*
+* Produces structured JSON logs for production environments.
+* Optimized for log aggregation systems (Cloudflare Analytics, Datadog, etc.)
+*
+* Output format:
+* {
+*   "level": "info",
+*   "message": "User logged in",
+*   "timestamp": 1234567890,
+*   "userId": "user_456",
+*   "error": { "message": "...", "stack": "..." }
+* }
+*/
+var JsonFormatter = class {
+	format(entry) {
+		const output = {
+			level: entry.level,
+			message: entry.message,
+			...entry.context,
+			...entry.error && { error: entry.error }
+		};
+		return JSON.stringify(output);
+	}
+};
+//#endregion
+//#region src/logger/formatters/pretty-formatter.ts
+/**
+* Pretty Formatter
+*
+* Human-readable colored output for development environments.
+* Uses ANSI color codes for terminal output.
+*
+* Output format:
+* [2024-01-15 10:30:45] INFO: User logged in
+*   userId: user_456
+*/
+var PrettyFormatter = class {
+	colors = {
+		["debug"]: "\x1B[36m",
+		["info"]: "\x1B[32m",
+		["warn"]: "\x1B[33m",
+		["error"]: "\x1B[31m"
+	};
+	reset = "\x1B[0m";
+	format(entry) {
+		let output = `${this.colors[entry.level]}[${new Date(entry.context.timestamp).toISOString()}] ${entry.level.toUpperCase().padEnd(5)}${this.reset}: ${entry.message}`;
+		const { timestamp: _, ...contextWithoutTimestamp } = entry.context;
+		const contextEntries = Object.entries(contextWithoutTimestamp);
+		if (contextEntries.length > 0) {
+			output += "\n";
+			contextEntries.forEach(([key, value]) => {
+				output += `  ${key}: ${JSON.stringify(value)}\n`;
+			});
+		}
+		if (entry.error?.stack) output += `\n${entry.error.stack}\n`;
+		return output.trimEnd();
+	}
+};
+//#endregion
+export { JsonFormatter, LOGGER_TOKENS, LOG_LEVEL_PRIORITY, LogLevel, LoggerService, PrettyFormatter };
+
+//# sourceMappingURL=index.mjs.map

package/dist/logger/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/logger/logger.tokens.ts","../../src/logger/contracts/log-level.ts","../../src/logger/services/logger.service.ts","../../src/logger/formatters/json-formatter.ts","../../src/logger/formatters/pretty-formatter.ts"],"sourcesContent":["export const LOGGER_TOKENS = {\n  LoggerService: Symbol.for('stratal:logger:service'),\n  Formatter: Symbol.for('stratal:logger:formatter'),\n  LogLevelOptions: Symbol.for('stratal:logger:log:level:options'),\n} as const\n","/**\n * Log severity levels\n * Ordered from least to most severe\n */\nexport enum LogLevel {\n  DEBUG = 'debug',\n  INFO = 'info',\n  WARN = 'warn',\n  ERROR = 'error',\n}\n\n/**\n * Map log levels to numeric priorities (for filtering)\n * Higher numbers = more severe = higher priority\n */\nexport const LOG_LEVEL_PRIORITY: Record<LogLevel, number> = {\n  [LogLevel.DEBUG]: 0,\n  [LogLevel.INFO]: 1,\n  [LogLevel.WARN]: 2,\n  [LogLevel.ERROR]: 3,\n}\n","import { inject } from '../../di'\nimport { Transient } from '../../di/decorators'\nimport type { InternalLogContext, LogContext, LogEntry } from '../contracts'\nimport { LOG_LEVEL_PRIORITY, LogLevel } from '../contracts/log-level'\nimport type { ILogFormatter } from '../formatters/formatter.interface'\nimport { LOGGER_TOKENS } from '../logger.tokens'\n\n@Transient()\nexport class LoggerService {\n  constructor(\n    @inject(LOGGER_TOKENS.LogLevelOptions)\n    private readonly logLevel: LogLevel,\n\n    @inject(LOGGER_TOKENS.Formatter)\n    private readonly formatter: ILogFormatter,\n  ) { }\n\n  debug(message: string, context?: LogContext): void {\n    this.log(LogLevel.DEBUG, message, context)\n  }\n\n  info(message: string, context?: LogContext): void {\n    this.log(LogLevel.INFO, message, context)\n  }\n\n  warn(message: string, context?: LogContext): void {\n    this.log(LogLevel.WARN, message, context)\n  }\n\n  error(message: string, error: Error, context?: LogContext): void\n  error(message: string, context?: LogContext): void\n  error(message: string, errorOrContext?: Error | LogContext, maybeContext?: LogContext): void {\n    let context: LogContext | undefined\n    let error: Error | undefined\n\n    if (errorOrContext instanceof Error) {\n      error = errorOrContext\n      context = maybeContext\n    } else {\n      context = errorOrContext\n    }\n\n    this.log(LogLevel.ERROR, message, context, error)\n  }\n\n  private log(\n    level: LogLevel,\n    message: string,\n    userContext?: LogContext,\n    error?: Error\n  ): void {\n    if (LOG_LEVEL_PRIORITY[level] < LOG_LEVEL_PRIORITY[this.logLevel]) {\n      return\n    }\n\n    const entry: LogEntry = {\n      level,\n      message,\n      context: this.enrichContext(userContext ?? {}),\n      error: error ? this.serializeError(error) : undefined,\n    }\n\n    const formatted = this.formatter.format(entry)\n    this.writeToConsole(level, formatted)\n  }\n\n  private writeToConsole(level: LogLevel, formatted: string): void {\n    switch (level) {\n      case LogLevel.DEBUG:\n        console.debug(formatted)\n        break\n      case LogLevel.INFO:\n        console.info(formatted)\n        break\n      case LogLevel.WARN:\n        console.warn(formatted)\n        break\n      case LogLevel.ERROR:\n        console.error(formatted)\n        break\n    }\n  }\n\n  private enrichContext(userContext: LogContext): InternalLogContext {\n    return {\n      ...userContext,\n      timestamp: Date.now(),\n    }\n  }\n\n  private serializeError(error: Error): { message: string; stack?: string; name?: string } {\n    return {\n      message: error.message,\n      stack: error.stack,\n      name: error.name,\n    }\n  }\n}\n","import type { LogEntry } from '../contracts'\nimport type { ILogFormatter } from './formatter.interface'\n\n/**\n * JSON Formatter\n *\n * Produces structured JSON logs for production environments.\n * Optimized for log aggregation systems (Cloudflare Analytics, Datadog, etc.)\n *\n * Output format:\n * {\n *   \"level\": \"info\",\n *   \"message\": \"User logged in\",\n *   \"timestamp\": 1234567890,\n *   \"userId\": \"user_456\",\n *   \"error\": { \"message\": \"...\", \"stack\": \"...\" }\n * }\n */\nexport class JsonFormatter implements ILogFormatter {\n  format(entry: LogEntry): string {\n    const output = {\n      level: entry.level,\n      message: entry.message,\n      ...entry.context,\n      ...(entry.error && { error: entry.error }),\n    }\n\n    return JSON.stringify(output)\n  }\n}\n","import type { LogEntry } from '../contracts'\nimport { LogLevel } from '../contracts'\nimport type { ILogFormatter } from './formatter.interface'\n\n/**\n * Pretty Formatter\n *\n * Human-readable colored output for development environments.\n * Uses ANSI color codes for terminal output.\n *\n * Output format:\n * [2024-01-15 10:30:45] INFO: User logged in\n *   userId: user_456\n */\nexport class PrettyFormatter implements ILogFormatter {\n  private readonly colors: Record<LogLevel, string> = {\n    [LogLevel.DEBUG]: '\\x1b[36m', // Cyan\n    [LogLevel.INFO]: '\\x1b[32m', // Green\n    [LogLevel.WARN]: '\\x1b[33m', // Yellow\n    [LogLevel.ERROR]: '\\x1b[31m', // Red\n  }\n\n  private readonly reset = '\\x1b[0m'\n\n  format(entry: LogEntry): string {\n    const color = this.colors[entry.level]\n    const timestamp = new Date(entry.context.timestamp).toISOString()\n    const levelStr = entry.level.toUpperCase().padEnd(5)\n\n    let output = `${color}[${timestamp}] ${levelStr}${this.reset}: ${entry.message}`\n\n    // Add context (exclude timestamp)\n    const { timestamp: _, ...contextWithoutTimestamp } = entry.context\n    const contextEntries = Object.entries(contextWithoutTimestamp)\n\n    if (contextEntries.length > 0) {\n      output += '\\n'\n      contextEntries.forEach(([key, value]) => {\n        output += `  ${key}: ${JSON.stringify(value)}\\n`\n      })\n    }\n\n    // Add error stack if present\n    if (entry.error?.stack) {\n      output += `\\n${entry.error.stack}\\n`\n    }\n\n    return output.trimEnd()\n  }\n}\n"],"mappings":"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"}

package/dist/macroable/index.d.mts

@@ -1,2 +1,2 @@
-import { n as MacroFunction, t as Macroable } from "../index-7-hU3GTV.mjs";
-export { MacroFunction, Macroable };
+import { n as MacroFunction, t as Macroable } from "../index-0ItCjaqw.mjs";
+export { type MacroFunction, Macroable };

package/dist/macroable/index.mjs

@@ -1,2 +1,2 @@
-import { t as Macroable } from "../macroable-BmufBshB.mjs";
+import { t as Macroable } from "../macroable-cvDTFZ_A.mjs";
 export { Macroable };

package/dist/{macroable-BmufBshB.mjs → macroable-cvDTFZ_A.mjs}

@@ -119,4 +119,4 @@ var Macroable = class {
 //#endregion
 export { Macroable as t };
 
-//# sourceMappingURL=macroable-BmufBshB.mjs.map
+//# sourceMappingURL=macroable-cvDTFZ_A.mjs.map

package/dist/{macroable-BmufBshB.mjs.map → macroable-cvDTFZ_A.mjs.map}

@@ -1 +1 @@
-{"version":3,"file":"macroable-BmufBshB.mjs","names":[],"sources":["../src/macroable/macroable.ts"],"sourcesContent":["import type { MacroFunction } from './types'\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype Constructor = abstract new (...args: any[]) => any\n\n/**\n * Abstract base class for adding macros, instance properties, and getters\n * to classes at runtime.\n *\n * Inspired by [@poppinss/macroable](https://github.com/poppinss/macroable)\n * and Laravel's Macroable trait.\n *\n * @example\n * ```typescript\n * // Register a macro\n * RouterContext.macro('flash', function (this: RouterContext, key: string, value: unknown) {\n *   const session = this.getContainer().resolve(SessionService)\n *   session.flash(key, value)\n * })\n *\n * // Register a getter\n * RouterContext.getter('requestId', function (this: RouterContext) {\n *   return this.header('x-request-id') ?? crypto.randomUUID()\n * }, true)\n *\n * // Register a per-instance property (safe for destructuring)\n * RouterContext.instanceProperty('getUser', function (this: RouterContext) {\n *   return this.getContainer().resolve(AuthContext).user\n * })\n * ```\n */\nexport abstract class Macroable {\n  [key: string | symbol]: unknown\n  /**\n   * Per-instance properties. Each entry is applied and bound\n   * to `this` inside the constructor so destructuring stays safe.\n   */\n  protected static instanceMacros = new Set<{ key: string | symbol; value: unknown }>()\n\n  /**\n   * Names registered via macro() — used by hasMacro() and flushMacros().\n   */\n  protected static macroNames = new Set<string | symbol>()\n\n  /**\n   * Names registered via getter() — used by hasMacro() and flushMacros().\n   */\n  protected static getterNames = new Set<string | symbol>()\n\n  /**\n   * Original prototype values saved before macro() overrides them.\n   * Used by flushMacros() to restore native methods.\n   */\n  private static _originals = new Map<string | symbol, { existed: boolean; value: unknown }>()\n\n  // ── Macros (prototype-level) ──────────────────────────────\n\n  /**\n   * Register a macro on the class prototype.\n   * Can override existing methods.\n   *\n   * When the name matches an existing property, the value type is auto-derived.\n   *\n   * @param name - Method or property name\n   * @param value - Function or value to assign\n   */\n  static macro<T extends Constructor, K extends keyof InstanceType<T>>(\n    this: T,\n    name: K,\n    value: InstanceType<T>[K],\n  ): void\n  static macro(name: string | symbol, value: unknown): void\n  static macro(name: string | symbol, value: unknown): void {\n    if (!Object.prototype.hasOwnProperty.call(this, 'macroNames')) {\n      this.macroNames = new Set(this.macroNames)\n    }\n    if (!Object.prototype.hasOwnProperty.call(this, '_originals')) {\n      this._originals = new Map(this._originals)\n    }\n\n    // Save the original value before first override so flushMacros() can restore it\n    if (!this._originals.has(name)) {\n      const existed = Object.prototype.hasOwnProperty.call(this.prototype, name)\n      this._originals.set(name, {\n        existed,\n        value: existed ? (this.prototype as Record<string | symbol, unknown>)[name] : undefined,\n      })\n    }\n\n    this.macroNames.add(name);\n    (this.prototype as Record<string | symbol, unknown>)[name] = value\n  }\n\n  // ── Instance properties (bound per-instance) ─────────────\n\n  /**\n   * Register a per-instance property that is bound to `this`\n   * in the constructor. Safe for destructuring.\n   *\n   * When the name matches an existing property, the value type is auto-derived.\n   *\n   * @param name - Property name\n   * @param value - Function (will be bound) or value\n   */\n  static instanceProperty<T extends Constructor, K extends keyof InstanceType<T>>(\n    this: T,\n    name: K,\n    value: InstanceType<T>[K],\n  ): void\n  static instanceProperty(name: string | symbol, value: unknown): void\n  static instanceProperty(name: string | symbol, value: unknown): void {\n    if (!Object.prototype.hasOwnProperty.call(this, 'instanceMacros')) {\n      this.instanceMacros = new Set(this.instanceMacros)\n    }\n    this.instanceMacros.add({ key: name, value })\n  }\n\n  // ── Getters (Object.defineProperty on prototype) ──────────\n\n  /**\n   * Register a computed getter on the class prototype.\n   *\n   * @param name - Property name\n   * @param accumulator - Function that computes the value (called with instance as `this`)\n   * @param singleton - If true, cache the value after first access\n   */\n  static getter<T extends Constructor, K extends keyof InstanceType<T>>(\n    this: T,\n    name: K,\n    accumulator: (this: InstanceType<T>) => InstanceType<T>[K],\n    singleton?: boolean,\n  ): void\n  static getter(name: string | symbol, accumulator: MacroFunction, singleton?: boolean): void\n  static getter(\n    name: string | symbol,\n    accumulator: MacroFunction,\n    singleton = false,\n  ): void {\n    if (!Object.prototype.hasOwnProperty.call(this, 'getterNames')) {\n      this.getterNames = new Set(this.getterNames)\n    }\n    this.getterNames.add(name)\n\n    Object.defineProperty(this.prototype, name, {\n      get(): unknown {\n        const value: unknown = accumulator.call(this)\n        if (singleton) {\n          Object.defineProperty(this, name, {\n            value,\n            configurable: false,\n            enumerable: false,\n            writable: false,\n          })\n        }\n        return value\n      },\n      configurable: true,\n      enumerable: false,\n    })\n  }\n\n  // ── Introspection ─────────────────────────────────────────\n\n  /**\n   * Check if a macro, instance property, or getter is registered.\n   *\n   * @param name - Name to check\n   */\n  static hasMacro(name: string | symbol): boolean {\n    return (\n      this.macroNames.has(name) ||\n      [...this.instanceMacros].some((m) => m.key === name) ||\n      this.getterNames.has(name)\n    )\n  }\n\n  // ── Cleanup ───────────────────────────────────────────────\n\n  /**\n   * Remove all macros, instance properties, and getters\n   * registered on this class. Does not affect parent classes.\n   */\n  static flushMacros(): void {\n    const proto = this.prototype as Record<string | symbol, unknown>\n\n    // Restore original prototype values or delete if they didn't exist before\n    for (const name of this.macroNames) {\n      const original = this._originals.get(name)\n      if (original?.existed) {\n        proto[name] = original.value\n      } else {\n        Reflect.deleteProperty(proto, name)\n      }\n    }\n    for (const name of this.getterNames) {\n      Reflect.deleteProperty(proto, name)\n    }\n\n    if (Object.prototype.hasOwnProperty.call(this, 'macroNames')) {\n      this.macroNames.clear()\n    }\n    if (Object.prototype.hasOwnProperty.call(this, 'instanceMacros')) {\n      this.instanceMacros.clear()\n    }\n    if (Object.prototype.hasOwnProperty.call(this, 'getterNames')) {\n      this.getterNames.clear()\n    }\n    if (Object.prototype.hasOwnProperty.call(this, '_originals')) {\n      this._originals.clear()\n    }\n  }\n\n  // ── Constructor (applies instance properties) ─────────────\n\n  constructor() {\n    const Constructor = this.constructor as typeof Macroable\n    const self = this as Record<string | symbol, unknown>\n    Constructor.instanceMacros.forEach(({ key, value }) => {\n      if (typeof value === 'function') {\n        self[key] = value.bind(this)\n      } else {\n        self[key] = value\n      }\n    })\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,IAAsB,YAAtB,MAAgC;;;;;CAM9B,OAAiB,iCAAiB,IAAI,KAA+C;;;;CAKrF,OAAiB,6BAAa,IAAI,KAAsB;;;;CAKxD,OAAiB,8BAAc,IAAI,KAAsB;;;;;CAMzD,OAAe,6BAAa,IAAI,KAA4D;CAmB5F,OAAO,MAAM,MAAuB,OAAsB;EACxD,IAAI,CAAC,OAAO,UAAU,eAAe,KAAK,MAAM,aAAa,EAC3D,KAAK,aAAa,IAAI,IAAI,KAAK,WAAW;EAE5C,IAAI,CAAC,OAAO,UAAU,eAAe,KAAK,MAAM,aAAa,EAC3D,KAAK,aAAa,IAAI,IAAI,KAAK,WAAW;EAI5C,IAAI,CAAC,KAAK,WAAW,IAAI,KAAK,EAAE;GAC9B,MAAM,UAAU,OAAO,UAAU,eAAe,KAAK,KAAK,WAAW,KAAK;GAC1E,KAAK,WAAW,IAAI,MAAM;IACxB;IACA,OAAO,UAAW,KAAK,UAA+C,QAAQ,KAAA;IAC/E,CAAC;;EAGJ,KAAK,WAAW,IAAI,KAAK;EACzB,KAAM,UAA+C,QAAQ;;CAoB/D,OAAO,iBAAiB,MAAuB,OAAsB;EACnE,IAAI,CAAC,OAAO,UAAU,eAAe,KAAK,MAAM,iBAAiB,EAC/D,KAAK,iBAAiB,IAAI,IAAI,KAAK,eAAe;EAEpD,KAAK,eAAe,IAAI;GAAE,KAAK;GAAM;GAAO,CAAC;;CAmB/C,OAAO,OACL,MACA,aACA,YAAY,OACN;EACN,IAAI,CAAC,OAAO,UAAU,eAAe,KAAK,MAAM,cAAc,EAC5D,KAAK,cAAc,IAAI,IAAI,KAAK,YAAY;EAE9C,KAAK,YAAY,IAAI,KAAK;EAE1B,OAAO,eAAe,KAAK,WAAW,MAAM;GAC1C,MAAe;IACb,MAAM,QAAiB,YAAY,KAAK,KAAK;IAC7C,IAAI,WACF,OAAO,eAAe,MAAM,MAAM;KAChC;KACA,cAAc;KACd,YAAY;KACZ,UAAU;KACX,CAAC;IAEJ,OAAO;;GAET,cAAc;GACd,YAAY;GACb,CAAC;;;;;;;CAUJ,OAAO,SAAS,MAAgC;EAC9C,OACE,KAAK,WAAW,IAAI,KAAK,IACzB,CAAC,GAAG,KAAK,eAAe,CAAC,MAAM,MAAM,EAAE,QAAQ,KAAK,IACpD,KAAK,YAAY,IAAI,KAAK;;;;;;CAU9B,OAAO,cAAoB;EACzB,MAAM,QAAQ,KAAK;EAGnB,KAAK,MAAM,QAAQ,KAAK,YAAY;GAClC,MAAM,WAAW,KAAK,WAAW,IAAI,KAAK;GAC1C,IAAI,UAAU,SACZ,MAAM,QAAQ,SAAS;QAEvB,QAAQ,eAAe,OAAO,KAAK;;EAGvC,KAAK,MAAM,QAAQ,KAAK,aACtB,QAAQ,eAAe,OAAO,KAAK;EAGrC,IAAI,OAAO,UAAU,eAAe,KAAK,MAAM,aAAa,EAC1D,KAAK,WAAW,OAAO;EAEzB,IAAI,OAAO,UAAU,eAAe,KAAK,MAAM,iBAAiB,EAC9D,KAAK,eAAe,OAAO;EAE7B,IAAI,OAAO,UAAU,eAAe,KAAK,MAAM,cAAc,EAC3D,KAAK,YAAY,OAAO;EAE1B,IAAI,OAAO,UAAU,eAAe,KAAK,MAAM,aAAa,EAC1D,KAAK,WAAW,OAAO;;CAM3B,cAAc;EACZ,MAAM,cAAc,KAAK;EACzB,MAAM,OAAO;EACb,YAAY,eAAe,SAAS,EAAE,KAAK,YAAY;GACrD,IAAI,OAAO,UAAU,YACnB,KAAK,OAAO,MAAM,KAAK,KAAK;QAE5B,KAAK,OAAO;IAEd"}
+{"version":3,"file":"macroable-cvDTFZ_A.mjs","names":[],"sources":["../src/macroable/macroable.ts"],"sourcesContent":["import type { MacroFunction } from './types'\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype Constructor = abstract new (...args: any[]) => any\n\n/**\n * Abstract base class for adding macros, instance properties, and getters\n * to classes at runtime.\n *\n * Inspired by [@poppinss/macroable](https://github.com/poppinss/macroable)\n * and Laravel's Macroable trait.\n *\n * @example\n * ```typescript\n * // Register a macro\n * RouterContext.macro('flash', function (this: RouterContext, key: string, value: unknown) {\n *   const session = this.getContainer().resolve(SessionService)\n *   session.flash(key, value)\n * })\n *\n * // Register a getter\n * RouterContext.getter('requestId', function (this: RouterContext) {\n *   return this.header('x-request-id') ?? crypto.randomUUID()\n * }, true)\n *\n * // Register a per-instance property (safe for destructuring)\n * RouterContext.instanceProperty('getUser', function (this: RouterContext) {\n *   return this.getContainer().resolve(AuthContext).user\n * })\n * ```\n */\nexport abstract class Macroable {\n  [key: string | symbol]: unknown\n  /**\n   * Per-instance properties. Each entry is applied and bound\n   * to `this` inside the constructor so destructuring stays safe.\n   */\n  protected static instanceMacros = new Set<{ key: string | symbol; value: unknown }>()\n\n  /**\n   * Names registered via macro() — used by hasMacro() and flushMacros().\n   */\n  protected static macroNames = new Set<string | symbol>()\n\n  /**\n   * Names registered via getter() — used by hasMacro() and flushMacros().\n   */\n  protected static getterNames = new Set<string | symbol>()\n\n  /**\n   * Original prototype values saved before macro() overrides them.\n   * Used by flushMacros() to restore native methods.\n   */\n  private static _originals = new Map<string | symbol, { existed: boolean; value: unknown }>()\n\n  // ── Macros (prototype-level) ──────────────────────────────\n\n  /**\n   * Register a macro on the class prototype.\n   * Can override existing methods.\n   *\n   * When the name matches an existing property, the value type is auto-derived.\n   *\n   * @param name - Method or property name\n   * @param value - Function or value to assign\n   */\n  static macro<T extends Constructor, K extends keyof InstanceType<T>>(\n    this: T,\n    name: K,\n    value: InstanceType<T>[K],\n  ): void\n  static macro(name: string | symbol, value: unknown): void\n  static macro(name: string | symbol, value: unknown): void {\n    if (!Object.prototype.hasOwnProperty.call(this, 'macroNames')) {\n      this.macroNames = new Set(this.macroNames)\n    }\n    if (!Object.prototype.hasOwnProperty.call(this, '_originals')) {\n      this._originals = new Map(this._originals)\n    }\n\n    // Save the original value before first override so flushMacros() can restore it\n    if (!this._originals.has(name)) {\n      const existed = Object.prototype.hasOwnProperty.call(this.prototype, name)\n      this._originals.set(name, {\n        existed,\n        value: existed ? (this.prototype as Record<string | symbol, unknown>)[name] : undefined,\n      })\n    }\n\n    this.macroNames.add(name);\n    (this.prototype as Record<string | symbol, unknown>)[name] = value\n  }\n\n  // ── Instance properties (bound per-instance) ─────────────\n\n  /**\n   * Register a per-instance property that is bound to `this`\n   * in the constructor. Safe for destructuring.\n   *\n   * When the name matches an existing property, the value type is auto-derived.\n   *\n   * @param name - Property name\n   * @param value - Function (will be bound) or value\n   */\n  static instanceProperty<T extends Constructor, K extends keyof InstanceType<T>>(\n    this: T,\n    name: K,\n    value: InstanceType<T>[K],\n  ): void\n  static instanceProperty(name: string | symbol, value: unknown): void\n  static instanceProperty(name: string | symbol, value: unknown): void {\n    if (!Object.prototype.hasOwnProperty.call(this, 'instanceMacros')) {\n      this.instanceMacros = new Set(this.instanceMacros)\n    }\n    this.instanceMacros.add({ key: name, value })\n  }\n\n  // ── Getters (Object.defineProperty on prototype) ──────────\n\n  /**\n   * Register a computed getter on the class prototype.\n   *\n   * @param name - Property name\n   * @param accumulator - Function that computes the value (called with instance as `this`)\n   * @param singleton - If true, cache the value after first access\n   */\n  static getter<T extends Constructor, K extends keyof InstanceType<T>>(\n    this: T,\n    name: K,\n    accumulator: (this: InstanceType<T>) => InstanceType<T>[K],\n    singleton?: boolean,\n  ): void\n  static getter(name: string | symbol, accumulator: MacroFunction, singleton?: boolean): void\n  static getter(\n    name: string | symbol,\n    accumulator: MacroFunction,\n    singleton = false,\n  ): void {\n    if (!Object.prototype.hasOwnProperty.call(this, 'getterNames')) {\n      this.getterNames = new Set(this.getterNames)\n    }\n    this.getterNames.add(name)\n\n    Object.defineProperty(this.prototype, name, {\n      get(): unknown {\n        const value: unknown = accumulator.call(this)\n        if (singleton) {\n          Object.defineProperty(this, name, {\n            value,\n            configurable: false,\n            enumerable: false,\n            writable: false,\n          })\n        }\n        return value\n      },\n      configurable: true,\n      enumerable: false,\n    })\n  }\n\n  // ── Introspection ─────────────────────────────────────────\n\n  /**\n   * Check if a macro, instance property, or getter is registered.\n   *\n   * @param name - Name to check\n   */\n  static hasMacro(name: string | symbol): boolean {\n    return (\n      this.macroNames.has(name) ||\n      [...this.instanceMacros].some((m) => m.key === name) ||\n      this.getterNames.has(name)\n    )\n  }\n\n  // ── Cleanup ───────────────────────────────────────────────\n\n  /**\n   * Remove all macros, instance properties, and getters\n   * registered on this class. Does not affect parent classes.\n   */\n  static flushMacros(): void {\n    const proto = this.prototype as Record<string | symbol, unknown>\n\n    // Restore original prototype values or delete if they didn't exist before\n    for (const name of this.macroNames) {\n      const original = this._originals.get(name)\n      if (original?.existed) {\n        proto[name] = original.value\n      } else {\n        Reflect.deleteProperty(proto, name)\n      }\n    }\n    for (const name of this.getterNames) {\n      Reflect.deleteProperty(proto, name)\n    }\n\n    if (Object.prototype.hasOwnProperty.call(this, 'macroNames')) {\n      this.macroNames.clear()\n    }\n    if (Object.prototype.hasOwnProperty.call(this, 'instanceMacros')) {\n      this.instanceMacros.clear()\n    }\n    if (Object.prototype.hasOwnProperty.call(this, 'getterNames')) {\n      this.getterNames.clear()\n    }\n    if (Object.prototype.hasOwnProperty.call(this, '_originals')) {\n      this._originals.clear()\n    }\n  }\n\n  // ── Constructor (applies instance properties) ─────────────\n\n  constructor() {\n    const Constructor = this.constructor as typeof Macroable\n    const self = this as Record<string | symbol, unknown>\n    Constructor.instanceMacros.forEach(({ key, value }) => {\n      if (typeof value === 'function') {\n        self[key] = value.bind(this)\n      } else {\n        self[key] = value\n      }\n    })\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,IAAsB,YAAtB,MAAgC;;;;;CAM9B,OAAiB,iCAAiB,IAAI,IAA8C;;;;CAKpF,OAAiB,6BAAa,IAAI,IAAqB;;;;CAKvD,OAAiB,8BAAc,IAAI,IAAqB;;;;;CAMxD,OAAe,6BAAa,IAAI,IAA2D;CAmB3F,OAAO,MAAM,MAAuB,OAAsB;EACxD,IAAI,CAAC,OAAO,UAAU,eAAe,KAAK,MAAM,YAAY,GAC1D,KAAK,aAAa,IAAI,IAAI,KAAK,UAAU;EAE3C,IAAI,CAAC,OAAO,UAAU,eAAe,KAAK,MAAM,YAAY,GAC1D,KAAK,aAAa,IAAI,IAAI,KAAK,UAAU;EAI3C,IAAI,CAAC,KAAK,WAAW,IAAI,IAAI,GAAG;GAC9B,MAAM,UAAU,OAAO,UAAU,eAAe,KAAK,KAAK,WAAW,IAAI;GACzE,KAAK,WAAW,IAAI,MAAM;IACxB;IACA,OAAO,UAAW,KAAK,UAA+C,QAAQ,KAAA;GAChF,CAAC;EACH;EAEA,KAAK,WAAW,IAAI,IAAI;EACxB,KAAM,UAA+C,QAAQ;CAC/D;CAmBA,OAAO,iBAAiB,MAAuB,OAAsB;EACnE,IAAI,CAAC,OAAO,UAAU,eAAe,KAAK,MAAM,gBAAgB,GAC9D,KAAK,iBAAiB,IAAI,IAAI,KAAK,cAAc;EAEnD,KAAK,eAAe,IAAI;GAAE,KAAK;GAAM;EAAM,CAAC;CAC9C;CAkBA,OAAO,OACL,MACA,aACA,YAAY,OACN;EACN,IAAI,CAAC,OAAO,UAAU,eAAe,KAAK,MAAM,aAAa,GAC3D,KAAK,cAAc,IAAI,IAAI,KAAK,WAAW;EAE7C,KAAK,YAAY,IAAI,IAAI;EAEzB,OAAO,eAAe,KAAK,WAAW,MAAM;GAC1C,MAAe;IACb,MAAM,QAAiB,YAAY,KAAK,IAAI;IAC5C,IAAI,WACF,OAAO,eAAe,MAAM,MAAM;KAChC;KACA,cAAc;KACd,YAAY;KACZ,UAAU;IACZ,CAAC;IAEH,OAAO;GACT;GACA,cAAc;GACd,YAAY;EACd,CAAC;CACH;;;;;;CASA,OAAO,SAAS,MAAgC;EAC9C,OACE,KAAK,WAAW,IAAI,IAAI,KACxB,CAAC,GAAG,KAAK,cAAc,EAAE,MAAM,MAAM,EAAE,QAAQ,IAAI,KACnD,KAAK,YAAY,IAAI,IAAI;CAE7B;;;;;CAQA,OAAO,cAAoB;EACzB,MAAM,QAAQ,KAAK;EAGnB,KAAK,MAAM,QAAQ,KAAK,YAAY;GAClC,MAAM,WAAW,KAAK,WAAW,IAAI,IAAI;GACzC,IAAI,UAAU,SACZ,MAAM,QAAQ,SAAS;QAEvB,QAAQ,eAAe,OAAO,IAAI;EAEtC;EACA,KAAK,MAAM,QAAQ,KAAK,aACtB,QAAQ,eAAe,OAAO,IAAI;EAGpC,IAAI,OAAO,UAAU,eAAe,KAAK,MAAM,YAAY,GACzD,KAAK,WAAW,MAAM;EAExB,IAAI,OAAO,UAAU,eAAe,KAAK,MAAM,gBAAgB,GAC7D,KAAK,eAAe,MAAM;EAE5B,IAAI,OAAO,UAAU,eAAe,KAAK,MAAM,aAAa,GAC1D,KAAK,YAAY,MAAM;EAEzB,IAAI,OAAO,UAAU,eAAe,KAAK,MAAM,YAAY,GACzD,KAAK,WAAW,MAAM;CAE1B;CAIA,cAAc;EACZ,MAAM,cAAc,KAAK;EACzB,MAAM,OAAO;EACb,YAAY,eAAe,SAAS,EAAE,KAAK,YAAY;GACrD,IAAI,OAAO,UAAU,YACnB,KAAK,OAAO,MAAM,KAAK,IAAI;QAE3B,KAAK,OAAO;EAEhB,CAAC;CACH;AACF"}

package/dist/metadata-DzzprcID.mjs

@@ -0,0 +1,39 @@
+//#region src/di/metadata.ts
+const STORE_KEY = Symbol.for("stratal:metadata:store");
+const g = globalThis;
+const store = g[STORE_KEY] ?? (g[STORE_KEY] = /* @__PURE__ */ new WeakMap());
+function getKeyTarget(target, propertyKey) {
+	if (propertyKey === void 0) return target;
+	let propMap = store.get(target);
+	if (!propMap) {
+		propMap = /* @__PURE__ */ new Map();
+		store.set(target, propMap);
+	}
+	let propTarget = propMap.get(propertyKey);
+	if (!propTarget) {
+		propTarget = Object.create(null);
+		propMap.set(propertyKey, propTarget);
+	}
+	return propTarget;
+}
+function defineMetadata(key, value, target, propertyKey) {
+	const resolved = getKeyTarget(target, propertyKey);
+	let meta = store.get(resolved);
+	if (!meta) {
+		meta = /* @__PURE__ */ new Map();
+		store.set(resolved, meta);
+	}
+	meta.set(key, value);
+}
+function getMetadata(key, target, propertyKey) {
+	const resolved = getKeyTarget(target, propertyKey);
+	return store.get(resolved)?.get(key);
+}
+function hasMetadata(key, target, propertyKey) {
+	const resolved = getKeyTarget(target, propertyKey);
+	return store.get(resolved)?.has(key) ?? false;
+}
+//#endregion
+export { getMetadata as n, hasMetadata as r, defineMetadata as t };
+
+//# sourceMappingURL=metadata-DzzprcID.mjs.map

package/dist/metadata-DzzprcID.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata-DzzprcID.mjs","names":[],"sources":["../src/di/metadata.ts"],"sourcesContent":["type MetadataTarget = object | string | symbol\n\nconst STORE_KEY = Symbol.for('stratal:metadata:store')\nconst g = globalThis as Record<symbol, unknown>\nconst store: WeakMap<object, Map<MetadataTarget, unknown>> =\n  (g[STORE_KEY] as WeakMap<object, Map<MetadataTarget, unknown>>) ??\n  (g[STORE_KEY] = new WeakMap<object, Map<MetadataTarget, unknown>>())\n\nfunction getKeyTarget(target: object, propertyKey?: string | symbol): object {\n  if (propertyKey === undefined) return target\n  let propMap = store.get(target)\n  if (!propMap) {\n    propMap = new Map()\n    store.set(target, propMap)\n  }\n  let propTarget = propMap.get(propertyKey) as object | undefined\n  if (!propTarget) {\n    propTarget = Object.create(null) as object\n    propMap.set(propertyKey, propTarget)\n  }\n  return propTarget\n}\n\nexport function defineMetadata(key: symbol, value: unknown, target: object, propertyKey?: string | symbol): void {\n  const resolved = getKeyTarget(target, propertyKey)\n  let meta = store.get(resolved)\n  if (!meta) {\n    meta = new Map()\n    store.set(resolved, meta)\n  }\n  meta.set(key, value)\n}\n\nexport function getMetadata<T = unknown>(key: symbol, target: object, propertyKey?: string | symbol): T | undefined {\n  const resolved = getKeyTarget(target, propertyKey)\n  return store.get(resolved)?.get(key) as T | undefined\n}\n\nexport function hasMetadata(key: symbol, target: object, propertyKey?: string | symbol): boolean {\n  const resolved = getKeyTarget(target, propertyKey)\n  return store.get(resolved)?.has(key) ?? false\n}\n"],"mappings":";AAEA,MAAM,YAAY,OAAO,IAAI,wBAAwB;AACrD,MAAM,IAAI;AACV,MAAM,QACH,EAAE,eACF,EAAE,6BAAa,IAAI,QAA8C;AAEpE,SAAS,aAAa,QAAgB,aAAuC;CAC3E,IAAI,gBAAgB,KAAA,GAAW,OAAO;CACtC,IAAI,UAAU,MAAM,IAAI,MAAM;CAC9B,IAAI,CAAC,SAAS;EACZ,0BAAU,IAAI,IAAI;EAClB,MAAM,IAAI,QAAQ,OAAO;CAC3B;CACA,IAAI,aAAa,QAAQ,IAAI,WAAW;CACxC,IAAI,CAAC,YAAY;EACf,aAAa,OAAO,OAAO,IAAI;EAC/B,QAAQ,IAAI,aAAa,UAAU;CACrC;CACA,OAAO;AACT;AAEA,SAAgB,eAAe,KAAa,OAAgB,QAAgB,aAAqC;CAC/G,MAAM,WAAW,aAAa,QAAQ,WAAW;CACjD,IAAI,OAAO,MAAM,IAAI,QAAQ;CAC7B,IAAI,CAAC,MAAM;EACT,uBAAO,IAAI,IAAI;EACf,MAAM,IAAI,UAAU,IAAI;CAC1B;CACA,KAAK,IAAI,KAAK,KAAK;AACrB;AAEA,SAAgB,YAAyB,KAAa,QAAgB,aAA8C;CAClH,MAAM,WAAW,aAAa,QAAQ,WAAW;CACjD,OAAO,MAAM,IAAI,QAAQ,GAAG,IAAI,GAAG;AACrC;AAEA,SAAgB,YAAY,KAAa,QAAgB,aAAwC;CAC/F,MAAM,WAAW,aAAa,QAAQ,WAAW;CACjD,OAAO,MAAM,IAAI,QAAQ,GAAG,IAAI,GAAG,KAAK;AAC1C"}

package/dist/module/index.d.mts

@@ -1,32 +1,15 @@
-import { $t as ModuleRegistry, An as ValueProvider, Cn as ModuleContext, Dn as OnShutdown, En as OnInitialize, On as Provider, Sn as ModuleClass, Tn as OnException, _n as ClassProvider, bn as FactoryProvider, gn as AsyncModuleOptions, kn as RegistryEntry, vn as DynamicModule, wn as ModuleOptions, xn as InjectionToken, yn as ExistingProvider } from "../index-ByOyTmqf.mjs";
-import { t as Constructor } from "../types-cySNS_lp.mjs";
+import { An as ExistingProvider, Dn as AsyncModuleOptions, Dr as ApplicationError, Fn as OnException, Hn as InjectionToken, In as OnInitialize, Ln as OnShutdown, Mn as ModuleClass, Nn as ModuleContext, On as ClassProvider, Pn as ModuleOptions, Rn as Provider, jn as FactoryProvider, kn as DynamicModule, ln as ModuleRegistry, zn as ValueProvider } from "../index-B_JoEl3V.mjs";
+import { t as Constructor } from "../types-CmV_9xBD.mjs";
+import { n as ModuleRef, t as LazyModuleLoader } from "../lazy-module-loader-Ib383jH_.mjs";
 
+//#region src/module/module.error.d.ts
+declare class ModuleError extends ApplicationError {}
+//#endregion
 //#region src/module/module.decorator.d.ts
 declare const MODULE_OPTIONS_KEY: unique symbol;
-/**
- * `@Module` decorator - defines a module with imports, providers, controllers, consumers, jobs
- *
- * Uses tsyringe's `@registry` internally to auto-register providers when module is imported.
- *
- * @example
- * ```typescript
- * @Module({
- *   imports: [OtherModule],
- *   providers: [MyService, MyRepository],
- *   controllers: [MyController],
- * })
- * export class MyModule {}
- * ```
- */
 declare function Module(options: ModuleOptions): <TFunction extends abstract new (...args: never[]) => unknown>(target: TFunction) => TFunction;
-/**
- * Get module options from decorated class
- */
 declare function getModuleOptions(target: Constructor): ModuleOptions | undefined;
-/**
- * Check if a class is decorated with `@Module`
- */
 declare function isModuleClass(target: unknown): target is Constructor;
 //#endregion
-export { AsyncModuleOptions, ClassProvider, DynamicModule, ExistingProvider, FactoryProvider, InjectionToken, MODULE_OPTIONS_KEY, Module, ModuleClass, ModuleContext, ModuleOptions, ModuleRegistry, OnException, OnInitialize, OnShutdown, Provider, RegistryEntry, ValueProvider, getModuleOptions, isModuleClass };
+export { AsyncModuleOptions, ClassProvider, DynamicModule, ExistingProvider, FactoryProvider, type InjectionToken, LazyModuleLoader, MODULE_OPTIONS_KEY, Module, ModuleClass, ModuleContext, ModuleError, ModuleOptions, ModuleRef, ModuleRegistry, OnException, OnInitialize, OnShutdown, Provider, ValueProvider, getModuleOptions, isModuleClass };
 //# sourceMappingURL=index.d.mts.map

package/dist/module/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/module/module.decorator.ts"],"mappings":";;;;cAea,kBAAA;AAyBb;;;;;;;;;;;;;;;AAAA,iBAAgB,MAAA,CAAO,OAAA,EAAS,aAAA,uCACa,IAAA,uBAA2B,MAAA,EAAQ,SAAA,KAAY,SAAA;;AAmB5F;;iBAAgB,gBAAA,CAAiB,MAAA,EAAQ,WAAA,GAAc,aAAA;;;;iBAOvC,aAAA,CAAc,MAAA,YAAkB,MAAA,IAAU,WAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/module/module.error.ts","../../src/module/module.decorator.ts"],"mappings":";;;;;cAEa,WAAA,SAAoB,gBAAgB;;;cCEpC,kBAAA;AAAA,iBAEG,MAAA,CAAO,OAAA,EAAS,aAAA,uCACa,IAAA,uBAA2B,MAAA,EAAQ,SAAA,KAAY,SAAA;AAAA,iBAM5E,gBAAA,CAAiB,MAAA,EAAQ,WAAA,GAAc,aAAa;AAAA,iBAIpD,aAAA,CAAc,MAAA,YAAkB,MAAA,IAAU,WAAW"}

package/dist/module/index.mjs

@@ -1,2 +1,10 @@
-import { A as getModuleOptions, O as MODULE_OPTIONS_KEY, j as isModuleClass, k as Module, t as ModuleRegistry } from "../module-BzLg57FK.mjs";
-export { MODULE_OPTIONS_KEY, Module, ModuleRegistry, getModuleOptions, isModuleClass };
+import { a as ApplicationError } from "../container-storage-BmOJ4_Na.mjs";
+import "../errors-mXYxG0XB.mjs";
+import { i as isModuleClass, n as Module, r as getModuleOptions, t as MODULE_OPTIONS_KEY } from "../module.decorator-CYHY6pG5.mjs";
+import { d as LazyModuleLoader, f as ModuleRef, t as ModuleRegistry } from "../module-registry-Dm-pqHd3.mjs";
+//#region src/module/module.error.ts
+var ModuleError = class extends ApplicationError {};
+//#endregion
+export { LazyModuleLoader, MODULE_OPTIONS_KEY, Module, ModuleError, ModuleRef, ModuleRegistry, getModuleOptions, isModuleClass };
+
+//# sourceMappingURL=index.mjs.map

package/dist/module/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/module/module.error.ts"],"sourcesContent":["import { ApplicationError } from '../errors'\n\nexport class ModuleError extends ApplicationError {}\n"],"mappings":";;;;;AAEA,IAAa,cAAb,cAAiC,iBAAiB,CAAC"}