@axi-engine/configs 0.1.2 → 0.1.3

package/dist/index.d.mts

@@ -1,13 +1,14 @@
-import { PathType } from "@axi-engine/utils";
+import { PathType } from '@axi-engine/utils';
 
-//#region src/config-resolver.types.d.ts
 /**
  * Represents a specific configuration variant that can extend another variant.
  * @template T The base type of the configuration object.
  */
 type ConfigVariant<T extends object> = {
-  /** Path to a base config (or multiple configs) that this variant extends. */extends?: PathType; /** The specific fields that override or extend the base config. */
-  fields?: Partial<T>;
+    /** Path to a base config (or multiple configs) that this variant extends. */
+    extends?: PathType;
+    /** The specific fields that override or extend the base config. */
+    fields?: Partial<T>;
 };
 /**
  * Represents the hierarchical structure of the configuration.
@@ -15,42 +16,40 @@ type ConfigVariant<T extends object> = {
  * @template T The base type of the configuration object.
  */
 type ConfigTree<T extends object> = {
-  [key: string]: ConfigVariant<T> | ConfigTree<T>;
+    [key: string]: ConfigVariant<T> | ConfigTree<T>;
 };
 /**
  * Type guard to check if an object is a ConfigVariant.
  */
 declare function isConfigVariant<T extends object>(obj: any): obj is ConfigVariant<T>;
-//#endregion
-//#region src/config-resolver.d.ts
+
 /**
  * Resolves hierarchical configurations with inheritance and caching.
  * @template TBase The base type for all configurations this resolver handles.
  */
 declare class ConfigResolver<TBase extends object> {
-  readonly configs: ConfigTree<TBase>;
-  private cache;
-  constructor(configs: ConfigTree<TBase>);
-  /**
-       * Retrieves a fully resolved and merged configuration for a given path.
-       * @template T A specific subtype of TBase that the caller expects.
-       * @param path Path to the config, e.g., 'enemies.boss.goblin'.
-       * @returns The resolved configuration object.
-       */
-  get<T extends TBase>(path: PathType): T;
-  /**
-       * Clears the cache of resolved configurations.
-       */
-  clearCache(): void;
-  /**
-       * Recursively calculates the configuration by merging a variant with its parents.
-       */
-  private calculateConfig;
-  /**
-       * Traverses the config tree to find the node at the specified path.
-       */
-  private getNode;
+    readonly configs: ConfigTree<TBase>;
+    private cache;
+    constructor(configs: ConfigTree<TBase>);
+    /**
+     * Retrieves a fully resolved and merged configuration for a given path.
+     * @template T A specific subtype of TBase that the caller expects.
+     * @param path Path to the config, e.g., 'enemies.boss.goblin'.
+     * @returns The resolved configuration object.
+     */
+    get<T extends TBase>(path: PathType): T;
+    /**
+     * Clears the cache of resolved configurations.
+     */
+    clearCache(): void;
+    /**
+     * Recursively calculates the configuration by merging a variant with its parents.
+     */
+    private calculateConfig;
+    /**
+     * Traverses the config tree to find the node at the specified path.
+     */
+    private getNode;
 }
-//#endregion
-export { ConfigResolver, ConfigTree, ConfigVariant, isConfigVariant };
-//# sourceMappingURL=index.d.mts.map
+
+export { ConfigResolver, type ConfigTree, type ConfigVariant, isConfigVariant };

package/dist/index.d.ts

