@warlock.js/core 4.0.174 → 4.1.3

package/esm/cli/index.d.mts

@@ -0,0 +1,2 @@
+import { CLICommandAction, CLICommandOption, CLICommandOptions, CLICommandPreload, CLICommandSource, CommandActionData, ResolvedCLICommandOption } from "./types.mjs";
+import { CLICommand, command } from "./cli-command.mjs";

package/esm/cli/parse-cli-args.mjs

@@ -0,0 +1,62 @@
+import { toCamelCase } from "@mongez/reinforcements";
+
+//#region ../../@warlock.js/core/src/cli/parse-cli-args.ts
+/**
+* Parse CLI arguments from process.argv
+*
+* @example
+* parseCliArgs(["node", "warlock", "migrate", "--rollback", "file.ts"])
+* // Returns: { name: "migrate", args: [], options: { rollback: "file.ts" } }
+*
+* @example
+* parseCliArgs(["node", "warlock", "dev", "--port=3000", "--fresh"])
+* // Returns: { name: "dev", args: [], options: { port: "3000", fresh: true } }
+*/
+function parseCliArgs(argv) {
+	const potentialCommand = argv[2] || "";
+	const isFirstArgOption = potentialCommand.startsWith("-");
+	const command = isFirstArgOption ? "" : potentialCommand;
+	const args = [];
+	const options = {};
+	const startIndex = isFirstArgOption ? 2 : 3;
+	for (let i = startIndex; i < argv.length; i++) {
+		const arg = argv[i];
+		if (arg.startsWith("--")) {
+			const withoutDashes = arg.slice(2);
+			const equalIndex = withoutDashes.indexOf("=");
+			if (equalIndex !== -1) {
+				const key = toCamelCase(withoutDashes.slice(0, equalIndex));
+				options[key] = withoutDashes.slice(equalIndex + 1);
+			} else {
+				const key = toCamelCase(withoutDashes);
+				const nextArg = argv[i + 1];
+				if (nextArg && !nextArg.startsWith("-")) {
+					options[key] = nextArg;
+					i++;
+				} else options[key] = true;
+			}
+		} else if (arg.startsWith("-") && arg.length > 1) {
+			const flags = arg.slice(1);
+			const equalIndex = flags.indexOf("=");
+			if (equalIndex !== -1) {
+				const key = toCamelCase(flags.slice(0, equalIndex));
+				options[key] = flags.slice(equalIndex + 1);
+			} else if (flags.length === 1) {
+				const nextArg = argv[i + 1];
+				if (nextArg && !nextArg.startsWith("-")) {
+					options[toCamelCase(flags)] = nextArg;
+					i++;
+				} else options[toCamelCase(flags)] = true;
+			} else for (const flag of flags) options[toCamelCase(flag)] = true;
+		} else args.push(arg);
+	}
+	return {
+		name: command,
+		args,
+		options
+	};
+}
+
+//#endregion
+export { parseCliArgs };
+//# sourceMappingURL=parse-cli-args.mjs.map

