@meltstudio/config-loader 1.0.4 → 2.0.0

package/dist/index.js

@@ -5,7 +5,6 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -27,18 +26,70 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-  return value;
-};
 
 // src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  default: () => src_default,
-  option: () => option
+var index_exports = {};
+__export(index_exports, {
+  ConfigFileError: () => ConfigFileError,
+  ConfigLoadError: () => ConfigLoadError,
+  default: () => index_default
 });
-module.exports = __toCommonJS(src_exports);
+module.exports = __toCommonJS(index_exports);
+
+// src/settings.ts
+var import_commander = require("commander");
+
+// src/errors.ts
+var ConfigLoadError = class extends Error {
+  errors;
+  warnings;
+  constructor(errors, warnings) {
+    const message = `Configuration loading failed with ${errors.length} error${errors.length === 1 ? "" : "s"}`;
+    super(message);
+    this.name = "ConfigLoadError";
+    this.errors = errors;
+    this.warnings = warnings;
+  }
+};
+var ConfigFileError = class extends ConfigLoadError {
+  constructor(message) {
+    super([{ message, kind: "file_validation" }], []);
+    this.name = "ConfigFileError";
+    this.message = message;
+  }
+};
+
+// src/nodes/configNode.ts
+var ConfigNode = class {
+  value;
+  path;
+  sourceType;
+  file;
+  variableName;
+  argName;
+  line;
+  column;
+  constructor(value, path2, sourceType, file, variableName, argName, line = null, column = null) {
+    this.value = value;
+    this.path = path2;
+    this.sourceType = sourceType;
+    this.file = file;
+    this.variableName = variableName;
+    this.argName = argName;
+    this.line = line;
+    this.column = column;
+  }
+};
+var configNode_default = ConfigNode;
+
+// src/nodes/configNodeArray.ts
+var ConfigNodeArray = class {
+  arrayValues;
+  constructor(arrayValues) {
+    this.arrayValues = arrayValues;
+  }
+};
+var configNodeArray_default = ConfigNodeArray;
 
 // src/types.ts
 var InvalidValue = class {
@@ -55,57 +106,175 @@ var ArrayValueContainer = class {
 };
 var arrayOption_default = ArrayValueContainer;
 
-// src/option/base.ts
+// src/fileLoader.ts
 var fs = __toESM(require("fs"));
 var import_js_yaml = __toESM(require("js-yaml"));
-
-// src/nodes/configNode.ts
-var ConfigNode = class {
-  value;
-  path;
-  source_type;
-  file;
-  variable_name;
-  arg_name;
-  constructor(value, path, source_type, file, variable_name, arg_name) {
-    this.value = value;
-    this.path = path;
-    this.source_type = source_type;
-    this.file = file;
-    this.variable_name = variable_name;
-    this.arg_name = arg_name;
+var import_js_yaml_source_map = __toESM(require("js-yaml-source-map"));
+var path = __toESM(require("path"));
+var fileCache = /* @__PURE__ */ new Map();
+var JsonSourceMap = class {
+  locations = /* @__PURE__ */ new Map();
+  constructor(content) {
+    this.buildMap(content);
+  }
+  buildMap(content, prefix = []) {
+    const lines = content.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const keyRegex = /^(\s*)"([^"]+)"\s*:/g;
+      let match;
+      while ((match = keyRegex.exec(line)) !== null) {
+        const key = match[2];
+        const column = match[1].length + 1;
+        this.locations.set(key, {
+          line: i + 1,
+          column,
+          position: 0
+        });
+      }
+    }
+    try {
+      const data = JSON.parse(content);
+      this.walkObject(data, prefix, lines);
+    } catch {
+    }
+  }
+  walkObject(obj, prefix, lines) {
+    for (const key of Object.keys(obj)) {
+      const fullPath = [...prefix, key].join(".");
+      for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const keyPattern = `"${key}"`;
+        const idx = line.indexOf(keyPattern);
+        if (idx !== -1) {
+          const afterKey = line.slice(idx + keyPattern.length).trim();
+          if (afterKey.startsWith(":")) {
+            this.locations.set(fullPath, {
+              line: i + 1,
+              column: idx + 1,
+              position: 0
+            });
+            break;
+          }
+        }
+      }
+      const val = obj[key];
+      if (val && typeof val === "object" && !Array.isArray(val)) {
+        this.walkObject(
+          val,
+          [...prefix, key],
+          lines
+        );
+      }
+    }
+  }
+  lookup(path2) {
+    const key = Array.isArray(path2) ? path2.join(".") : path2;
+    return this.locations.get(key);
   }
 };