@@ -0,0 +1,55 @@
+import { PathType } from '@axi-engine/utils';
+
+/**
+ * Represents a specific configuration variant that can extend another variant.
+ * @template T The base type of the configuration object.
+ */
+type ConfigVariant<T extends object> = {
+    /** Path to a base config (or multiple configs) that this variant extends. */
+    extends?: PathType;
+    /** The specific fields that override or extend the base config. */
+    fields?: Partial<T>;
+};
+/**
+ * Represents the hierarchical structure of the configuration.
+ * It's a recursive type that can contain other trees or final variants.
+ * @template T The base type of the configuration object.
+ */
+type ConfigTree<T extends object> = {
+    [key: string]: ConfigVariant<T> | ConfigTree<T>;
+};
+/**
+ * Type guard to check if an object is a ConfigVariant.
+ */
+declare function isConfigVariant<T extends object>(obj: any): obj is ConfigVariant<T>;
+
+/**
+ * Resolves hierarchical configurations with inheritance and caching.
+ * @template TBase The base type for all configurations this resolver handles.
+ */
+declare class ConfigResolver<TBase extends object> {
+    readonly configs: ConfigTree<TBase>;
+    private cache;
+    constructor(configs: ConfigTree<TBase>);
+    /**
+     * Retrieves a fully resolved and merged configuration for a given path.
+     * @template T A specific subtype of TBase that the caller expects.
+     * @param path Path to the config, e.g., 'enemies.boss.goblin'.
+     * @returns The resolved configuration object.
+     */
+    get<T extends TBase>(path: PathType): T;
+    /**
+     * Clears the cache of resolved configurations.
+     */
+    clearCache(): void;
+    /**
+     * Recursively calculates the configuration by merging a variant with its parents.
+     */
+    private calculateConfig;
+    /**
+     * Traverses the config tree to find the node at the specified path.
+     */
+    private getNode;
+}
+
+export { ConfigResolver, type ConfigTree, type ConfigVariant, isConfigVariant };

package/dist/index.js

@@ -0,0 +1,94 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ConfigResolver: () => ConfigResolver,
+  isConfigVariant: () => isConfigVariant
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/config-resolver.types.ts
+function isConfigVariant(obj) {
+  return obj && (obj.fields !== void 0 || obj.extends !== void 0);
+}
+
+// src/config-resolver.ts
+var import_deepmerge_ts = require("deepmerge-ts");
+var import_utils = require("@axi-engine/utils");
+var ConfigResolver = class {
+  constructor(configs) {
+    this.configs = configs;
+  }
+  cache = /* @__PURE__ */ new Map();
+  /**
+   * Retrieves a fully resolved and merged configuration for a given path.
+   * @template T A specific subtype of TBase that the caller expects.
+   * @param path Path to the config, e.g., 'enemies.boss.goblin'.
+   * @returns The resolved configuration object.
+   */
+  get(path) {
+    const pathArr = (0, import_utils.ensurePathArray)(path);
+    const fullPathKey = pathArr.join(import_utils.axiSettings.pathSeparator);
+    if (this.cache.has(fullPathKey)) {
+      return this.cache.get(fullPathKey);
+    }
+    const config = this.calculateConfig(pathArr);
+    this.cache.set(fullPathKey, config);
+    return config;
+  }
+  /**
+   * Clears the cache of resolved configurations.
+   */
+  clearCache() {
+    this.cache.clear();
+  }
+  /**
+   * Recursively calculates the configuration by merging a variant with its parents.
+   */
+  calculateConfig(path, visited = []) {
+    const node = this.getNode(path, this.configs);
+    const pathStr = path.join(import_utils.axiSettings.pathSeparator);
+    (0, import_utils.throwIf)(visited.includes(pathStr), `Cyclic dependency detected in ${pathStr}`);
+    visited.push(pathStr);
+    const parentNode = node.extends ? this.calculateConfig((0, import_utils.ensurePathArray)(node.extends), [...visited]) : {};
+    return (0, import_deepmerge_ts.deepmerge)(parentNode, node);
+  }
+  /**
+   * Traverses the config tree to find the node at the specified path.
+   */
+  getNode(path, tree) {
+    const pathStr = path.join(import_utils.axiSettings.pathSeparator);
+    const [current, ...rest] = path;
+    const node = tree[current];
+    (0, import_utils.throwIfEmpty)(node, `Can't find node with path: ${pathStr}`);
+    if (rest.length > 0) {
+      (0, import_utils.throwIf)(isConfigVariant(node), `Path leads through a variant, not a tree branch: ${pathStr}`);
+      return this.getNode(rest, node);
+    }
+    (0, import_utils.throwIf)(!isConfigVariant(node), `Path does not lead to a variant: ${pathStr}`);
+    return node;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConfigResolver,
+  isConfigVariant
+});

package/dist/index.mjs

@@ -1,72 +1,66 @@
-import { deepmerge } from "deepmerge-ts";
-import { axiSettings, ensurePathArray, throwIf, throwIfEmpty } from "@axi-engine/utils";
-
-//#region src/config-resolver.types.ts
-/**
-* Type guard to check if an object is a ConfigVariant.
-*/
+// src/config-resolver.types.ts
 function isConfigVariant(obj) {
-	return obj && (obj.fields !== void 0 || obj.extends !== void 0);
+  return obj && (obj.fields !== void 0 || obj.extends !== void 0);
 }
 