package/esm/cli/parse-cli-args.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-cli-args.mjs","names":[],"sources":["../../../../../../@warlock.js/core/src/cli/parse-cli-args.ts"],"sourcesContent":["import { toCamelCase } from \"@mongez/reinforcements\";\n\nexport type ParsedCliArgs = {\n  name: string;\n  args: string[];\n  options: Record<string, string | boolean>;\n};\n\n/**\n * Parse CLI arguments from process.argv\n *\n * @example\n * parseCliArgs([\"node\", \"warlock\", \"migrate\", \"--rollback\", \"file.ts\"])\n * // Returns: { name: \"migrate\", args: [], options: { rollback: \"file.ts\" } }\n *\n * @example\n * parseCliArgs([\"node\", \"warlock\", \"dev\", \"--port=3000\", \"--fresh\"])\n * // Returns: { name: \"dev\", args: [], options: { port: \"3000\", fresh: true } }\n */\nexport function parseCliArgs(argv: string[]): ParsedCliArgs {\n  // Command is at index 2 (after \"node\" and script path)\n  // But if index 2 starts with \"-\", it's an option, not a command\n  const potentialCommand = argv[2] || \"\";\n  const isFirstArgOption = potentialCommand.startsWith(\"-\");\n  const command = isFirstArgOption ? \"\" : potentialCommand;\n  const args: string[] = [];\n  const options: Record<string, string | boolean> = {};\n\n  // Parse arguments starting from index 3 (or 2 if first arg was an option)\n  const startIndex = isFirstArgOption ? 2 : 3;\n  for (let i = startIndex; i < argv.length; i++) {\n    const arg = argv[i];\n\n    if (arg.startsWith(\"--\")) {\n      // Long option: --key or --key=value\n      const withoutDashes = arg.slice(2);\n      const equalIndex = withoutDashes.indexOf(\"=\");\n\n      if (equalIndex !== -1) {\n        // --key=value format\n        const key = toCamelCase(withoutDashes.slice(0, equalIndex));\n        const value = withoutDashes.slice(equalIndex + 1);\n        options[key] = value;\n      } else {\n        // --key format (check if next arg is a value)\n        const key = toCamelCase(withoutDashes);\n        const nextArg = argv[i + 1];\n\n        // If next arg exists and doesn't start with -, treat it as value\n        if (nextArg && !nextArg.startsWith(\"-\")) {\n          options[key] = nextArg;\n          i++; // Skip next arg\n        } else {\n          options[key] = true;\n        }\n      }\n    } else if (arg.startsWith(\"-\") && arg.length > 1) {\n      // Short option: -f, -t=value, or -abc (multiple flags)\n      const flags = arg.slice(1);\n      const equalIndex = flags.indexOf(\"=\");\n\n      if (equalIndex !== -1) {\n        // -t=value format\n        const key = toCamelCase(flags.slice(0, equalIndex));\n        const value = flags.slice(equalIndex + 1);\n        options[key] = value;\n      } else if (flags.length === 1) {\n        // Single flag: -f\n        const nextArg = argv[i + 1];\n\n        if (nextArg && !nextArg.startsWith(\"-\")) {\n          options[toCamelCase(flags)] = nextArg;\n          i++; // Skip next arg\n        } else {\n          options[toCamelCase(flags)] = true;\n        }\n      } else {\n        // Multiple flags: -abc becomes { a: true, b: true, c: true }\n        for (const flag of flags) {\n          options[toCamelCase(flag)] = true;\n        }\n      }\n    } else {\n      // Positional argument\n      args.push(arg);\n    }\n  }\n\n  return { name: command, args, options };\n}\n"],"mappings":";;;;;;;;;;;;;;AAmBA,SAAgB,aAAa,MAA+B;CAG1D,MAAM,mBAAmB,KAAK,MAAM;CACpC,MAAM,mBAAmB,iBAAiB,WAAW,GAAG;CACxD,MAAM,UAAU,mBAAmB,KAAK;CACxC,MAAM,OAAiB,CAAC;CACxB,MAAM,UAA4C,CAAC;CAGnD,MAAM,aAAa,mBAAmB,IAAI;CAC1C,KAAK,IAAI,IAAI,YAAY,IAAI,KAAK,QAAQ,KAAK;EAC7C,MAAM,MAAM,KAAK;EAEjB,IAAI,IAAI,WAAW,IAAI,GAAG;GAExB,MAAM,gBAAgB,IAAI,MAAM,CAAC;GACjC,MAAM,aAAa,cAAc,QAAQ,GAAG;GAE5C,IAAI,eAAe,IAAI;IAErB,MAAM,MAAM,YAAY,cAAc,MAAM,GAAG,UAAU,CAAC;IAE1D,QAAQ,OADM,cAAc,MAAM,aAAa,CAC5B;GACrB,OAAO;IAEL,MAAM,MAAM,YAAY,aAAa;IACrC,MAAM,UAAU,KAAK,IAAI;IAGzB,IAAI,WAAW,CAAC,QAAQ,WAAW,GAAG,GAAG;KACvC,QAAQ,OAAO;KACf;IACF,OACE,QAAQ,OAAO;GAEnB;EACF,OAAO,IAAI,IAAI,WAAW,GAAG,KAAK,IAAI,SAAS,GAAG;GAEhD,MAAM,QAAQ,IAAI,MAAM,CAAC;GACzB,MAAM,aAAa,MAAM,QAAQ,GAAG;GAEpC,IAAI,eAAe,IAAI;IAErB,MAAM,MAAM,YAAY,MAAM,MAAM,GAAG,UAAU,CAAC;IAElD,QAAQ,OADM,MAAM,MAAM,aAAa,CACpB;GACrB,OAAO,IAAI,MAAM,WAAW,GAAG;IAE7B,MAAM,UAAU,KAAK,IAAI;IAEzB,IAAI,WAAW,CAAC,QAAQ,WAAW,GAAG,GAAG;KACvC,QAAQ,YAAY,KAAK,KAAK;KAC9B;IACF,OACE,QAAQ,YAAY,KAAK,KAAK;GAElC,OAEE,KAAK,MAAM,QAAQ,OACjB,QAAQ,YAAY,IAAI,KAAK;EAGnC,OAEE,KAAK,KAAK,GAAG;CAEjB;CAEA,OAAO;EAAE,MAAM;EAAS;EAAM;CAAQ;AACxC"}

package/esm/cli/start.d.mts

@@ -0,0 +1 @@
+export { };

package/esm/cli/start.mjs

@@ -0,0 +1,8 @@
+import { CLICommandsManager } from "./cli-commands.manager.mjs";
+
+//#region ../../@warlock.js/core/src/cli/start.ts
+await new CLICommandsManager().start();
+
+//#endregion
+export {  };
+//# sourceMappingURL=start.mjs.map

package/esm/cli/start.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"start.mjs","names":[],"sources":["../../../../../../@warlock.js/core/src/cli/start.ts"],"sourcesContent":["import { CLICommandsManager } from \"./cli-commands.manager\";\n\nconst commandsManager = new CLICommandsManager();\nawait commandsManager.start();\n"],"mappings":";;;AAGA,MAAM,IADsB,mBACR,EAAE,MAAM"}

package/esm/cli/string-similarity.mjs