-var configNode_default = ConfigNode;
+function loadConfigFile(filePath) {
+  const cached = fileCache.get(filePath);
+  if (cached) return cached;
+  const content = fs.readFileSync(filePath, "utf-8");
+  const ext = path.extname(filePath).toLowerCase();
+  try {
+    if (ext === ".json") {
+      const result2 = {
+        data: JSON.parse(content),
+        sourceMap: new JsonSourceMap(content)
+      };
+      fileCache.set(filePath, result2);
+      return result2;
+    }
+    const sourceMap = new import_js_yaml_source_map.default();
+    const data = import_js_yaml.default.load(content, { listener: sourceMap.listen() });
+    const result = { data, sourceMap };
+    fileCache.set(filePath, result);
+    return result;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : "Unknown parsing error";
+    throw new ConfigFileError(
+      `Failed to parse config file '${filePath}': ${message}`
+    );
+  }
+}
+function clearFileCache() {
+  fileCache.clear();
+}
 
 // src/utils.ts
 function valueIsInvalid(val) {
   return val instanceof InvalidValue || val === null || val === void 0;
 }
 
-// src/option/errors.ts
-var _OptionErrors = class {
-  static clearAll() {
-    _OptionErrors.errors = [];
-    _OptionErrors.warnings = [];
-  }
-};
-var OptionErrors = _OptionErrors;
-__publicField(OptionErrors, "errors", []);
-__publicField(OptionErrors, "warnings", []);
-
 // src/option/base.ts