-//#endregion
-//#region src/config-resolver.ts
-/**
-* Resolves hierarchical configurations with inheritance and caching.
-* @template TBase The base type for all configurations this resolver handles.
-*/
+// src/config-resolver.ts
+import { deepmerge } from "deepmerge-ts";
+import { axiSettings, ensurePathArray, throwIf, throwIfEmpty } from "@axi-engine/utils";
 var ConfigResolver = class {
-	cache = /* @__PURE__ */ new Map();
-	constructor(configs) {
-		this.configs = configs;
-	}
-	/**
-	* Retrieves a fully resolved and merged configuration for a given path.
-	* @template T A specific subtype of TBase that the caller expects.
-	* @param path Path to the config, e.g., 'enemies.boss.goblin'.
-	* @returns The resolved configuration object.
-	*/
-	get(path) {
-		const pathArr = ensurePathArray(path);
-		const fullPathKey = pathArr.join(axiSettings.pathSeparator);
-		if (this.cache.has(fullPathKey)) return this.cache.get(fullPathKey);
-		const config = this.calculateConfig(pathArr);
-		this.cache.set(fullPathKey, config);
-		return config;
-	}
-	/**
-	* Clears the cache of resolved configurations.
-	*/
-	clearCache() {
-		this.cache.clear();
-	}
-	/**
-	* Recursively calculates the configuration by merging a variant with its parents.
-	*/
-	calculateConfig(path, visited = []) {
-		const node = this.getNode(path, this.configs);
-		const pathStr = path.join(axiSettings.pathSeparator);
-		throwIf(visited.includes(pathStr), `Cyclic dependency detected in ${pathStr}`);
-		visited.push(pathStr);
-		return deepmerge(node.extends ? this.calculateConfig(ensurePathArray(node.extends), [...visited]) : {}, node);
-	}
-	/**
-	* Traverses the config tree to find the node at the specified path.
-	*/
-	getNode(path, tree) {
-		const pathStr = path.join(axiSettings.pathSeparator);
-		const [current, ...rest] = path;
-		const node = tree[current];
-		throwIfEmpty(node, `Can't find node with path: ${pathStr}`);
-		if (rest.length > 0) {
-			throwIf(isConfigVariant(node), `Path leads through a variant, not a tree branch: ${pathStr}`);
-			return this.getNode(rest, node);
-		}
-		throwIf(!isConfigVariant(node), `Path does not lead to a variant: ${pathStr}`);
-		return node;
-	}
+  constructor(configs) {
+    this.configs = configs;
+  }
+  cache = /* @__PURE__ */ new Map();
+  /**
+   * Retrieves a fully resolved and merged configuration for a given path.
+   * @template T A specific subtype of TBase that the caller expects.
+   * @param path Path to the config, e.g., 'enemies.boss.goblin'.
+   * @returns The resolved configuration object.
+   */
+  get(path) {
+    const pathArr = ensurePathArray(path);
+    const fullPathKey = pathArr.join(axiSettings.pathSeparator);
+    if (this.cache.has(fullPathKey)) {
+      return this.cache.get(fullPathKey);
+    }
+    const config = this.calculateConfig(pathArr);
+    this.cache.set(fullPathKey, config);
+    return config;
+  }
+  /**
+   * Clears the cache of resolved configurations.
+   */
+  clearCache() {
+    this.cache.clear();
+  }
+  /**
+   * Recursively calculates the configuration by merging a variant with its parents.
+   */
+  calculateConfig(path, visited = []) {
+    const node = this.getNode(path, this.configs);
+    const pathStr = path.join(axiSettings.pathSeparator);
+    throwIf(visited.includes(pathStr), `Cyclic dependency detected in ${pathStr}`);
+    visited.push(pathStr);
+    const parentNode = node.extends ? this.calculateConfig(ensurePathArray(node.extends), [...visited]) : {};
+    return deepmerge(parentNode, node);
+  }
+  /**
+   * Traverses the config tree to find the node at the specified path.
+   */
+  getNode(path, tree) {
+    const pathStr = path.join(axiSettings.pathSeparator);
+    const [current, ...rest] = path;
+    const node = tree[current];
+    throwIfEmpty(node, `Can't find node with path: ${pathStr}`);
+    if (rest.length > 0) {
+      throwIf(isConfigVariant(node), `Path leads through a variant, not a tree branch: ${pathStr}`);
+      return this.getNode(rest, node);
+    }
+    throwIf(!isConfigVariant(node), `Path does not lead to a variant: ${pathStr}`);
+    return node;
+  }
+};
+export {
+  ConfigResolver,
+  isConfigVariant
 };