@@ -0,0 +1,56 @@
+//#region ../../@warlock.js/core/src/cli/string-similarity.ts
+/**
+* String similarity utilities for CLI command suggestions
+* Uses Levenshtein distance algorithm for fuzzy matching
+*/
+/**
+* Calculate the Levenshtein distance between two strings
+* Lower distance = more similar
+*
+* @param str1 - First string
+* @param str2 - Second string
+* @returns Distance (number of edits required to transform str1 to str2)
+*/
+function levenshteinDistance(str1, str2) {
+	const s1 = str1.toLowerCase();
+	const s2 = str2.toLowerCase();
+	const len1 = s1.length;
+	const len2 = s2.length;
+	const matrix = Array.from({ length: len1 + 1 }, (_, i) => Array.from({ length: len2 + 1 }, (_, j) => i === 0 ? j : j === 0 ? i : 0));
+	for (let i = 1; i <= len1; i++) for (let j = 1; j <= len2; j++) {
+		const cost = s1[i - 1] === s2[j - 1] ? 0 : 1;
+		matrix[i][j] = Math.min(matrix[i - 1][j] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j - 1] + cost);
+	}
+	return matrix[len1][len2];
+}
+/**
+* Find similar strings from a list
+*
+* @param input - The input string to find matches for
+* @param candidates - List of candidate strings
+* @param maxDistance - Maximum distance to consider (default: 3)
+* @param maxResults - Maximum number of results to return (default: 3)
+* @returns Array of suggestions sorted by similarity
+*
+* @example
+* ```typescript
+* findSimilar("biuld", ["build", "dev", "start", "test"])
+* // Returns: [{ value: "build", distance: 1 }]
+* ```
+*/
+function findSimilar(input, candidates, maxDistance = 3, maxResults = 3) {
+	const results = [];
+	for (const candidate of candidates) {
+		const distance = levenshteinDistance(input, candidate);
+		if (distance <= maxDistance && distance > 0) results.push({
+			value: candidate,
+			distance
+		});
+	}
+	results.sort((a, b) => a.distance - b.distance);
+	return results.slice(0, maxResults);
+}
+
+//#endregion
+export { findSimilar };
+//# sourceMappingURL=string-similarity.mjs.map

package/esm/cli/string-similarity.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"string-similarity.mjs","names":[],"sources":["../../../../../../@warlock.js/core/src/cli/string-similarity.ts"],"sourcesContent":["/**\n * String similarity utilities for CLI command suggestions\n * Uses Levenshtein distance algorithm for fuzzy matching\n */\n\n/**\n * Calculate the Levenshtein distance between two strings\n * Lower distance = more similar\n *\n * @param str1 - First string\n * @param str2 - Second string\n * @returns Distance (number of edits required to transform str1 to str2)\n */\nexport function levenshteinDistance(str1: string, str2: string): number {\n  const s1 = str1.toLowerCase();\n  const s2 = str2.toLowerCase();\n\n  const len1 = s1.length;\n  const len2 = s2.length;\n\n  // Create matrix\n  const matrix: number[][] = Array.from({ length: len1 + 1 }, (_, i) =>\n    Array.from({ length: len2 + 1 }, (_, j) => (i === 0 ? j : j === 0 ? i : 0)),\n  );\n\n  // Fill matrix\n  for (let i = 1; i <= len1; i++) {\n    for (let j = 1; j <= len2; j++) {\n      const cost = s1[i - 1] === s2[j - 1] ? 0 : 1;\n      matrix[i][j] = Math.min(\n        matrix[i - 1][j] + 1, // deletion\n        matrix[i][j - 1] + 1, // insertion\n        matrix[i - 1][j - 1] + cost, // substitution\n      );\n    }\n  }\n\n  return matrix[len1][len2];\n}\n\n/**\n * Suggestion result with similarity score\n */\nexport type Suggestion = {\n  /** The suggested value */\n  value: string;\n  /** Distance score (lower = more similar) */\n  distance: number;\n};\n\n/**\n * Find similar strings from a list\n *\n * @param input - The input string to find matches for\n * @param candidates - List of candidate strings\n * @param maxDistance - Maximum distance to consider (default: 3)\n * @param maxResults - Maximum number of results to return (default: 3)\n * @returns Array of suggestions sorted by similarity\n *\n * @example\n * ```typescript\n * findSimilar(\"biuld\", [\"build\", \"dev\", \"start\", \"test\"])\n * // Returns: [{ value: \"build\", distance: 1 }]\n * ```\n */\nexport function findSimilar(\n  input: string,\n  candidates: string[],\n  maxDistance: number = 3,\n  maxResults: number = 3,\n): Suggestion[] {\n  const results: Suggestion[] = [];\n\n  for (const candidate of candidates) {\n    const distance = levenshteinDistance(input, candidate);\n\n    if (distance <= maxDistance && distance > 0) {\n      results.push({ value: candidate, distance });\n    }\n  }\n\n  // Sort by distance (most similar first)\n  results.sort((a, b) => a.distance - b.distance);\n\n  return results.slice(0, maxResults);\n}\n\n/**\n * Check if a string starts with any of the given prefixes\n * Useful for command name matching\n */\nexport function startsWithAny(str: string, prefixes: string[]): boolean {\n  return prefixes.some((prefix) => str.toLowerCase().startsWith(prefix.toLowerCase()));\n}\n"],"mappings":";;;;;;;;;;;;;AAaA,SAAgB,oBAAoB,MAAc,MAAsB;CACtE,MAAM,KAAK,KAAK,YAAY;CAC5B,MAAM,KAAK,KAAK,YAAY;CAE5B,MAAM,OAAO,GAAG;CAChB,MAAM,OAAO,GAAG;CAGhB,MAAM,SAAqB,MAAM,KAAK,EAAE,QAAQ,OAAO,EAAE,IAAI,GAAG,MAC9D,MAAM,KAAK,EAAE,QAAQ,OAAO,EAAE,IAAI,GAAG,MAAO,MAAM,IAAI,IAAI,MAAM,IAAI,IAAI,CAAE,CAC5E;CAGA,KAAK,IAAI,IAAI,GAAG,KAAK,MAAM,KACzB,KAAK,IAAI,IAAI,GAAG,KAAK,MAAM,KAAK;EAC9B,MAAM,OAAO,GAAG,IAAI,OAAO,GAAG,IAAI,KAAK,IAAI;EAC3C,OAAO,GAAG,KAAK,KAAK,IAClB,OAAO,IAAI,GAAG,KAAK,GACnB,OAAO,GAAG,IAAI,KAAK,GACnB,OAAO,IAAI,GAAG,IAAI,KAAK,IACzB;CACF;CAGF,OAAO,OAAO,MAAM;AACtB;;;;;;;;;;;;;;;;AA2BA,SAAgB,YACd,OACA,YACA,cAAsB,GACtB,aAAqB,GACP;CACd,MAAM,UAAwB,CAAC;CAE/B,KAAK,MAAM,aAAa,YAAY;EAClC,MAAM,WAAW,oBAAoB,OAAO,SAAS;EAErD,IAAI,YAAY,eAAe,WAAW,GACxC,QAAQ,KAAK;GAAE,OAAO;GAAW;EAAS,CAAC;CAE/C;CAGA,QAAQ,MAAM,GAAG,MAAM,EAAE,WAAW,EAAE,QAAQ;CAE9C,OAAO,QAAQ,MAAM,GAAG,UAAU;AACpC"}