+function valueToString(val) {
+  if (typeof val === "object" && val !== null) {
+    return JSON.stringify(val);
+  }
+  return String(val);
+}
+function lookupLocation(sourceMap, path2) {
+  if (!sourceMap) return null;
+  const loc = sourceMap.lookup(path2.map(String));
+  if (!loc) return null;
+  return { line: loc.line, column: loc.column };
+}
+function findEnvFileSource(envKey, currentValue, envFileResults) {
+  if (!envFileResults) return null;
+  for (let i = envFileResults.length - 1; i >= 0; i--) {
+    const result = envFileResults[i];
+    const entry = result.entries.get(envKey);
+    if (entry && entry.value === currentValue) {
+      return {
+        filePath: result.filePath,
+        line: entry.line,
+        column: entry.column
+      };
+    }
+  }
+  return null;
+}
+function checkNumberType(val, pathStr, sourceOfVal, errors) {
+  if (typeof val === "string") {
+    const parseVal = parseInt(val, 10);
+    if (Number.isNaN(parseVal)) {
+      errors?.errors.push({
+        message: `Cannot convert value '${val}' for '${pathStr}' to number in ${sourceOfVal}.`,
+        path: pathStr,
+        source: sourceOfVal,
+        kind: "type_conversion"
+      });
+      return new InvalidValue();
+    }
+    errors?.warnings.push(
+      `The option ${pathStr} is stated as a number but is provided as a string`
+    );
+    return parseVal;
+  }
+  errors?.errors.push({
+    message: `Invalid state. Invalid kind in ${sourceOfVal}`,
+    source: sourceOfVal,
+    kind: "invalid_state"
+  });
+  return new InvalidValue();
+}
+function formatFileLocation(file, loc) {
+  if (!loc) return file;
+  return `${file}:${loc.line}:${loc.column}`;
+}
 var OptionBase = class {
   params;
   constructor(params) {
     this.params = params;
   }
-  getValue(sourceFile, env, args, path, defaultValues, objectFromArray) {
-    const ident = path.join(".");
+  getValue(sourceFile, env, args, path2, defaultValues, objectFromArray, envFileResults, errors) {
+    const ident = path2.join(".");
     if (this.params.cli && args) {
       if (ident in args) {
         return new configNode_default(
-          this.checkType(args[ident], path, "args"),
+          this.checkType(args[ident], path2, "args", errors),
           ident,
           "args",
           null,
@@ -118,8 +287,25 @@ var OptionBase = class {
       if (this.params.env in env) {
         const val = env[this.params.env];
         if (val) {
+          const envFileSource = findEnvFileSource(
+            this.params.env,
+            val,
+            envFileResults
+          );
+          if (envFileSource) {
+            return new configNode_default(
+              this.checkType(val, path2, "envFile", errors),
+              ident,
+              "envFile",
+              envFileSource.filePath,
+              this.params.env,
+              null,
+              envFileSource.line,
+              envFileSource.column
+            );
+          }
           return new configNode_default(
-            this.checkType(val, path, "env"),
+            this.checkType(val, path2, "env", errors),
             ident,
             "env",
             null,
@@ -130,88 +316,52 @@ var OptionBase = class {
       }
     }
     if (typeof sourceFile === "string") {
-      const data = import_js_yaml.default.load(
-        fs.readFileSync(sourceFile, "utf-8")
+      const { data, sourceMap } = loadConfigFile(sourceFile);
+      const node = this.resolveFromFileData(
+        data || {},
+        sourceFile,
+        sourceMap,
+        path2,
+        ident,
+        errors
       );
-      const val = this.findInObject(data || {}, path);
-      if (val instanceof arrayOption_default) {
-        return new configNode_default(
-          this.checkType(val, path, sourceFile),
-          ident,
-          "file",
-          sourceFile,
-          null,
-          null
-        );
-      }
-      if (!valueIsInvalid(val)) {
-        return new configNode_default(
-          this.checkType(val, path, sourceFile),
-          ident,
-          "file",
-          sourceFile,
-          null,
-          null
-        );
-      }
+      if (node) return node;
     }
     if (Array.isArray(sourceFile)) {
       for (let index = 0; index < sourceFile.length; index += 1) {
         const file = sourceFile[index];
-        const data = import_js_yaml.default.load(
-          fs.readFileSync(file, "utf-8")
+        const { data, sourceMap } = loadConfigFile(file);
+        const node = this.resolveFromFileData(
+          data || {},
+          file,
+          sourceMap,
+          path2,
+          ident,
+          errors
         );
-        const val = this.findInObject(data || {}, path);
-        if (val instanceof arrayOption_default) {
-          return new configNode_default(
-            this.checkType(val, path, file),
-            ident,
-            "file",
-            file,
-            null,
-            null
-          );
-        }
-        if (!valueIsInvalid(val)) {
-          return new configNode_default(
-            this.checkType(val, path, file),
-            ident,
-            "file",
-            file,
-            null,
-            null
-          );
-        }
+        if (node) return node;
       }
     }
     if (objectFromArray) {
-      const val = this.findInObject(objectFromArray.value, path);
-      if (val instanceof arrayOption_default) {
-        return new configNode_default(
-          this.checkType(val, path, objectFromArray.file),
-          ident,
-          "file",
-          objectFromArray.file,
-          null,
-          null
-        );
-      }
-      if (!valueIsInvalid(val)) {
-        return new configNode_default(
-          this.checkType(val, path, objectFromArray.file),
-          ident,
-          "file",
-          objectFromArray.file,
-          null,
-          null
-        );
-      }
+      const node = this.resolveFromFileData(
+        objectFromArray.value,
+        objectFromArray.file,
+        objectFromArray.sourceMap ?? null,
+        path2,
+        ident,
+        errors
+      );
+      if (node) return node;
     }
     if (defaultValues) {
-      const val = this.findInObject(defaultValues, path);
+      const val = this.findInObject(
+        defaultValues,
+        path2,
+        errors
+      );
       if (val instanceof arrayOption_default) {
         return new configNode_default(
-          this.checkType(val, path, "default"),
+          this.checkType(val, path2, "default", errors),
           ident,
           "default",
           null,
@@ -221,7 +371,7 @@ var OptionBase = class {
       }
       if (!valueIsInvalid(val)) {
         return new configNode_default(
-          this.checkType(val, path, "default"),
+          this.checkType(val, path2, "default", errors),
           ident,
           "default",
           null,
@@ -232,17 +382,18 @@ var OptionBase = class {
     }
     if (this.params.defaultValue !== void 0) {
       let defaultValue;
-      if (typeof this.params.defaultValue === "function") {
-        defaultValue = this.params.defaultValue();
+      const rawDefault = this.params.defaultValue;
+      if (typeof rawDefault === "function") {
+        defaultValue = rawDefault();
       } else {
-        defaultValue = this.params.defaultValue;
+        defaultValue = rawDefault;
       }
       if (this.params.kind === "array" && Array.isArray(defaultValue)) {
-        defaultValue = this.buildArrayOption(defaultValue);
+        defaultValue = this.buildArrayOption(defaultValue, errors);
       }
       if (!valueIsInvalid(defaultValue)) {
         return new configNode_default(
-          this.checkType(defaultValue, path, "default"),
+          this.checkType(defaultValue, path2, "default", errors),
           ident,
           "default",
           null,
@@ -252,32 +403,39 @@ var OptionBase = class {
       }
     }
     if (this.params.required) {
-      OptionErrors.errors.push(`Required option '${ident}' not provided.`);
+      errors?.errors.push({
+        message: `Required option '${ident}' not provided.`,
+        path: ident,
+        kind: "required"
+      });
     }
     return null;
   }
-  // eslint-disable-next-line class-methods-use-this
-  checkNumberType(val, pathStr, sourceOfVal) {
-    if (typeof val === "string") {
-      const parseVal = parseInt(val, 10);
-      if (Number.isNaN(parseVal)) {
-        OptionErrors.errors.push(
-          `Cannot convert value '${val}' for '${pathStr}' to number in ${sourceOfVal}.`
-        );
-        return new InvalidValue();
-      }
-      OptionErrors.warnings.push(
-        `The option ${pathStr} is stated as a number but is provided as a string`
+  resolveFromFileData(data, file, sourceMap, path2, ident, errors) {
+    const val = this.findInObject(data, path2, errors);
+    const loc = lookupLocation(sourceMap, path2);
+    if (val instanceof arrayOption_default || !valueIsInvalid(val)) {
+      return new configNode_default(
+        this.checkType(val, path2, formatFileLocation(file, loc), errors),
+        ident,
+        "file",
+        file,
+        null,
+        null,
+        loc?.line ?? null,
+        loc?.column ?? null
       );
-      return parseVal;
     }
-    OptionErrors.errors.push(`Invalid state. Invalid kind in ${sourceOfVal}`);
-    return new InvalidValue();
+    return null;
   }
-  checkType(val, path, sourceOfVal) {
-    const ident = path.join(".");
+  checkType(val, path2, sourceOfVal, errors) {
+    const ident = path2.join(".");
     if (valueIsInvalid(val)) {
-      OptionErrors.errors.push(`Invalid state. Invalid kind in ${sourceOfVal}`);
+      errors?.errors.push({
+        message: `Invalid state. Invalid kind in ${sourceOfVal}`,
+        source: sourceOfVal,
+        kind: "invalid_state"
+      });
       return val;
     }
     if (typeof val === this.params.kind) {
@@ -285,14 +443,19 @@ var OptionBase = class {
     }
     if (this.params.kind === "string") {
       if (typeof val === "number") {
-        OptionErrors.warnings.push(
+        errors?.warnings.push(
           `The option ${ident} is stated as a string but is provided as a number`
         );
         return val.toString();
       }
-      OptionErrors.errors.push(
-        `Cannot convert value '${val.toString()}' for '${ident}' to string in ${sourceOfVal}.`
-      );
+      errors?.errors.push({
+        message: `Cannot convert value '${valueToString(
+          val
+        )}' for '${ident}' to string in ${sourceOfVal}.`,
+        path: ident,
+        source: sourceOfVal,
+        kind: "type_conversion"
+      });
       return new InvalidValue();
     }
     if (this.params.kind === "boolean") {
@@ -304,73 +467,106 @@ var OptionBase = class {
           return false;
         }
       }
-      OptionErrors.errors.push(
-        `Cannot convert value '${val.toString()}' for '${ident}' to boolean in ${sourceOfVal}.`
-      );
+      errors?.errors.push({
+        message: `Cannot convert value '${valueToString(
+          val
+        )}' for '${ident}' to boolean in ${sourceOfVal}.`,
+        path: ident,
+        source: sourceOfVal,
+        kind: "type_conversion"
+      });
       return new InvalidValue();
     }
     if (this.params.kind === "number") {
-      return this.checkNumberType(val, ident, sourceOfVal);
+      return checkNumberType(val, ident, sourceOfVal, errors);
     }
-    if (this.params.kind === "any") {
-      return val;
-    }
-    OptionErrors.errors.push(`Invalid state. Invalid kind in ${sourceOfVal}`);
+    errors?.errors.push({
+      message: `Invalid state. Invalid kind in ${sourceOfVal}`,
+      source: sourceOfVal,
+      kind: "invalid_state"
+    });
     throw new Error(
-      "Invalid kind. Must be 'string', 'number', 'boolean', 'array' or 'any'"
+      "Invalid kind. Must be 'string', 'number', 'boolean' or 'array'"
     );
   }
-  findInObject(obj, path) {
-    if (path.length > 1) {
-      const [child, ...rest] = path;
+  findInObject(obj, path2, errors) {
+    if (path2.length > 1) {
+      const [child, ...rest] = path2;
       const val = obj[child];
       if (typeof val === "string") {
-        OptionErrors.errors.push(`Cant get path from string value '${val}'`);
+        errors?.errors.push({
+          message: `Cant get path from string value '${val}'`,
+          kind: "invalid_path"
+        });
         return new InvalidValue();
       }
       if (typeof val === "number") {
-        OptionErrors.errors.push(`Cant get path from number value '${val}'`);
+        errors?.errors.push({
+          message: `Cant get path from number value '${val}'`,
+          kind: "invalid_path"
+        });
         return new InvalidValue();
       }
       if (typeof val === "boolean") {
-        OptionErrors.errors.push(
-          `Cant get path from boolean value '${val.toString()}'`
-        );
+        errors?.errors.push({
+          message: `Cant get path from boolean value '${val.toString()}'`,
+          kind: "invalid_path"
+        });
         return new InvalidValue();
       }
       if (Array.isArray(val)) {
-        OptionErrors.errors.push(
-          `Cant get path from array value '${val.toString()}'`
-        );
+        errors?.errors.push({
+          message: `Cant get path from array value '${valueToString(val)}'`,
+          kind: "invalid_path"
+        });
         return new InvalidValue();
       }
       if (val == null) {
         return new InvalidValue();
       }
-      return this.findInObject(val, rest);
+      return this.findInObject(val, rest, errors);
     }
-    if (path.length === 1) {
-      const val = obj[path[0]];
+    if (path2.length === 1) {
+      const val = obj[path2[0]];
       if (!Array.isArray(val) && typeof val === "object" && val || typeof val === "string" || typeof val === "number" || typeof val === "boolean" || typeof val === "undefined") {
         return val;
       }
       if (Array.isArray(val)) {
-        return this.buildArrayOption(val);
+        return this.buildArrayOption(val, errors);
       }
-      OptionErrors.errors.push(
-        `Invalid path '${path.join(".")}': ${typeof val}`
-      );
+      errors?.errors.push({
+        message: `Invalid path '${path2.join(".")}': ${typeof val}`,
+        kind: "invalid_path"
+      });
       return new InvalidValue();
     }
-    OptionErrors.errors.push(`Invalid path '${path.join()}'`);
+    errors?.errors.push({
+      message: `Invalid path '${path2.join()}'`,
+      kind: "invalid_path"
+    });
     return new InvalidValue();
   }
   // eslint-disable-next-line class-methods-use-this
-  buildArrayOption(_val) {
+  buildArrayOption(_val, _errors) {
     return new InvalidValue();
   }
 };
 
+// src/option/object.ts
+var ObjectOption = class extends OptionBase {
+  item;
+  constructor(params) {
+    super({
+      kind: "object",
+      env: null,
+      cli: false,
+      help: "",
+      ...params
+    });
+    this.item = params.item;
+  }
+};
+
 // src/option/array.ts
 var ArrayOption = class extends OptionBase {
   item;
@@ -384,105 +580,186 @@ var ArrayOption = class extends OptionBase {
     });
     this.item = params.item;
   }
-  buildArrayOption(val) {
+  buildArrayOption(val, errors) {
     if (this.item === null) {
-      OptionErrors.errors.push(`Array item cannot be null`);
+      errors?.errors.push({
+        message: `Array item cannot be null`,
+        kind: "invalid_state"
+      });
       return new InvalidValue();
     }
     return new arrayOption_default(this.item, val);
   }
-  // eslint-disable-next-line class-methods-use-this
-  checkType(val, path, sourceOfVal) {
+  checkType(val, path2, sourceOfVal, errors) {
     if (val instanceof arrayOption_default) {
       val.val.forEach((v, i) => {
-        if (this.item instanceof OptionBase) {
-          this.item.checkType(v, [...path, i], sourceOfVal);
+        if (this.item instanceof OptionBase && !(this.item instanceof ObjectOption)) {
+          this.item.checkType(v, [...path2, i], sourceOfVal, errors);
         }
       });
       return val;
     }
-    OptionErrors.errors.push(`Invalid state. Invalid kind in ${sourceOfVal}`);
+    errors?.errors.push({
+      message: `Invalid state. Invalid kind in ${sourceOfVal}`,
+      source: sourceOfVal,
+      kind: "invalid_state"
+    });
     return new InvalidValue();
   }
 };
 
+// src/envFileLoader.ts
+var fs2 = __toESM(require("fs"));
+var envFileCache = /* @__PURE__ */ new Map();
+function loadEnvFile(filePath) {
+  const cached = envFileCache.get(filePath);
+  if (cached) return cached;
+  const content = fs2.readFileSync(filePath, "utf-8");
+  const entries = /* @__PURE__ */ new Map();
+  const lines = content.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    const raw = lines[i];
+    const trimmed = raw.trim();
+    if (trimmed === "" || trimmed.startsWith("#")) continue;
+    const eqIndex = trimmed.indexOf("=");
+    if (eqIndex === -1) continue;
+    const key = trimmed.slice(0, eqIndex).trim();
+    if (key === "") continue;
+    let value = trimmed.slice(eqIndex + 1).trim();
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.slice(1, -1);
+    }
+    const column = raw.indexOf(key) + 1;
+    entries.set(key, {
+      value,
+      line: i + 1,
+      column
+    });
+  }
+  const result = { entries, filePath };
+  envFileCache.set(filePath, result);
+  return result;
+}
+function clearEnvFileCache() {
+  envFileCache.clear();
+}
+
+// src/option/errors.ts
+var OptionErrors = class {
+  errors = [];
+  warnings = [];
+  clearAll() {
+    this.errors = [];
+    this.warnings = [];
+    clearFileCache();
+    clearEnvFileCache();
+  }
+};
+
 // src/option/primitive.ts
 var PrimitiveOption = class extends OptionBase {
 };
 
-// src/settings.ts
-var import_commander = require("commander");
-var fs2 = __toESM(require("fs"));
-
-// src/nodes/configNodeArray.ts
-var ConfigNodeArray = class {
-  arrayValues;
-  constructor(arrayValues) {
-    this.arrayValues = arrayValues;
+// src/sourceValidation.ts
+var fs3 = __toESM(require("fs"));
+function validateFiles(files, dir) {
+  if (files && dir)
+    throw new ConfigFileError("Dir and files are specified, choose one");
+  let sourceFile = [];
+  if (files) {
+    if (Array.isArray(files)) {
+      const result = [];
+      files.forEach((file) => {
+        if (!fs3.existsSync(file)) {
+          throw new ConfigFileError(`Invalid config file '${file}'`);
+        } else {
+          result.push(file);
+        }
+      });
+      sourceFile = result;
+    } else {
+      if (!fs3.existsSync(files)) {
+        throw new ConfigFileError(`Invalid config file '${files}'`);
+      }
+      sourceFile = files;
+    }
   }
-};
-var configNodeArray_default = ConfigNodeArray;
+  if (dir) {
+    if (!(fs3.existsSync(dir) && fs3.lstatSync(dir).isDirectory())) {
+      throw new ConfigFileError(`'${dir}' not exists or is not a dir`);
+    }
+    const filesInDirectory = fs3.readdirSync(dir).sort();
+    if (filesInDirectory.length === 0) {
+      throw new ConfigFileError(`Directory '${dir}' is empty`);
+    }
+    const result = [];
+    filesInDirectory.forEach((file) => {
+      result.push(`${dir}/${file}`);
+    });
+    sourceFile = result;
+  }
+  return sourceFile;
+}
+function loadEnvFiles(envFile, envData) {
+  const envFileResults = [];
+  if (!envFile) return { envFileResults, mergedEnvData: envData };
+  const envFiles = Array.isArray(envFile) ? envFile : [envFile];
+  for (const file of envFiles) {
+    if (!fs3.existsSync(file)) {
+      throw new ConfigFileError(`Invalid env file '${file}'`);
+    }
+    const result = loadEnvFile(file);
+    envFileResults.push(result);
+  }
+  const merged = {};
+  for (const result of envFileResults) {
+    for (const [key, entry] of result.entries) {
+      merged[key] = entry.value;
+    }
+  }
+  for (const [key, value] of Object.entries(envData)) {
+    if (value !== void 0) {
+      merged[key] = value;
+    }
+  }
+  return { envFileResults, mergedEnvData: merged };
+}
 
 // src/settings.ts
 var Settings = class {
   schema;
   sources;
+  errors = new OptionErrors();
   sourceFile = [];
   argsData = {};
   envData = {};
   optionsTree = {};
   defaultData = {};
+  envFileResults = [];
   program;
-  constructor(schema, sources) {
-    this.schema = schema;
+  constructor(schema2, sources) {
+    this.schema = schema2;
     this.sources = sources;
     this.program = new import_commander.Command().allowUnknownOption(true).allowExcessArguments(true);
     this.load();
   }
-  validateFiles() {
-    const { files, dir } = this.sources;
-    if (files && dir)
-      throw new Error("Dir and files are specified, choose one");
-    if (files) {
-      if (Array.isArray(files)) {
-        files.forEach((file) => {
-          if (!fs2.existsSync(file)) {
-            throw new Error(`Invalid config file '${file}'`);
-          } else {
-            if (!Array.isArray(this.sourceFile)) {
-              this.sourceFile = [];
-            }
-            this.sourceFile.push(file);
-          }
-        });
-      } else {
-        if (!fs2.existsSync(files)) {
-          throw new Error(`Invalid config file '${files}'`);
-        }
-        this.sourceFile = files;
-      }
-    }
-    if (dir) {
-      if (!(fs2.existsSync(dir) && fs2.lstatSync(dir).isDirectory())) {
-        throw new Error(`'${dir}' not exists or is not a dir`);
-      }
-      const filesInDirectory = fs2.readdirSync(dir).sort();
-      if (filesInDirectory.length === 0) {
-        throw new Error(`Directory '${dir}' is empty`);
-      }
-      filesInDirectory.forEach((file) => {
-        if (!Array.isArray(this.sourceFile)) {
-          this.sourceFile = [];
-        }
-        this.sourceFile.push(`${dir}/${file}`);
-      });
-    }
+  validateAndLoadFiles() {
+    this.sourceFile = validateFiles(this.sources.files, this.sources.dir);
+  }
+  loadAndMergeEnvFiles() {
+    const { envFileResults, mergedEnvData } = loadEnvFiles(
+      this.sources.envFile,
+      this.envData
+    );
+    this.envFileResults = envFileResults;
+    this.envData = mergedEnvData;
   }
   load() {
-    this.validateFiles();
+    this.validateAndLoadFiles();
     if (this.sources.env) {
-      this.envData = process.env;
+      this.envData = { ...process.env };
     }
+    this.loadAndMergeEnvFiles();
     if (this.sources.args) {
       this.traverseOptions(this.schema, [], this.addArg.bind(this));
       this.program.parse(process.argv);
@@ -498,44 +775,66 @@ var Settings = class {
         sourceFile: this.sourceFile,
         envData: this.envData,
         argsData: this.argsData,
-        defaultValue: this.defaultData
+        defaultValue: this.defaultData,
+        envFileResults: this.envFileResults,
+        errors: this.errors
       })
     );
-    if (OptionErrors.warnings.length > 0) {
-      for (let index = 0; index < OptionErrors.warnings.length; index += 1) {
-        console.warn(`[Warning]: ${OptionErrors.warnings[index]}`);
+    if (this.errors.warnings.length > 0) {
+      for (let index = 0; index < this.errors.warnings.length; index += 1) {
+        console.warn(`[Warning]: ${this.errors.warnings[index]}`);
       }
     }
-    if (OptionErrors.errors.length > 0) {
-      for (let index = 0; index < OptionErrors.errors.length; index += 1) {
-        console.error(`[Error]: ${OptionErrors.errors[index]}`);
+    if (this.errors.errors.length > 0) {
+      if (this.sources.exitOnError) {
+        for (let index = 0; index < this.errors.errors.length; index += 1) {
+          console.error(`[Error]: ${this.errors.errors[index].message}`);
+        }
+        process.exit(1);
       }
-      process.exit(1);
+      throw new ConfigLoadError(
+        [...this.errors.errors],
+        [...this.errors.warnings]
+      );
     }
   }
-  traverseOptions(node, path, callback) {
-    if (node instanceof OptionBase) {
-      callback(node, path);
+  traverseOptions(node, path2, callback) {
+    if (node instanceof ObjectOption) {
+      const item = node.item;
+      Object.keys(item).forEach((key) => {
+        this.traverseOptions(item[key], [...path2, key], callback);
+      });
+    } else if (node instanceof OptionBase) {
+      callback(node, path2);
     } else {
       Object.keys(node).forEach((key) => {
         const val = node[key];
-        this.traverseOptions(val, [...path, key], callback);
+        this.traverseOptions(val, [...path2, key], callback);
       });
     }
   }
-  buildOption(result, configData, node, path) {
-    const { sourceFile, envData, argsData, defaultValue, objectFromArray } = configData;
+  buildOption(result, configData, node, path2) {
+    const {
+      sourceFile = [],
+      envData = {},
+      argsData = {},
+      defaultValue = {},
+      objectFromArray,
+      envFileResults,
+      errors
+    } = configData;
     const value = node.getValue(
       sourceFile,
       envData,
       argsData,
-      path,
+      path2,
       defaultValue,
-      objectFromArray
+      objectFromArray,
+      envFileResults,
+      errors
     );
-    if (value === null) {
-    } else {
-      this.setOption(result, path, value);
+    if (value !== null) {
+      this.setOption(result, path2, value);
     }
   }
   getValidatedArray(item, values, file) {
@@ -548,27 +847,18 @@ var Settings = class {
       }
       if (item.params.kind === "boolean") {
         return values.map((v) => {
-          if (v === "true")
-            return true;
-          if (v === "1")
-            return true;
-          if (v === 1)
-            return true;
-          if (v === "false")
-            return false;
-          if (v === "0")
-            return false;
-          if (v === 0)
-            return false;
+          if (v === "true") return true;
+          if (v === "1") return true;
+          if (v === 1) return true;
+          if (v === "false") return false;
+          if (v === "0") return false;
+          if (v === 0) return false;
           return v;
         });
       }
     }
     const arrayValues = values.map(
-      (v) => (
-        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
-        this.processArrayWithSchema(item, v, file)
-      )
+      (v) => this.processArrayWithSchema(item, v, file)
     );
     return new configNodeArray_default(arrayValues);
   }
@@ -579,30 +869,34 @@ var Settings = class {
       [],
       this.buildOption.bind(this, result, {
         objectFromArray: {
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
           value: v,
           file
-        }
+        },
+        errors: this.errors
       })
     );
     return result;
   }
-  setOption(options, path, node) {
-    if (path.length > 1) {
-      const [child, ...rest] = path;
+  setOption(options, path2, node) {
+    if (path2.length > 1) {
+      const [child, ...rest] = path2;
       if (!options[child]) {
         options[child] = {};
       }
-      this.setOption(options[child], rest, node);
-    } else if (path.length === 1) {
-      const [child] = path;
+      this.setOption(
+        options[child],
+        rest,
+        node
+      );
+    } else if (path2.length === 1) {
+      const [child] = path2;
       if (node != null) {
         if (node.value instanceof arrayOption_default) {
           options[child] = node;
           options[child].value = this.getValidatedArray(
             node.value.item,
             node.value.val,
-            node.file || node.variable_name || node.arg_name || ""
+            node.file || node.variableName || node.argName || ""
           );
         } else {
           options[child] = node;
@@ -610,13 +904,13 @@ var Settings = class {
       }
     } else {
       throw new Error(
-        `Invalid path '${node.path}' getting from '${node.arg_name || node.file || node.variable_name || ""}' in ' ${node.source_type}`
+        `Invalid path '${node.path}' getting from '${node.argName || node.file || node.variableName || ""}' in ' ${node.sourceType}`
       );
     }
   }
-  addArg(node, path = []) {
+  addArg(node, path2 = []) {
     if (node.params.cli) {
-      const ident = path.join(".");
+      const ident = path2.join(".");
       this.program.option(`--${ident} <value>`, node.params.help);
     }
   }
@@ -637,7 +931,9 @@ var Settings = class {
     );
   }
   get() {
-    return this.getValuesFromTree(this.optionsTree);
+    return this.getValuesFromTree(
+      this.optionsTree
+    );
   }
   getExtended() {
     return this.optionsTree;
@@ -645,14 +941,28 @@ var Settings = class {
 };
 var settings_default = Settings;
 
+// src/builder/settings.ts
+var SettingsBuilder = class {
+  schema;
+  constructor(schema2) {
+    this.schema = schema2;
+  }
+  load(sources) {
+    const settings = new settings_default(this.schema, sources);
+    return settings.get();
+  }
+  loadExtended(sources) {
+    const settings = new settings_default(this.schema, sources);
+    return settings.getExtended();
+  }
+};
+
 // src/index.ts
-var src_default = settings_default;
 var DEFAULTS = {
   required: false,
   env: null,
   cli: false,
   help: ""
-  // properties: {},
 };
 var string = (opts) => {
   return new PrimitiveOption({
@@ -681,14 +991,26 @@ var array = (opts) => {
     ...opts
   });
 };
+var object = (opts) => {
+  return new ObjectOption({
+    required: false,
+    ...opts
+  });
+};
+var schema = (theSchema) => {
+  return new SettingsBuilder(theSchema);
+};
 var option = {
   string,
   number,
   bool,
-  // object,
-  array
+  array,
+  object,
+  schema
 };
+var index_default = option;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  option
+  ConfigFileError,
+  ConfigLoadError
 });