-
-//#endregion
-export { ConfigResolver, isConfigVariant };
-//# sourceMappingURL=index.mjs.map

package/package.json

@@ -1,44 +1,44 @@
-{
-  "name": "@axi-engine/configs",
-  "version": "0.1.2",
-  "description": "A lightweight, type-safe, and hierarchical configuration resolver",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/axijs/engine.git",
-    "directory": "packages/configs"
-  },
-  "keywords": [
-    "axi-engine",
-    "typescript",
-    "gamedev",
-    "configs"
-  ],
-  "types": "./dist/index.d.ts",
-  "main": "./dist/index.js",
-  "module": "./dist/index.mjs",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.mjs",
-      "require": "./dist/index.js"
-    }
-  },
-  "scripts": {
-    "build": "tsdown",
-    "docs": "typedoc src/index.ts --out docs/api --options ../../typedoc.json",
-    "test": "echo 'No tests yet for @axi-engine/configs'"
-  },
-  "files": [
-    "dist"
-  ],
-  "dependencies": {
-    "deepmerge-ts": "^7.1.5"
-  },
-  "devDependencies": {
-    "@axi-engine/utils": "^0.1.6"
-  },
-  "peerDependencies": {
-    "@axi-engine/utils": "^0.1.6"
-  }
-}
+{
+  "name": "@axi-engine/configs",
+  "version": "0.1.3",
+  "description": "A lightweight, type-safe, and hierarchical configuration resolver",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/axijs/engine.git",
+    "directory": "packages/configs"
+  },
+  "keywords": [
+    "axi-engine",
+    "typescript",
+    "gamedev",
+    "configs"
+  ],
+  "types": "./dist/index.d.ts",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsup",
+    "docs": "typedoc src/index.ts --out docs/api --options ../../typedoc.json",
+    "test": "echo 'No tests yet for @axi-engine/configs'"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "deepmerge-ts": "^7.1.5"
+  },
+  "devDependencies": {
+    "@axi-engine/utils": "^0.1.6"
+  },
+  "peerDependencies": {
+    "@axi-engine/utils": "^0.1.6"
+  }
+}

package/dist/index.cjs

@@ -1,72 +0,0 @@
-let deepmerge_ts = require("deepmerge-ts");
-let _axi_engine_utils = require("@axi-engine/utils");
-
-//#region src/config-resolver.types.ts
-/**
-* Type guard to check if an object is a ConfigVariant.
-*/
-function isConfigVariant(obj) {
-	return obj && (obj.fields !== void 0 || obj.extends !== void 0);
-}
-
-//#endregion
-//#region src/config-resolver.ts
-/**
-* Resolves hierarchical configurations with inheritance and caching.
-* @template TBase The base type for all configurations this resolver handles.
-*/
-var ConfigResolver = class {
-	cache = /* @__PURE__ */ new Map();
-	constructor(configs) {
-		this.configs = configs;
-	}
-	/**
-	* Retrieves a fully resolved and merged configuration for a given path.
-	* @template T A specific subtype of TBase that the caller expects.
-	* @param path Path to the config, e.g., 'enemies.boss.goblin'.
-	* @returns The resolved configuration object.
-	*/
-	get(path) {
-		const pathArr = (0, _axi_engine_utils.ensurePathArray)(path);
-		const fullPathKey = pathArr.join(_axi_engine_utils.axiSettings.pathSeparator);
-		if (this.cache.has(fullPathKey)) return this.cache.get(fullPathKey);
-		const config = this.calculateConfig(pathArr);
-		this.cache.set(fullPathKey, config);
-		return config;
-	}
-	/**
-	* Clears the cache of resolved configurations.
-	*/
-	clearCache() {
-		this.cache.clear();
-	}
-	/**
-	* Recursively calculates the configuration by merging a variant with its parents.
-	*/
-	calculateConfig(path, visited = []) {
-		const node = this.getNode(path, this.configs);
-		const pathStr = path.join(_axi_engine_utils.axiSettings.pathSeparator);
-		(0, _axi_engine_utils.throwIf)(visited.includes(pathStr), `Cyclic dependency detected in ${pathStr}`);
-		visited.push(pathStr);
-		return (0, deepmerge_ts.deepmerge)(node.extends ? this.calculateConfig((0, _axi_engine_utils.ensurePathArray)(node.extends), [...visited]) : {}, node);
-	}
-	/**
-	* Traverses the config tree to find the node at the specified path.
-	*/
-	getNode(path, tree) {
-		const pathStr = path.join(_axi_engine_utils.axiSettings.pathSeparator);
-		const [current, ...rest] = path;
-		const node = tree[current];
-		(0, _axi_engine_utils.throwIfEmpty)(node, `Can't find node with path: ${pathStr}`);
-		if (rest.length > 0) {
-			(0, _axi_engine_utils.throwIf)(isConfigVariant(node), `Path leads through a variant, not a tree branch: ${pathStr}`);
-			return this.getNode(rest, node);
-		}
-		(0, _axi_engine_utils.throwIf)(!isConfigVariant(node), `Path does not lead to a variant: ${pathStr}`);
-		return node;
-	}
-};
-
-//#endregion
-exports.ConfigResolver = ConfigResolver;
-exports.isConfigVariant = isConfigVariant;