package/esm/cli/types.d.mts

@@ -0,0 +1,216 @@
+import { ConnectorName } from "../connectors/types.mjs";
+//#region ../../@warlock.js/core/src/cli/types.d.ts
+/**
+ * Indicates the origin/source of a CLI command.
+ *
+ * - `"framework"` - Built-in commands provided by Warlock.js (e.g., `dev`, `help`)
+ * - `"plugin"` - Commands from installed Warlock.js plugins
+ * - `"project"` - Custom commands defined in the project's source code
+ */
+type CLICommandSource = "framework" | "plugin" | "project";
+/**
+ * Data passed to command action and preAction functions.
+ *
+ * @example
+ * // For command: warlock migrate users --fresh --limit=10
+ * {
+ *   args: ["users"],
+ *   options: { fresh: true, limit: "10" }
+ * }
+ */
+type CommandActionData = {
+  /**
+   * Positional arguments passed after the command name.
+   * @example `warlock migrate users posts` → args: ["users", "posts"]
+   */
+  args: string[];
+  /**
+   * Named options/flags parsed from CLI arguments.
+   * Kebab-case options are converted to camelCase.
+   * @example `--no-cache --port=3000` → { noCache: true, port: "3000" }
+   */
+  options: Record<string, string | boolean | number>;
+};
+/**
+ * Configuration for lazy-loading resources before command execution.
+ * Only specified resources are loaded, optimizing startup time.
+ *
+ * @example
+ * // Load only database config and connector
+ * preload: {
+ *   config: ["database"],
+ *   connectors: ["database"]
+ * }
+ *
+ * @example
+ * // Load everything (full bootstrap)
+ * preload: {
+ *   bootstrap: true,
+ *   config: true,
+ *   connectors: true
+ * }
+ */
+type CLICommandPreload = {
+  /**
+   * Configuration files to load.
+   * - `true` - Load all config files
+   * - `string[]` - Load only specified config modules (e.g., `["database", "cache"]`)
+   */
+  config?: true | string[];
+  /**
+   * Load prestart file after (bootstrap and configurations are loaded).
+   */
+  prestart?: boolean;
+  /**
+   * Load warlock config
+   */
+  warlockConfig?: boolean;
+  /**
+   * Set runtime strategy
+   */
+  runtimeStrategy?: "production" | "development";
+  /**
+   * Override current detect environment
+   */
+  environemnt?: "production" | "development" | "test";
+  /**
+   * Whether to load environment variables from .env files.
+   * Note: If `bootstrap` is true, env is loaded automatically.
+   */
+  env?: boolean;
+  /**
+   * Whether to run the full bootstrap process.
+   * This includes loading env and initializing the application.
+   */
+  bootstrap?: boolean;
+  /**
+   * Connectors to initialize before command execution.
+   * - `true` - Initialize all connectors (http, database, cache)
+   * - `string[]` - Initialize only specified connectors
+   *
+   * Available connectors: `"http"`, `"database"`, `"cache"`, `"storage"`
+   */
+  connectors?: ConnectorName[] | true;
+};
+/**
+ * Definition for a CLI command option/flag.
+ *
+ * @example
+ * {
+ *   name: "port",
+ *   text: "--port, -p",
+ *   alias: "p",
+ *   description: "Server port number",
+ *   type: "number",
+ *   required: false
+ * }
+ */
+type CLICommandOption = {
+  /**
+   * The raw option text as it appears in help output.
+   * Supports formats: `"--port"`, `"-p"`, `"--port, -p"`, `"-p, --port"`
+   */
+  text: string;
+  /**
+   * The camelCase name of the option (auto-extracted from `text`).
+   * This is the key used in `CommandActionData.options`.
+   */
+  name?: string;
+  /**
+   * Short alias for the option (auto-extracted from `text`).
+   * @example For `"--port, -p"` → alias: "p"
+   */
+  alias?: string;
+  /**
+   * Human-readable description shown in help output.
+   */
+  description?: string;
+  /**
+   * Expected value type for validation and parsing.
+   * @default "string"
+   */
+  type?: "string" | "boolean" | "number";
+  /**
+   * Default value if option is not provided.
+   */
+  defaultValue?: string | boolean | number;
+  /**
+   * Whether this option is required.
+   * If true and not provided, command will fail with an error.
+   */
+  required?: boolean;
+};
+type ResolvedCLICommandOption = Omit<CLICommandOption, "alias" | "name"> & {
+  name: string;
+  alias: string;
+};
+/**
+ * Command action function signature.
+ * Receives parsed CLI data and can be sync or async.
+ */
+type CLICommandAction = (data: CommandActionData) => void | Promise<void>;
+/**
+ * Configuration object for creating a CLI command using the `command()` factory.
+ *
+ * @example
+ * command({
+ *   name: "migrate",
+ *   description: "Run database migrations",
+ *   preload: {
+ *     bootstrap: true,
+ *     connectors: ["database"]
+ *   },
+ *   options: [
+ *     { text: "--fresh, -f", description: "Drop all tables first" }
+ *   ],
+ *   action: async ({ options }) => {
+ *     if (options.fresh) await dropTables();
+ *     await runMigrations();
+ *   }
+ * })
+ */
+type CLICommandOptions = {
+  /**
+   * The command name. Use dot notation for namespaced commands.
+   * @example "migrate", "db.seed", "jwt.generate"
+   */
+  name: string;
+  /**
+   * Short alias for the command.
+   * @example "m" for "migrate", "g" for "generate"
+   */
+  alias?: string;
+  /**
+   * Human-readable description shown in help output.
+   */
+  description?: string;
+  /**
+   * Resources to preload before command execution.
+   * @see CLICommandPreload
+   */
+  preload?: CLICommandPreload;
+  /**
+   * Whether the command keeps the process alive (e.g., dev server, watchers).
+   * If false, process exits after action completes.
+   * @default false
+   */
+  persistent?: boolean;
+  /**
+   * Function to run BEFORE preloading resources.
+   * Useful for displaying banners, validating input, etc.
+   */
+  preAction?: CLICommandAction;
+  /**
+   * The main command action function.
+   * Executed after preloading resources.
+   */
+  action: CLICommandAction;
+  /**
+   * Command-specific options/flags.
+   * @see CLICommandOption
+   */
+  options?: CLICommandOption[];
+};
+//#endregion
+export { CLICommandAction, CLICommandOption, CLICommandOptions, CLICommandPreload, CLICommandSource, CommandActionData, ResolvedCLICommandOption };
+//# sourceMappingURL=types.d.mts.map

package/esm/cli/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../../../../../@warlock.js/core/src/cli/types.ts"],"mappings":";;;;AAe4B;AAY5B;;;;KAZY,gBAAA;;;;AAwBK;AAsBjB;;;;;;KAlCY,iBAAA;EAuDV;;;;EAlDA,IAAA;EA4Ea;;AAAa;AAgB5B;;EArFE,OAAA,EAAS,MAAM;AAAA;;;;;;;;;AA4HP;AAGV;;;;;;;;;AAEO;KA3GK,iBAAA;EAkHgB;;;;;EA5G1B,MAAA;EA4GwE;AAAA;AAsB1E;EA7HE,QAAA;;;;EAKA,aAAA;EAuKU;;;EAlKV,eAAA;EA8HA;;;EAzHA,WAAA;EA2IA;;;;EArIA,GAAA;EAuJA;;;AAA0B;EAjJ1B,SAAA;;;;;;;;EASA,UAAA,GAAa,aAAa;AAAA;;;;;;;;;;;;;;KAgBhB,gBAAA;;;;;EAKV,IAAA;;;;;EAMA,IAAA;;;;;EAMA,KAAA;;;;EAKA,WAAA;;;;;EAMA,IAAA;;;;EAKA,YAAA;;;;;EAMA,QAAA;AAAA;AAAA,KAGU,wBAAA,GAA2B,IAAI,CAAC,gBAAA;EAC1C,IAAA;EACA,KAAA;AAAA;;;;;KAOU,gBAAA,IAAoB,IAAA,EAAM,iBAAA,YAA6B,OAAO;;;;;;;;;;;;;;;;;;;;;KAsB9D,iBAAA;;;;;EAKV,IAAA;;;;;EAMA,KAAA;;;;EAKA,WAAA;;;;;EAMA,OAAA,GAAU,iBAAA;;;;;;EAOV,UAAA;;;;;EAMA,SAAA,GAAY,gBAAA;;;;;EAMZ,MAAA,EAAQ,gBAAA;;;;;EAMR,OAAA,GAAU,gBAAA;AAAA"}

package/esm/config/config-getter.d.mts

@@ -0,0 +1,38 @@
+import { ConfigKey, ConfigRegistry } from "./types.mjs";
+
+//#region ../../@warlock.js/core/src/config/config-getter.d.ts
+/**
+ * Config accessor interface with typed overloads
+ */
+interface ConfigAccessor {
+  /**
+   * Get a config value by dot-notation key path.
+   */
+  key<T = any>(key: ConfigKey | (string & {}), defaultValue?: T): T;
+  /**
+   * Get an entire config group by name with type inference.
+   * Returns the typed config object for known config names.
+   */
+  get<K extends keyof ConfigRegistry>(name: K, defaultValue?: ConfigRegistry[K]): ConfigRegistry[K];
+  /**
+   * Get an entire config group by name (dynamic string).
+   */
+  get<T = any>(name: string, defaultValue?: T): T;
+}
+/**
+ * Config accessor with typed autocomplete and return type inference.
+ *
+ * @example
+ * ```typescript
+ * // Get entire config group - returns the actual config type
+ * const db = config.get("database"); // → DatabaseConfigurations
+ *
+ * // Get specific key with dot notation
+ * const host = config.key("database.host");
+ * const port = config.key<number>("database.port", 27017);
+ * ```
+ */
+declare const config: ConfigAccessor;
+//#endregion
+export { config };
+//# sourceMappingURL=config-getter.d.mts.map