package/dist/index.d.cts

@@ -1,56 +0,0 @@
-import { PathType } from "@axi-engine/utils";
-
-//#region src/config-resolver.types.d.ts
-/**
- * Represents a specific configuration variant that can extend another variant.
- * @template T The base type of the configuration object.
- */
-type ConfigVariant<T extends object> = {
-  /** Path to a base config (or multiple configs) that this variant extends. */extends?: PathType; /** The specific fields that override or extend the base config. */
-  fields?: Partial<T>;
-};
-/**
- * Represents the hierarchical structure of the configuration.
- * It's a recursive type that can contain other trees or final variants.
- * @template T The base type of the configuration object.
- */
-type ConfigTree<T extends object> = {
-  [key: string]: ConfigVariant<T> | ConfigTree<T>;
-};
-/**
- * Type guard to check if an object is a ConfigVariant.
- */
-declare function isConfigVariant<T extends object>(obj: any): obj is ConfigVariant<T>;
-//#endregion
-//#region src/config-resolver.d.ts
-/**
- * Resolves hierarchical configurations with inheritance and caching.
- * @template TBase The base type for all configurations this resolver handles.
- */
-declare class ConfigResolver<TBase extends object> {
-  readonly configs: ConfigTree<TBase>;
-  private cache;
-  constructor(configs: ConfigTree<TBase>);
-  /**
-       * Retrieves a fully resolved and merged configuration for a given path.
-       * @template T A specific subtype of TBase that the caller expects.
-       * @param path Path to the config, e.g., 'enemies.boss.goblin'.
-       * @returns The resolved configuration object.
-       */
-  get<T extends TBase>(path: PathType): T;
-  /**
-       * Clears the cache of resolved configurations.
-       */
-  clearCache(): void;
-  /**
-       * Recursively calculates the configuration by merging a variant with its parents.
-       */
-  private calculateConfig;
-  /**
-       * Traverses the config tree to find the node at the specified path.
-       */
-  private getNode;
-}
-//#endregion
-export { ConfigResolver, ConfigTree, ConfigVariant, isConfigVariant };
-//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../src/config-resolver.types.ts","../src/config-resolver.ts"],"mappings":";;;;AAMA;;;KAAY,aAAA;EAAA,6EAAA,OAAA,GAEA,QAAA;EAAA,MAAA,GAED,OAAA,CAAQ,CAAA;AAAA;AAAA;;;AAQnB;;AARmB,KAQP,UAAA;EAAA,CAAA,GAAA,WACK,aAAA,CAAc,CAAA,IAAK,UAAA,CAAW,CAAA;AAAA;AAAA;;;AAAA,iBAM/B,eAAA,kBAAA,CAAA,GAAA,QAAA,GAAA,IAAoD,aAAA,CAAc,CAAA;;;;ACjBlF;;;cAAa,cAAA;EAAA,SAAA,OAAA,EAG0B,UAAA,CAAW,KAAA;EAAA,QAAA,KAAA;EAAA,YAAA,OAAA,EAAX,UAAA,CAAW,KAAA;EAAA;;;;;;EAAA,GAAA,WAQlC,KAAA,CAAA,CAAA,IAAA,EAAa,QAAA,GAAW,CAAA;EAAA;;;EAAA,WAAA;EAAA;;;EAAA,QAAA,eAAA;EAAA;;;EAAA,QAAA,OAAA;AAAA"}