package/esm/config/config-getter.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-getter.d.mts","names":[],"sources":["../../../../../../@warlock.js/core/src/config/config-getter.ts"],"mappings":";;;;;AACyD;UAK/C,cAAA;EAAc;;;EAItB,GAAA,UAAa,GAAA,EAAK,SAAA,kBAA2B,YAAA,GAAe,CAAA,GAAI,CAAA;EAM5C;;;;EAApB,GAAA,iBAAoB,cAAA,EAAgB,IAAA,EAAM,CAAA,EAAG,YAAA,GAAe,cAAA,CAAe,CAAA,IAAK,cAAA,CAAe,CAAA;EAAA;;;EAK/F,GAAA,UAAa,IAAA,UAAc,YAAA,GAAe,CAAA,GAAI,CAAA;AAAA;;;;;;;;;;;;;;cAgBnC,MAAA,EAAQ,cAQpB"}

package/esm/config/config-getter.mjs

@@ -0,0 +1,28 @@
+import config from "@mongez/config";
+
+//#region ../../@warlock.js/core/src/config/config-getter.ts
+/**
+* Config accessor with typed autocomplete and return type inference.
+*
+* @example
+* ```typescript
+* // Get entire config group - returns the actual config type
+* const db = config.get("database"); // → DatabaseConfigurations
+*
+* // Get specific key with dot notation
+* const host = config.key("database.host");
+* const port = config.key<number>("database.port", 27017);
+* ```
+*/
+const config$1 = {
+	key(key, defaultValue) {
+		return config.get(key, defaultValue);
+	},
+	get(name, defaultValue) {
+		return config.get(name, defaultValue);
+	}
+};
+
+//#endregion
+export { config$1 as config };
+//# sourceMappingURL=config-getter.mjs.map

package/esm/config/config-getter.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-getter.mjs","names":["config","baseConfig"],"sources":["../../../../../../@warlock.js/core/src/config/config-getter.ts"],"sourcesContent":["import baseConfig from \"@mongez/config\";\nimport type { ConfigKey, ConfigRegistry } from \"./types\";\n\n/**\n * Config accessor interface with typed overloads\n */\ninterface ConfigAccessor {\n  /**\n   * Get a config value by dot-notation key path.\n   */\n  key<T = any>(key: ConfigKey | (string & {}), defaultValue?: T): T;\n\n  /**\n   * Get an entire config group by name with type inference.\n   * Returns the typed config object for known config names.\n   */\n  get<K extends keyof ConfigRegistry>(name: K, defaultValue?: ConfigRegistry[K]): ConfigRegistry[K];\n\n  /**\n   * Get an entire config group by name (dynamic string).\n   */\n  get<T = any>(name: string, defaultValue?: T): T;\n}\n\n/**\n * Config accessor with typed autocomplete and return type inference.\n *\n * @example\n * ```typescript\n * // Get entire config group - returns the actual config type\n * const db = config.get(\"database\"); // → DatabaseConfigurations\n *\n * // Get specific key with dot notation\n * const host = config.key(\"database.host\");\n * const port = config.key<number>(\"database.port\", 27017);\n * ```\n */\nexport const config: ConfigAccessor = {\n  key(key: ConfigKey | (string & {}), defaultValue?: any): any {\n    return baseConfig.get(key, defaultValue);\n  },\n\n  get(name: string, defaultValue?: any): any {\n    return baseConfig.get(name, defaultValue);\n  },\n};\n"],"mappings":";;;;;;;;;;;;;;;;AAqCA,MAAaA,WAAyB;CACpC,IAAI,KAAgC,cAAyB;EAC3D,OAAOC,OAAW,IAAI,KAAK,YAAY;CACzC;CAEA,IAAI,MAAc,cAAyB;EACzC,OAAOA,OAAW,IAAI,MAAM,YAAY;CAC1C;AACF"}

package/esm/config/config-handlers.d.mts

@@ -0,0 +1,11 @@
+import { AppConfigurations } from "../utils/types.mjs";
+
+//#region ../../@warlock.js/core/src/config/config-handlers.d.ts
+/**
+ * App Config Handler
+ * Handles locale loading for dayjs
+ */
+declare const registerAppConfig: (config: AppConfigurations) => Promise<void>;
+//#endregion
+export { registerAppConfig };
+//# sourceMappingURL=config-handlers.d.mts.map

package/esm/config/config-handlers.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-handlers.d.mts","names":[],"sources":["../../../../../../@warlock.js/core/src/config/config-handlers.ts"],"mappings":";;;;;AAOA;;cAAa,iBAAA,GAA2B,MAAA,EAAQ,iBAAA,KAAiB,OAAA"}

package/esm/config/config-handlers.mjs

@@ -0,0 +1,23 @@
+import { configSpecialHandlers } from "./config-special-handlers.mjs";
+
+//#region ../../@warlock.js/core/src/config/config-handlers.ts
+/**
+* App Config Handler
+* Handles locale loading for dayjs
+*/
+const registerAppConfig = async (config) => {
+	const locales = config.locales || ["en"];
+	for (const locale of locales) {
+		if (locale === "en") continue;
+		try {
+			await import(`dayjs/locale/${locale}.js`);
+		} catch (error) {
+			console.warn(`   ⚠️  Failed to load dayjs locale: ${locale}`);
+		}
+	}
+};
+configSpecialHandlers.register("app", registerAppConfig);
+
+//#endregion
+export { registerAppConfig };
+//# sourceMappingURL=config-handlers.mjs.map

package/esm/config/config-handlers.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-handlers.mjs","names":[],"sources":["../../../../../../@warlock.js/core/src/config/config-handlers.ts"],"sourcesContent":["import { AppConfigurations } from \"../utils/types\";\nimport { configSpecialHandlers } from \"./config-special-handlers\";\n\n/**\n * App Config Handler\n * Handles locale loading for dayjs\n */\nexport const registerAppConfig = async (config: AppConfigurations) => {\n  // Load dayjs locales based on app.localeCodes\n  const locales = config.locales || [\"en\"];\n\n  for (const locale of locales) {\n    if (locale === \"en\") continue; // English is default\n\n    try {\n      await import(`dayjs/locale/${locale}.js`);\n    } catch (error) {\n      console.warn(`   ⚠️  Failed to load dayjs locale: ${locale}`);\n    }\n  }\n};\n\nconfigSpecialHandlers.register(\"app\", registerAppConfig);\n"],"mappings":";;;;;;;AAOA,MAAa,oBAAoB,OAAO,WAA8B;CAEpE,MAAM,UAAU,OAAO,WAAW,CAAC,IAAI;CAEvC,KAAK,MAAM,UAAU,SAAS;EAC5B,IAAI,WAAW,MAAM;EAErB,IAAI;GACF,MAAM,OAAO,gBAAgB,OAAO;EACtC,SAAS,OAAO;GACd,QAAQ,KAAK,uCAAuC,QAAQ;EAC9D;CACF;AACF;AAEA,sBAAsB,SAAS,OAAO,iBAAiB"}

package/esm/config/config-loader.d.mts

@@ -0,0 +1,9 @@
+//#region ../../@warlock.js/core/src/config/config-loader.d.ts
+/**
+ * Special Config Handler
+ * A function that handles special configuration loading
+ */
+type SpecialConfigHandler = (configValue: any) => void | Promise<void>;
+//#endregion
+export { SpecialConfigHandler };
+//# sourceMappingURL=config-loader.d.mts.map

package/esm/config/config-loader.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-loader.d.mts","names":[],"sources":["../../../../../../@warlock.js/core/src/config/config-loader.ts"],"mappings":";AAUA;;;;AAAA,KAAY,oBAAA,IAAwB,WAAA,iBAA4B,OAAO"}

package/esm/config/config-loader.mjs

@@ -0,0 +1,48 @@
+import { configSpecialHandlers } from "./config-special-handlers.mjs";
+import config from "@mongez/config";
+import { colors } from "@mongez/copper";
+import { pathToFileURL } from "node:url";
+
+//#region ../../@warlock.js/core/src/config/config-loader.ts
+/**
+* Config Loader
+* Dynamically loads all configuration files and registers them with @mongez/config
+* Supports special handlers for configs that require additional processing
+*/
+var ConfigLoader = class {
+	async loadAll(configFiles) {
+		for (const file of configFiles) await this.loadConfig(file);
+	}
+	/**
+	* Load a single configuration file.
+	*
+	* The ESM loader hook stamps a version token onto the URL so that each HMR
+	* cycle gets a fresh module — no manual cache-busting needed here.
+	*/
+	async loadConfig(file) {
+		const configName = this.getConfigName(file.relativePath);
+		try {
+			const configValue = (await import(pathToFileURL(file.absolutePath).href)).default;
+			if (configValue === void 0) {
+				console.log(colors.red(`config error: `), `Config file ${colors.yellow(file.relativePath)} does not have a default export`);
+				return;
+			}
+			config.set(configName, configValue);
+			await configSpecialHandlers.execute(configName, configValue);
+		} catch (error) {
+			throw error;
+		}
+	}
+	async reloadConfig(file) {
+		await this.loadConfig(file);
+	}
+	getConfigName(relativePath) {
+		const match = relativePath.match(/^src\/config\/(.+)\.(ts|tsx)$/);
+		if (!match) throw new Error(`Invalid config file path: ${relativePath}`);
+		return match[1];
+	}
+};
+
+//#endregion
+export { ConfigLoader };
+//# sourceMappingURL=config-loader.mjs.map

package/esm/config/config-loader.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-loader.mjs","names":[],"sources":["../../../../../../@warlock.js/core/src/config/config-loader.ts"],"sourcesContent":["import config from \"@mongez/config\";\r\nimport { colors } from \"@mongez/copper\";\r\nimport { pathToFileURL } from \"node:url\";\r\nimport type { FileManager } from \"../dev-server/file-manager\";\r\nimport { configSpecialHandlers } from \"./config-special-handlers\";\r\n\r\n/**\r\n * Special Config Handler\r\n * A function that handles special configuration loading\r\n */\r\nexport type SpecialConfigHandler = (configValue: any) => void | Promise<void>;\r\n\r\n/**\r\n * Config Loader\r\n * Dynamically loads all configuration files and registers them with @mongez/config\r\n * Supports special handlers for configs that require additional processing\r\n */\r\nexport class ConfigLoader {\r\n  public async loadAll(configFiles: FileManager[]): Promise<void> {\r\n    for (const file of configFiles) {\r\n      await this.loadConfig(file);\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Load a single configuration file.\r\n   *\r\n   * The ESM loader hook stamps a version token onto the URL so that each HMR\r\n   * cycle gets a fresh module — no manual cache-busting needed here.\r\n   */\r\n  public async loadConfig(file: FileManager): Promise<void> {\r\n    const configName = this.getConfigName(file.relativePath);\r\n\r\n    try {\r\n      const fileUrl = pathToFileURL(file.absolutePath).href;\r\n      const configModule = await import(fileUrl);\r\n      const configValue = configModule.default;\r\n\r\n      if (configValue === undefined) {\r\n        console.log(\r\n          colors.red(`config error: `),\r\n          `Config file ${colors.yellow(file.relativePath)} does not have a default export`,\r\n        );\r\n        return;\r\n      }\r\n\r\n      config.set(configName, configValue);\r\n      await configSpecialHandlers.execute(configName, configValue);\r\n    } catch (error) {\r\n      throw error;\r\n    }\r\n  }\r\n\r\n  public async reloadConfig(file: FileManager): Promise<void> {\r\n    await this.loadConfig(file);\r\n  }\r\n\r\n  private getConfigName(relativePath: string): string {\r\n    const match = relativePath.match(/^src\\/config\\/(.+)\\.(ts|tsx)$/);\r\n\r\n    if (!match) {\r\n      throw new Error(`Invalid config file path: ${relativePath}`);\r\n    }\r\n\r\n    return match[1];\r\n  }\r\n}\r\n"],"mappings":";;;;;;;;;;;AAiBA,IAAa,eAAb,MAA0B;CACxB,MAAa,QAAQ,aAA2C;EAC9D,KAAK,MAAM,QAAQ,aACjB,MAAM,KAAK,WAAW,IAAI;CAE9B;;;;;;;CAQA,MAAa,WAAW,MAAkC;EACxD,MAAM,aAAa,KAAK,cAAc,KAAK,YAAY;EAEvD,IAAI;GAGF,MAAM,eAAc,MADO,OADX,cAAc,KAAK,YAAY,EAAE,OAEhB;GAEjC,IAAI,gBAAgB,QAAW;IAC7B,QAAQ,IACN,OAAO,IAAI,gBAAgB,GAC3B,eAAe,OAAO,OAAO,KAAK,YAAY,EAAE,gCAClD;IACA;GACF;GAEA,OAAO,IAAI,YAAY,WAAW;GAClC,MAAM,sBAAsB,QAAQ,YAAY,WAAW;EAC7D,SAAS,OAAO;GACd,MAAM;EACR;CACF;CAEA,MAAa,aAAa,MAAkC;EAC1D,MAAM,KAAK,WAAW,IAAI;CAC5B;CAEA,AAAQ,cAAc,cAA8B;EAClD,MAAM,QAAQ,aAAa,MAAM,+BAA+B;EAEhE,IAAI,CAAC,OACH,MAAM,IAAI,MAAM,6BAA6B,cAAc;EAG7D,OAAO,MAAM;CACf;AACF"}