package/dist/index.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/config-resolver.types.ts","../src/config-resolver.ts"],"mappings":";;;;AAMA;;;KAAY,aAAA;EAAA,6EAAA,OAAA,GAEA,QAAA;EAAA,MAAA,GAED,OAAA,CAAQ,CAAA;AAAA;AAAA;;;AAQnB;;AARmB,KAQP,UAAA;EAAA,CAAA,GAAA,WACK,aAAA,CAAc,CAAA,IAAK,UAAA,CAAW,CAAA;AAAA;AAAA;;;AAAA,iBAM/B,eAAA,kBAAA,CAAA,GAAA,QAAA,GAAA,IAAoD,aAAA,CAAc,CAAA;;;;ACjBlF;;;cAAa,cAAA;EAAA,SAAA,OAAA,EAG0B,UAAA,CAAW,KAAA;EAAA,QAAA,KAAA;EAAA,YAAA,OAAA,EAAX,UAAA,CAAW,KAAA;EAAA;;;;;;EAAA,GAAA,WAQlC,KAAA,CAAA,CAAA,IAAA,EAAa,QAAA,GAAW,CAAA;EAAA;;;EAAA,WAAA;EAAA;;;EAAA,QAAA,eAAA;EAAA;;;EAAA,QAAA,OAAA;AAAA"}

package/dist/index.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../src/config-resolver.types.ts","../src/config-resolver.ts"],"sourcesContent":["import {PathType} from '@axi-engine/utils';\r\n\r\n/**\r\n * Represents a specific configuration variant that can extend another variant.\r\n * @template T The base type of the configuration object.\r\n */\r\nexport type ConfigVariant<T extends object> = {\r\n  /** Path to a base config (or multiple configs) that this variant extends. */\r\n  extends?: PathType;\r\n  /** The specific fields that override or extend the base config. */\r\n  fields?: Partial<T>;\r\n};\r\n\r\n/**\r\n * Represents the hierarchical structure of the configuration.\r\n * It's a recursive type that can contain other trees or final variants.\r\n * @template T The base type of the configuration object.\r\n */\r\nexport type ConfigTree<T extends object> = {\r\n  [key: string]: ConfigVariant<T> | ConfigTree<T>;\r\n};\r\n\r\n/**\r\n * Type guard to check if an object is a ConfigVariant.\r\n */\r\nexport function isConfigVariant<T extends object>(obj: any): obj is ConfigVariant<T> {\r\n  // The logic remains the same, but the signature is now generic.\r\n  return obj && (obj.fields !== undefined || obj.extends !== undefined);\r\n}\r\n","import {deepmerge} from \"deepmerge-ts\";\r\nimport {ConfigTree, ConfigVariant, isConfigVariant} from './config-resolver.types';\r\nimport {axiSettings, ensurePathArray, PathType, throwIf, throwIfEmpty} from '@axi-engine/utils';\r\n\r\n/**\r\n * Resolves hierarchical configurations with inheritance and caching.\r\n * @template TBase The base type for all configurations this resolver handles.\r\n */\r\nexport class ConfigResolver<TBase extends object> {\r\n  private cache = new Map<string, TBase>();\r\n\r\n  constructor(public readonly configs: ConfigTree<TBase>) {}\r\n\r\n  /**\r\n   * Retrieves a fully resolved and merged configuration for a given path.\r\n   * @template T A specific subtype of TBase that the caller expects.\r\n   * @param path Path to the config, e.g., 'enemies.boss.goblin'.\r\n   * @returns The resolved configuration object.\r\n   */\r\n  get<T extends TBase>(path: PathType): T {\r\n    const pathArr = ensurePathArray(path);\r\n    const fullPathKey = pathArr.join(axiSettings.pathSeparator);\r\n\r\n    if (this.cache.has(fullPathKey)) {\r\n      return this.cache.get(fullPathKey) as T;\r\n    }\r\n\r\n    const config = this.calculateConfig<T>(pathArr);\r\n    this.cache.set(fullPathKey, config);\r\n    return config;\r\n  }\r\n\r\n  /**\r\n   * Clears the cache of resolved configurations.\r\n   */\r\n  clearCache(): void {\r\n    this.cache.clear();\r\n  }\r\n\r\n  /**\r\n   * Recursively calculates the configuration by merging a variant with its parents.\r\n   */\r\n  private calculateConfig<T extends TBase>(path: string[], visited: string[] = []): T {\r\n    const node = this.getNode(path, this.configs) as ConfigVariant<T>;\r\n    const pathStr = path.join(axiSettings.pathSeparator);\r\n\r\n    throwIf(visited.includes(pathStr), `Cyclic dependency detected in ${pathStr}`);\r\n    visited.push(pathStr);\r\n\r\n    const parentNode = node.extends ? this.calculateConfig<T>(ensurePathArray(node.extends), [...visited]) : {};\r\n    return deepmerge(parentNode, node) as T;\r\n  }\r\n\r\n  /**\r\n   * Traverses the config tree to find the node at the specified path.\r\n   */\r\n  private getNode(path: string[], tree: ConfigTree<TBase>): ConfigVariant<TBase> {\r\n    const pathStr = path.join(axiSettings.pathSeparator);\r\n    const [current, ...rest] = path;\r\n    const node = tree[current];\r\n    throwIfEmpty(node, `Can't find node with path: ${pathStr}`);\r\n\r\n    if (rest.length > 0) {\r\n      throwIf(isConfigVariant(node), `Path leads through a variant, not a tree branch: ${pathStr}`);\r\n      return this.getNode(rest, node as ConfigTree<TBase>);\r\n    }\r\n\r\n    throwIf(!isConfigVariant(node), `Path does not lead to a variant: ${pathStr}`);\r\n    return node as ConfigVariant<TBase>;\r\n  }\r\n}\r\n"],"mappings":";;;;;;;AAyBA,SAAgB,gBAAkC,KAAmC;AAEnF,QAAO,QAAQ,IAAI,WAAW,UAAa,IAAI,YAAY;;;;;;;;;ACnB7D,IAAa,iBAAb,MAAkD;CAChD,AAAQ,wBAAQ,IAAI,KAAoB;CAExC,YAAY,AAAgB,SAA4B;EAA5B;;;;;;;;CAQ5B,IAAqB,MAAmB;EACtC,MAAM,UAAU,gBAAgB,KAAK;EACrC,MAAM,cAAc,QAAQ,KAAK,YAAY,cAAc;AAE3D,MAAI,KAAK,MAAM,IAAI,YAAY,CAC7B,QAAO,KAAK,MAAM,IAAI,YAAY;EAGpC,MAAM,SAAS,KAAK,gBAAmB,QAAQ;AAC/C,OAAK,MAAM,IAAI,aAAa,OAAO;AACnC,SAAO;;;;;CAMT,aAAmB;AACjB,OAAK,MAAM,OAAO;;;;;CAMpB,AAAQ,gBAAiC,MAAgB,UAAoB,EAAE,EAAK;EAClF,MAAM,OAAO,KAAK,QAAQ,MAAM,KAAK,QAAQ;EAC7C,MAAM,UAAU,KAAK,KAAK,YAAY,cAAc;AAEpD,UAAQ,QAAQ,SAAS,QAAQ,EAAE,iCAAiC,UAAU;AAC9E,UAAQ,KAAK,QAAQ;AAGrB,SAAO,UADY,KAAK,UAAU,KAAK,gBAAmB,gBAAgB,KAAK,QAAQ,EAAE,CAAC,GAAG,QAAQ,CAAC,GAAG,EAAE,EAC9E,KAAK;;;;;CAMpC,AAAQ,QAAQ,MAAgB,MAA+C;EAC7E,MAAM,UAAU,KAAK,KAAK,YAAY,cAAc;EACpD,MAAM,CAAC,SAAS,GAAG,QAAQ;EAC3B,MAAM,OAAO,KAAK;AAClB,eAAa,MAAM,8BAA8B,UAAU;AAE3D,MAAI,KAAK,SAAS,GAAG;AACnB,WAAQ,gBAAgB,KAAK,EAAE,oDAAoD,UAAU;AAC7F,UAAO,KAAK,QAAQ,MAAM,KAA0B;;AAGtD,UAAQ,CAAC,gBAAgB,KAAK,EAAE,oCAAoC,UAAU;AAC9E,SAAO"}