package/esm/config/config-manager.mjs

@@ -0,0 +1,28 @@
+import { ConfigLoader } from "./config-loader.mjs";
+
+//#region ../../@warlock.js/core/src/config/config-manager.ts
+var ConfigManager = class {
+	/**
+	* Constructor
+	*/
+	constructor() {
+		this.loader = new ConfigLoader();
+	}
+	/**
+	* Load all config files
+	*/
+	async loadAll(files) {
+		return this.loader.loadAll(files);
+	}
+	/**
+	* Reload a config file
+	*/
+	async reload(file) {
+		return this.loader.reloadConfig(file);
+	}
+};
+const configManager = new ConfigManager();
+
+//#endregion
+export { configManager };
+//# sourceMappingURL=config-manager.mjs.map

package/esm/config/config-manager.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-manager.mjs","names":[],"sources":["../../../../../../@warlock.js/core/src/config/config-manager.ts"],"sourcesContent":["import { FileManager } from \"../dev-server/file-manager\";\nimport { ConfigLoader } from \"./config-loader\";\n\nexport class ConfigManager {\n  /**\n   * Config loader instance\n   */\n  public loader = new ConfigLoader();\n\n  /**\n   * Constructor\n   */\n  public constructor() {\n    //\n  }\n\n  /**\n   * Load all config files\n   */\n  public async loadAll(files: FileManager[]) {\n    return this.loader.loadAll(files);\n  }\n\n  /**\n   * Reload a config file\n   */\n  public async reload(file: FileManager) {\n    return this.loader.reloadConfig(file);\n  }\n}\n\nexport const configManager = new ConfigManager();\n"],"mappings":";;;AAGA,IAAa,gBAAb,MAA2B;;;;CASzB,AAAO,cAAc;gBALL,IAAI,aAAa;CAOjC;;;;CAKA,MAAa,QAAQ,OAAsB;EACzC,OAAO,KAAK,OAAO,QAAQ,KAAK;CAClC;;;;CAKA,MAAa,OAAO,MAAmB;EACrC,OAAO,KAAK,OAAO,aAAa,IAAI;CACtC;AACF;AAEA,MAAa,gBAAgB,IAAI,cAAc"}

package/esm/config/config-special-handlers.d.mts

@@ -0,0 +1,21 @@
+import { SpecialConfigHandler } from "./config-loader.mjs";
+
+//#region ../../@warlock.js/core/src/config/config-special-handlers.d.ts
+declare class ConfigSpecialHandlers {
+  /**
+   * Handlers
+   */
+  protected handlers: Map<string, SpecialConfigHandler>;
+  /**
+   * Register a new handler
+   */
+  register(configName: string, handler: SpecialConfigHandler): void;
+  /**
+   * Execute handler for the given config name
+   */
+  execute(configName: string, config: any): Promise<void>;
+}
+declare const configSpecialHandlers: ConfigSpecialHandlers;
+//#endregion
+export { ConfigSpecialHandlers, configSpecialHandlers };
+//# sourceMappingURL=config-special-handlers.d.mts.map

package/esm/config/config-special-handlers.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-special-handlers.d.mts","names":[],"sources":["../../../../../../@warlock.js/core/src/config/config-special-handlers.ts"],"mappings":";;;cAEa,qBAAA;;AAAb;;YAIY,QAAA,EAAU,GAAA,SAAY,oBAAA;EAAA;;;EAKzB,QAAA,CAAS,UAAA,UAAoB,OAAA,EAAS,oBAAA;EAOO;;;EAAvC,OAAA,CAAQ,UAAA,UAAoB,MAAA,QAAW,OAAA;AAAA;AAAA,cAUzC,qBAAA,EAAqB,qBAA8B"}