kfg 0.0.1 → 1.1.0

package/dist/index.cjs

@@ -0,0 +1,1200 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ConfigFS: () => ConfigFS,
+  ConfigJS: () => ConfigJS,
+  ConfigJSDriver: () => ConfigJSDriver,
+  FileFSConfigJS: () => FileFSConfigJS,
+  KFS_JOIN_SYMBOL: () => KFS_JOIN_SYMBOL,
+  KFS_MANY_SYMBOL: () => KFS_MANY_SYMBOL,
+  Kfg: () => Kfg,
+  KfgDriver: () => KfgDriver,
+  KfgFS: () => KfgFS,
+  KfgFileFS: () => KfgFileFS,
+  c: () => c,
+  cfs: () => cfs,
+  envDriver: () => envDriver,
+  jsonDriver: () => jsonDriver,
+  k: () => k,
+  kfs: () => kfs
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/kfg-fs.ts
+var fs = __toESM(require("fs"), 1);
+
+// src/utils/object.ts
+function getProperty(obj, path3) {
+  return path3.split(".").reduce((acc, key) => acc?.[key], obj);
+}
+function setProperty(obj, path3, value) {
+  const keys = path3.split(".");
+  const lastKey = keys.pop();
+  let target = obj;
+  for (const key of keys) {
+    if (target[key] === void 0 || target[key] === null) {
+      target[key] = {};
+    } else if (typeof target[key] !== "object") {
+      throw new Error(`Cannot set property on non-object at path: ${key}`);
+    }
+    target = target[key];
+  }
+  target[lastKey] = value;
+}
+function isObject(item) {
+  return item !== null && typeof item === "object" && !Array.isArray(item);
+}
+function deepMerge(target, source) {
+  const output = { ...target };
+  if (isObject(target) && isObject(source)) {
+    Object.keys(source).forEach((key) => {
+      const sourceValue = source[key];
+      const targetValue = target[key];
+      if (isObject(sourceValue) && isObject(targetValue)) {
+        output[key] = deepMerge(
+          targetValue,
+          sourceValue
+        );
+      } else {
+        output[key] = sourceValue;
+      }
+    });
+  }
+  return output;
+}
+function flattenObject(obj, prefix = "") {
+  return Object.keys(obj).reduce(
+    (acc, k2) => {
+      const pre = prefix.length ? `${prefix}.` : "";
+      if (isObject(obj[k2])) {
+        Object.assign(acc, flattenObject(obj[k2], pre + k2));
+      } else {
+        acc[pre + k2] = obj[k2];
+      }
+      return acc;
+    },
+    {}
+  );
+}
+function unflattenObject(obj) {
+  const result = {};
+  for (const key in obj) {
+    setProperty(result, key, obj[key]);
+  }
+  return result;
+}
+function deleteProperty(obj, path3) {
+  const keys = path3.split(".");
+  const lastKey = keys.pop();
+  let target = obj;
+  for (const key of keys) {
+    if (target?.[key] === void 0) {
+      return false;
+    }
+    target = target[key];
+  }
+  if (typeof target === "object" && target !== null) {
+    return delete target[lastKey];
+  }
+  return false;
+}
+
+// src/utils/schema.ts
+var import_typebox = require("@sinclair/typebox");
+var import_value = require("@sinclair/typebox/value");
+function addSmartDefaults(schemaNode) {
+  if (schemaNode.type !== "object" || !schemaNode.properties) {
+    return;
+  }
+  let allChildrenOptional = true;
+  for (const key in schemaNode.properties) {
+    const prop = schemaNode.properties[key];
+    if (prop[Symbol.for("TypeBox.Kind")] === "Unsafe") {
+      continue;
+    }
+    if (prop.type === "object" && prop[Symbol.for("TypeBox.Kind")]) {
+      addSmartDefaults(prop);
+    }
+    const hasDefault = prop.default !== void 0;
+    const isOptional = import_value.Value.Check(import_typebox.Type.Object({ temp: prop }), {});
+    if (!hasDefault && !isOptional) {
+      allChildrenOptional = false;
+    }
+  }
+  if (allChildrenOptional && schemaNode.default === void 0) {
+    schemaNode.default = {};
+  }
+}
+function buildTypeBoxSchema(definition) {
+  if (definition[Symbol.for("TypeBox.Kind")] === "Object") {
+    return definition;
+  }
+  const properties = {};
+  for (const key in definition) {
+    const value = definition[key];
+    const isObject2 = typeof value === "object" && value !== null && !value[Symbol.for("TypeBox.Kind")];
+    if (isObject2) {
+      properties[key] = buildTypeBoxSchema(value);
+    } else {
+      properties[key] = value;
+    }
+  }
+  return import_typebox.Type.Object(properties, { additionalProperties: true });
+}
+function buildDefaultObject(definition) {
+  const schema = buildTypeBoxSchema(definition);
+  addSmartDefaults(schema);
+  return import_value.Value.Default(schema, {});
+}
+function makeSchemaOptional(definition) {
+  const newDefinition = {};
+  for (const key in definition) {
+    const value = definition[key];
+    if (value?.[Symbol.for("TypeBox.Kind")]) {
+      const schema = value;
+      const isOptional = import_value.Value.Check(import_typebox.Type.Object({ temp: schema }), {});
+      if (schema.important || isOptional) {
+        newDefinition[key] = schema;
+      } else {
+        newDefinition[key] = import_typebox.Type.Optional(schema);
+      }
+    } else if (typeof value === "object" && value !== null) {
+      newDefinition[key] = makeSchemaOptional(value);
+    } else {
+      newDefinition[key] = value;
+    }
+  }
+  return newDefinition;
+}
+
+// src/kfg.ts
+var Kfg = class {
+  driver;
+  schema;
+  loaded = false;
+  _lastOptions;
+  /**
+   * Creates a new instance of Kfg.
+   * @param driver The driver to use for loading and saving the configuration.
+   * @param schema The schema to use for validating the configuration.
+   */
+  constructor(driver, schema) {
+    this.driver = driver.clone();
+    this.schema = schema;
+  }
+  /**
+   * Reloads the configuration.
+   * @param options - The loading options.
+   */
+  reload(options) {
+    this.loaded = false;
+    return this.load(options || this._lastOptions);
+  }
+  /**
+   * Loads the configuration.
+   * @param options - The loading options.
+   */
+  load(options) {
+    this._lastOptions = options;
+    let schemaToLoad = this.schema;
+    if (options?.only_importants) {
+      schemaToLoad = makeSchemaOptional(this.schema);
+    }
+    const result = this.driver.load(schemaToLoad, options);
+    if (this.driver.async) {
+      return result.then(() => {
+        this.loaded = true;
+      });
+    }
+    this.loaded = true;
+    return result;
+  }
+  /**
+   * Gets a value from the configuration.
+   * @param path The path to the value.
+   * @returns The value at the given path.
+   */
+  get(path3) {
+    if (!this.loaded) {
+      throw new Error("[Kfg] Config not loaded. Call load() first.");
+    }
+    return this.driver.get(path3);
+  }
+  /**
+   * Checks if a value exists in the configuration.
+   * @param paths The paths to the values.
+   * @returns True if all values exist, false otherwise.
+   */
+  has(...paths) {
+    if (!this.loaded) {
+      throw new Error("[Kfg] Config not loaded. Call load() first.");
+    }
+    return this.driver.has(...paths);
+  }
+  /**
+   * Gets a value from the configuration.
+   * @param path The path to the value.
+   * @returns The value at the given path.
+   */
+  root(path3) {
+    if (!this.loaded) {
+      throw new Error("[Kfg] Config not loaded. Call load() first.");
+    }
+    return this.driver.get(path3);
+  }
+  /**
+   * Sets a value in the configuration.
+   * @param path The path to the value.
+   * @param value The new value.
+   * @param options The options for setting the value.
+   */
+  set(path3, value, options) {
+    if (!this.loaded) {
+      throw new Error("[Kfg] Config not loaded. Call load() first.");
+    }
+    return this.driver.set(path3, value, options);
+  }
+  /**
+   * Inserts a partial value into an object in the configuration.
+   * @param path The path to the object.
+   * @param partial The partial value to insert.
+   */
+  insert(path3, partial) {
+    if (!this.loaded) {
+      throw new Error("[Kfg] Config not loaded. Call load() first.");
+    }
+    return this.driver.insert(path3, partial);
+  }
+  /**
+   * Injects a partial value directly into the root configuration object.
+   * @param data The partial data to inject.
+   */
+  inject(data) {
+    if (!this.loaded) {
+      throw new Error("[Kfg] Config not loaded. Call load() first.");
+    }
+    return this.driver.inject(data);
+  }
+  /**
+   * Deletes a value from the configuration.
+   * @param path The path to the value.
+   */
+  del(path3) {
+    if (!this.loaded) {
+      throw new Error("[Kfg] Config not loaded. Call load() first.");
+    }
+    return this.driver.del(path3);
+  }
+  /**
+   * Gets the schema for a given path.
+   * @param path The path to the schema.
+   * @returns The schema at the given path.
+   */
+  conf(path3) {
+    if (!this.loaded) {
+      throw new Error("[Kfg] Config not loaded. Call load() first.");
+    }
+    return getProperty(this.schema, path3);
+  }
+  /**
+   * Returns the schema definition for a given path.
+   * @param path The path to the schema.
+   * @returns The schema at the given path.
+   */
+  schematic(path3) {
+    return this.conf(path3);
+  }
+  /**
+   * Returns cached data
+   * @returns
+   */
+  async toJSON() {
+    if (!this.loaded) {
+      throw new Error("[Kfg] Config not loaded. Call load() first.");
+    }
+    if (this.driver.async) {
+      return Promise.resolve(this.driver.data);
+    }
+    return this.driver.data;
+  }
+};
+
+// src/fs-factory.ts
+var import_typebox2 = require("@sinclair/typebox");
+var KFS_MANY_SYMBOL = Symbol.for("Kfg.many");
+var KFS_JOIN_SYMBOL = Symbol.for("Kfg.join");
+var _cfs = {
+  /**
+   * Creates a many-to-many relation in a schema.
+   * @param kfgFs The KfgFS instance to relate to.
+   * @param options The schema options.
+   */
+  many: (kfgFs, options) => import_typebox2.Type.Unsafe(
+    import_typebox2.Type.Array(import_typebox2.Type.String(), {
+      ...options,
+      [KFS_MANY_SYMBOL]: {
+        kfgFs
+      }
+    })
+  ),
+  join: (kfgFs, options) => import_typebox2.Type.Unsafe(
+    import_typebox2.Type.Object(
+      {},
+      {
+        ...options,
+        [KFS_JOIN_SYMBOL]: {
+          kfgFs,
+          fk: options?.fk
+        }
+      }
+    )
+  )
+};
+var cfs = {
+  ..._cfs
+};
+var kfs = cfs;
+
+// src/kfg-fs.ts
+var KfgFileFS = class extends Kfg {
+  /**
+   * Creates a new instance of KfgFileFS.
+   * @param driver The driver to use for loading and saving the configuration.
+   * @param schema The schema to use for validating the configuration.
+   * @param filePath The path to the configuration file.
+   */
+  constructor(driver, schema, filePath) {
+    super(driver, schema);
+    this.filePath = filePath;
+  }
+  /**
+   * Loads the configuration from the file.
+   * @param options The loading options.
+   */
+  load(options) {
+    const loadOptions = { ...options, path: this.filePath };
+    return super.load(loadOptions);
+  }
+  /**
+   * Sets a value in the configuration.
+   * @param path The path to the value.
+   * @param value The new value.
+   * @param options The options for setting the value.
+   */
+  //@ts-ignore KfgFS change internal logic of Kfg, ignore this
+  set(path3, value, options) {
+    return super.set(path3, value, options);
+  }
+  /**
+   * Inserts a partial value into an object in the configuration.
+   * @param path The path to the object.
+   * @param partial The partial value to insert.
+   */
+  //@ts-ignore KfgFS change internal logic of Kfg, ignore this
+  insert(path3, value) {
+    return super.insert(path3, value);
+  }
+  /**
+   * Gets a value from the configuration.
+   * @param path The path to the value.
+   * @returns The value at the given path.
+   */
+  //@ts-ignore KfgFS change internal logic of Kfg, ignore this
+  root(path3) {
+    return super.root(path3);
+  }
+  /**
+   * Checks if a value exists in the configuration.
+   * @param paths The paths to the values.
+   * @returns True if all values exist, false otherwise.
+   */
+  has(...paths) {
+    return super.has(...paths);
+  }
+  /**
+   * Gets the schema for a given path.
+   * @param path The path to the schema.
+   * @returns The schema at the given path.
+   */
+  conf(path3) {
+    return super.conf(path3);
+  }
+  /**
+   * Returns cached data
+   * @returns
+   */
+  //@ts-ignore more recursive types, ignore
+  toJSON() {
+    return super.toJSON();
+  }
+  /**
+   * Saves the configuration to the file.
+   */
+  save() {
+    return this.driver.set(null, this.driver.data);
+  }
+  /**
+   * Gets the related configurations for a many-to-many relation.
+   * @param path The path to the relation.
+   * @returns An array of related configurations.
+   */
+  getMany(path3) {
+    const schema = this.conf(path3);
+    const manyInfo = schema[KFS_MANY_SYMBOL];
+    if (!manyInfo) {
+      throw new Error(`[KfgFS] '${path3}' is not a many-relation field.`);
+    }
+    const ids = this.get(path3);
+    if (!ids || !Array.isArray(ids)) {
+      return void 0;
+    }
+    const related = manyInfo.kfgFs;
+    const files = ids.map((id) => related.file(id));
+    if (this.driver.async) {
+      return Promise.all(files);
+    }
+    return files;
+  }
+  /**
+   * Gets the related configuration for a one-to-one relation.
+   * @param path The path to the relation.
+   * @returns The related configuration.
+   */
+  getJoin(path3) {
+    const schema = this.conf(path3);
+    const joinInfo = schema[KFS_JOIN_SYMBOL];
+    if (!joinInfo) {
+      throw new Error(`[KfgFS] '${path3}' is not a join-relation field.`);
+    }
+    const fkValue = this.get(joinInfo.fk);
+    if (!fkValue) {
+      return void 0;
+    }
+    const related = joinInfo.kfgFs;
+    const instance = related.file(fkValue);
+    if (this.driver.async) {
+      return instance.then(
+        async (instance2) => {
+          await instance2.load();
+          return instance2;
+        }
+      );
+    }
+    const loadedInstance = instance;
+    loadedInstance.load();
+    return loadedInstance;
+  }
+  /**
+   * Returns the file path of the configuration.
+   */
+  toString() {
+    return this.filePath;
+  }
+};
+var KfgFS = class {
+  /**
+   * Creates a new instance of KfgFS.
+   * @param driver The driver to use for loading and saving the configurations.
+   * @param schema The schema to use for validating the configurations.
+   * @param config The configuration options.
+   */
+  constructor(driver, schema, config) {
+    this.driver = driver;
+    this.schema = schema;
+    this.config = config;
+  }
+  pathFn;
+  /**
+   * Initializes the KfgFS instance with a path function.
+   * @param pathFn A function that returns the file path for a given ID.
+   */
+  init(pathFn) {
+    this.pathFn = pathFn;
+  }
+  /**
+   * Gets the file path for a given ID.
+   * @param id The ID of the configuration file.
+   * @returns The file path.
+   */
+  getPath(id) {
+    if (!this.pathFn) {
+      throw new Error(
+        "[KfgFS] KfgFS not initialized. Call init() first."
+      );
+    }
+    return this.pathFn(id);
+  }
+  /**
+   * Checks if a configuration file exists for a given ID.
+   * @param id The ID of the configuration file.
+   * @returns True if the file exists, false otherwise.
+   */
+  exist(id) {
+    const filePath = this.getPath(id);
+    return fs.existsSync(filePath);
+  }
+  /**
+   * Creates a new configuration file for a given ID.
+   * @param id The ID of the configuration file.
+   * @param data Optional initial data for the configuration.
+   * @returns The created KfgFileFS instance.
+   */
+  create(id, data) {
+    if (this.exist(id)) {
+      throw new Error(`[KfgFS] Config with id '${id}' already exists.`);
+    }
+    const instanceOrPromise = this.file(id);
+    const initialize = (instance) => {
+      if (data) {
+        instance.inject(data);
+      }
+      const saveResult = instance.save();
+      if (this.driver.async) {
+        return saveResult.then(() => instance);
+      }
+      return instance;
+    };
+    if (this.driver.async) {
+      return instanceOrPromise.then(
+        initialize
+      );
+    } else {
+      return initialize(instanceOrPromise);
+    }
+  }
+  /**
+   * Gets a file-based configuration for a given ID.
+   * @param id The ID of the configuration file.
+   * @returns A KfgFileFS instance.
+   */
+  file(id) {
+    const filePath = this.getPath(id);
+    const newDriver = new this.driver.constructor(
+      this.driver.options
+    );
+    const fileInstance = new KfgFileFS(newDriver, this.schema, filePath);
+    const loadResult = fileInstance.load(this.config);
+    if (this.driver.async) {
+      return loadResult.then(
+        () => fileInstance
+      );
+    }
+    return fileInstance;
+  }
+  /**
+   * Deletes a configuration file.
+   * @param id The ID of the configuration file.
+   */
+  del(id) {
+    const filePath = this.getPath(id);
+    if (fs.existsSync(filePath)) {
+      fs.unlinkSync(filePath);
+    }
+  }
+  /**
+   * Copies a configuration file.
+   * @param fromId The ID of the source configuration file.
+   * @param toId The ID of the destination configuration file.
+   */
+  copy(fromId, toId) {
+    const fromPath = this.getPath(fromId);
+    const toPath = this.getPath(toId);
+    fs.copyFileSync(fromPath, toPath);
+  }
+  /**
+   * Gets the configuration data for a given ID.
+   * @param id The ID of the configuration file.
+   * @returns The configuration data.
+   */
+  toJSON(id) {
+    const fileInstance = this.file(id);
+    if (fileInstance instanceof Promise) {
+      return fileInstance.then((i) => i.toJSON());
+    } else {
+      return fileInstance.toJSON();
+    }
+  }
+};
+
+// src/kfg-driver.ts
+var import_value2 = require("@sinclair/typebox/value");
+var KfgDriver = class {
+  /**
+   * Creates a new instance of KfgDriver.
+   * @param options The driver options.
+   */
+  constructor(options) {
+    this.options = options;
+    this.identify = options.identify;
+    this.async = options.async;
+    this.config = options.config || {};
+    this._onLoad = options.onLoad;
+    this._onSet = options.onSet;
+    this._onDel = options.onDel;
+  }
+  identify;
+  async = void 0;
+  config;
+  data = {};
+  comments;
+  compiledSchema;
+  store = {};
+  _onSet;
+  _onDel;
+  // Utilities passed to drivers
+  buildDefaultObject = buildDefaultObject;
+  deepMerge = deepMerge;
+  /**
+   * Clones the driver.
+   * @returns A new instance of the driver with the same options.
+   */
+  clone() {
+    const Constructor = this.constructor;
+    return new Constructor(this.options);
+  }
+  /**
+   * Injects data directly into the driver's data store.
+   * This data is merged with the existing data.
+   * @param data The data to inject.
+   */
+  inject(data) {
+    this.data = this.deepMerge(this.data, data);
+    return this.async ? Promise.resolve() : void 0;
+  }
+  /**
+   * Loads the configuration.
+   * @param schema The schema to use for validating the configuration.
+   * @param options The loading options.
+   */
+  load(schema, options = {}) {
+    this.compiledSchema = buildTypeBoxSchema(schema);
+    addSmartDefaults(this.compiledSchema);
+    this.config = { ...this.config, ...options };
+    const processResult = (result) => {
+      this.data = result;
+      this.validate(this.data);
+    };
+    if (this._onLoad) {
+      const loadResult = this._onLoad.call(this, schema, this.config);
+      if (this.async) {
+        return loadResult.then(processResult);
+      }
+      processResult(loadResult);
+    }
+    return void 0;
+  }
+  /**
+   * Gets a value from the configuration.
+   * @param path The path to the value.
+   * @returns The value at the given path.
+   */
+  get(path3) {
+    const value = getProperty(this.data, path3);
+    if (this.async) {
+      return Promise.resolve(value);
+    }
+    return value;
+  }
+  /**
+   * Checks if a value exists in the configuration.
+   * @param paths The paths to the values.
+   * @returns True if all values exist, false otherwise.
+   */
+  has(...paths) {
+    const hasAllProps = paths.every(
+      (path3) => getProperty(this.data, path3) !== void 0
+    );
+    if (this.async) {
+      return Promise.resolve(hasAllProps);
+    }
+    return hasAllProps;
+  }
+  /**
+   * Sets a value in the configuration.
+   * @param path The path to the value.
+   * @param value The new value.
+   * @param options The options for setting the value.
+   */
+  set(path3, value, options) {
+    if (path3) {
+      setProperty(this.data, path3, value);
+    }
+    if (this._onSet) {
+      return this._onSet.call(this, path3, value, options);
+    }
+    return this.async ? Promise.resolve() : void 0;
+  }
+  /**
+   * Inserts a partial value into an object in the configuration.
+   * @param path The path to the object.
+   * @param partial The partial value to insert.
+   */
+  insert(path3, partial) {
+    const currentObject = getProperty(this.data, path3);
+    if (typeof currentObject !== "object" || currentObject === null) {
+      throw new Error(`Cannot insert into non-object at path: ${path3}`);
+    }
+    Object.assign(currentObject, partial);
+    return this.set(path3, currentObject);
+  }
+  /**
+   * Deletes a value from the configuration.
+   * @param path The path to the value.
+   */
+  del(path3) {
+    deleteProperty(this.data, path3);
+    if (this._onDel) {
+      return this._onDel.call(this, path3);
+    }
+    return this.async ? Promise.resolve() : void 0;
+  }
+  /**
+   * Validates the configuration against the schema.
+   * @param config The configuration to validate.
+   */
+  validate(config = this.data) {
+    if (!this.compiledSchema) return;
+    const configWithDefaults = import_value2.Value.Default(this.compiledSchema, config);
+    import_value2.Value.Convert(this.compiledSchema, configWithDefaults);
+    if (!import_value2.Value.Check(this.compiledSchema, configWithDefaults)) {
+      const errors = [...import_value2.Value.Errors(this.compiledSchema, configWithDefaults)];
+      throw new Error(
+        `[Kfg] Validation failed:
+${errors.map((e) => `- ${e.path}: ${e.message}`).join("\n")}`
+        // Corrected: escaped backtick in template literal
+      );
+    }
+    this.data = configWithDefaults;
+  }
+};
+
+// src/old.ts
+var ConfigJS = Kfg;
+var ConfigFS = KfgFS;
+var FileFSConfigJS = KfgFileFS;
+var ConfigJSDriver = KfgDriver;
+
+// src/drivers/env-driver.ts
+var fs2 = __toESM(require("fs"), 1);
+var path = __toESM(require("path"), 1);
+
+// src/utils/env.ts
+function parse(content) {
+  const result = {};
+  const lines = content.split(/\r?\n/);
+  for (const line of lines) {
+    const trimmedLine = line.trim();
+    if (!trimmedLine || trimmedLine.startsWith("#")) {
+      continue;
+    }
+    const match = trimmedLine.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*=\s*(.*)$/);
+    if (!match) continue;
+    const [, key, rawValue] = match;
+    let value = rawValue.trim();
+    if (!value.startsWith('"') && !value.startsWith("'")) {
+      const commentIndex = value.indexOf("#");
+      if (commentIndex > -1) {
+        value = value.substring(0, commentIndex).trim();
+      }
+    }
+    if (value.startsWith("'") && value.endsWith("'")) {
+      value = value.substring(1, value.length - 1);
+    } else if (value.startsWith('"') && value.endsWith('"')) {
+      value = value.substring(1, value.length - 1);
+    }
+    result[key] = value;
+  }
+  return result;
+}
+function updateEnvContent(content, key, value, description) {
+  const lines = content.split(/\r?\n/);
+  let keyFound = false;
+  const newLines = [...lines];
+  let formattedValue;
+  if (Array.isArray(value)) {
+    formattedValue = JSON.stringify(value);
+  } else {
+    const stringValue = String(value);
+    formattedValue = /[\s"'#]/.test(stringValue) ? `"${stringValue.replace(/"/g, '"').replace(/\n/g, "\\n")}"` : stringValue;
+  }
+  let lineIndex = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (new RegExp(`^s*${key}s*=s*`).test(lines[i])) {
+      keyFound = true;
+      lineIndex = i;
+      break;
+    }
+  }
+  if (keyFound) {
+    newLines[lineIndex] = `${key}=${formattedValue}`;
+    if (description) {
+      const comment = `# ${description}`;
+      if (lineIndex === 0 || !newLines[lineIndex - 1].trim().startsWith(comment)) {
+        if (lineIndex > 0 && !newLines[lineIndex - 1].trim().startsWith("#")) {
+          newLines.splice(lineIndex, 0, comment);
+        }
+      }
+    }
+  } else {
+    if (newLines[newLines.length - 1] !== "") {
+      newLines.push("");
+    }
+    if (description) {
+      newLines.push(`# ${description}`);
+    }
+    newLines.push(`${key}=${formattedValue}`);
+  }
+  return newLines.join("\n");
+}
+function removeEnvKey(content, key) {
+  const lines = content.split(/\r?\n/);
+  const keyRegex = new RegExp(`^\\s*${key}\\s*=\\s*`);
+  const newLines = [];
+  for (const line of lines) {
+    if (keyRegex.test(line)) {
+      if (newLines.length > 0 && newLines[newLines.length - 1].trim().startsWith("#")) {
+        newLines.pop();
+      }
+    } else {
+      newLines.push(line);
+    }
+  }
+  return newLines.join("\n");
+}
+
+// src/drivers/env-driver.ts
+function getFilePath(config) {
+  return path.resolve(process.cwd(), config.path || ".env");
+}
+function coerceType(value, schema) {
+  if (value === void 0) return void 0;
+  const type = schema.type;
+  if (type === "number") return Number(value);
+  if (type === "boolean") return String(value).toLowerCase() === "true";
+  if (type === "array" && typeof value === "string") {
+    const trimmedValue = value.trim();
+    if (trimmedValue.startsWith("[") && trimmedValue.endsWith("]")) {
+      try {
+        return JSON.parse(trimmedValue);
+      } catch {
+      }
+    }
+  }
+  return value;
+}
+function traverseSchema(schema, envValues, prefix = []) {
+  const builtConfig = {};
+  for (const key in schema) {
+    const currentPath = [...prefix, key];
+    const definition = schema[key];
+    const isTypeBoxSchema = (def) => !!def[Symbol.for("TypeBox.Kind")];
+    if (isTypeBoxSchema(definition)) {
+      const prop = definition.prop;
+      const envKey = prop || currentPath.join("_").toUpperCase();
+      let value = envValues[envKey];
+      if (value === void 0) {
+        value = definition.default;
+      }
+      if (value !== void 0) {
+        builtConfig[key] = coerceType(value, definition);
+      }
+    } else if (typeof definition === "object" && definition !== null) {
+      const nestedConfig = traverseSchema(
+        definition,
+        envValues,
+        currentPath
+      );
+      builtConfig[key] = nestedConfig;
+    }
+  }
+  return builtConfig;
+}
+var envDriver = new KfgDriver({
+  identify: "env-driver",
+  async: false,
+  config: { path: ".env" },
+  onLoad(schema, _opts) {
+    const filePath = getFilePath(this.config);
+    const fileContent = fs2.existsSync(filePath) ? fs2.readFileSync(filePath, "utf-8") : "";
+    const envFileValues = parse(fileContent);
+    const processEnv = Object.fromEntries(
+      Object.entries(process.env).filter(([, v]) => v !== void 0)
+    );
+    const allEnvValues = { ...processEnv, ...envFileValues };
+    const envData = traverseSchema(schema, allEnvValues);
+    const defaultData = this.buildDefaultObject(schema);
+    this.store = this.deepMerge(defaultData, envData);
+    return this.store;
+  },
+  onSet(key, value, options) {
+    const envKey = key.replace(/\./g, "_").toUpperCase();
+    const filePath = getFilePath(this.config);
+    const currentContent = fs2.existsSync(filePath) ? fs2.readFileSync(filePath, "utf-8") : "";
+    const newContent = updateEnvContent(
+      currentContent,
+      envKey,
+      value,
+      options?.description
+    );
+    fs2.writeFileSync(filePath, newContent);
+  },
+  onDel(key) {
+    const envKey = key.replace(/\./g, "_").toUpperCase();
+    const filePath = getFilePath(this.config);
+    if (!fs2.existsSync(filePath)) {
+      return;
+    }
+    const currentContent = fs2.readFileSync(filePath, "utf-8");
+    const newContent = removeEnvKey(currentContent, envKey);
+    fs2.writeFileSync(filePath, newContent);
+  }
+});
+
+// src/drivers/json-driver.ts
+var fs3 = __toESM(require("fs"), 1);
+var path2 = __toESM(require("path"), 1);
+function stripComments(data) {
+  const comments = {};
+  function recurse(currentData, prefix = "") {
+    const keys = Object.keys(currentData);
+    for (const key of keys) {
+      if (key.endsWith(":comment")) {
+        const dataKey = key.replace(/:comment$/, "");
+        const commentPath = prefix ? `${prefix}.${dataKey}` : dataKey;
+        comments[commentPath] = currentData[key];
+        delete currentData[key];
+      }
+    }
+    for (const key of keys) {
+      if (typeof currentData[key] === "object" && currentData[key] !== null && !key.endsWith(":comment")) {
+        const nestedPrefix = prefix ? `${prefix}.${key}` : key;
+        recurse(currentData[key], nestedPrefix);
+      }
+    }
+  }
+  recurse(data);
+  return comments;
+}
+function getFilePath2(config) {
+  return path2.resolve(process.cwd(), config.path || "config.json");
+}
+var jsonDriver = new KfgDriver({
+  identify: "json-driver",
+  async: false,
+  config: { path: "config.json", keyroot: false },
+  onLoad(schema, _opts) {
+    this.comments = this.comments || {};
+    const defaultData = this.buildDefaultObject(schema);
+    const filePath = getFilePath2(this.config);
+    let loadedData = {};
+    if (fs3.existsSync(filePath)) {
+      try {
+        const fileContent = fs3.readFileSync(filePath, "utf-8");
+        if (fileContent) {
+          loadedData = JSON.parse(fileContent);
+        }
+      } catch (_e) {
+      }
+    }
+    if (this.config.keyroot) {
+      const flatData = loadedData;
+      const comments = {};
+      const data = {};
+      for (const key in flatData) {
+        if (key.endsWith(":comment")) {
+          comments[key.replace(/:comment$/, "")] = flatData[key];
+        } else {
+          data[key] = flatData[key];
+        }
+      }
+      this.comments = comments;
+      loadedData = unflattenObject(data);
+    } else {
+      this.comments = stripComments(loadedData);
+    }
+    this.store = this.deepMerge(defaultData, loadedData);
+    return this.store;
+  },
+  onSet(key, _value, options) {
+    if (key) {
+      this.comments = this.comments || {};
+      if (options?.description) {
+        this.comments[key] = options.description;
+      }
+    }
+    let dataToSave;
+    if (this.config.keyroot) {
+      dataToSave = flattenObject(this.data);
+      for (const path3 in this.comments) {
+        dataToSave[`${path3}:comment`] = this.comments[path3];
+      }
+    } else {
+      const dataWithComments = JSON.parse(JSON.stringify(this.data));
+      for (const path3 in this.comments) {
+        const keys = path3.split(".");
+        const propName = keys.pop();
+        const parentPath = keys.join(".");
+        const parentObject = parentPath ? getProperty(dataWithComments, parentPath) : dataWithComments;
+        if (typeof parentObject === "object" && parentObject !== null) {
+          parentObject[`${propName}:comment`] = this.comments[path3];
+        }
+      }
+      dataToSave = dataWithComments;
+    }
+    const filePath = getFilePath2(this.config);
+    fs3.writeFileSync(filePath, JSON.stringify(dataToSave, null, 2));
+  },
+  onDel(key) {
+    if (this.comments?.[key]) {
+      delete this.comments[key];
+    }
+    let dataToSave;
+    if (this.config.keyroot) {
+      dataToSave = flattenObject(this.data);
+      for (const path3 in this.comments) {
+        dataToSave[`${path3}:comment`] = this.comments[path3];
+      }
+    } else {
+      const dataWithComments = JSON.parse(JSON.stringify(this.data));
+      for (const path3 in this.comments) {
+        const keys = path3.split(".");
+        const propName = keys.pop();
+        const parentPath = keys.join(".");
+        const parentObject = parentPath ? getProperty(dataWithComments, parentPath) : dataWithComments;
+        if (typeof parentObject === "object" && parentObject !== null) {
+          parentObject[`${propName}:comment`] = this.comments[path3];
+        }
+      }
+      dataToSave = dataWithComments;
+    }
+    const filePath = getFilePath2(this.config);
+    fs3.writeFileSync(filePath, JSON.stringify(dataToSave, null, 2));
+  }
+});
+
+// src/factory.ts
+var import_typebox3 = require("@sinclair/typebox");
+function getEnumValues(values) {
+  if (Array.isArray(values)) {
+    return values;
+  }
+  const isNumericEnum = Object.values(values).some(
+    (v) => typeof v === "number"
+  );
+  if (isNumericEnum) {
+    return Object.values(values).filter(
+      (v) => typeof v === "number"
+    );
+  }
+  return Object.values(values).filter((v) => typeof v === "string");
+}
+var _c = {
+  /** Creates a String schema. */
+  String: (options) => import_typebox3.Type.String(options),
+  /** Creates a Number schema. */
+  Number: (options) => import_typebox3.Type.Number(options),
+  /** Creates a Boolean schema. */
+  Boolean: (options) => import_typebox3.Type.Boolean(options),
+  /** Creates an Object schema. */
+  Object: (properties, options) => import_typebox3.Type.Object(properties, options),
+  /** Creates an Array schema. */
+  Array: (items, options) => import_typebox3.Type.Array(items, options),
+  /** Creates a Record schema. */
+  Record: (key, value, options) => import_typebox3.Type.Record(key, value, options),
+  /** Creates a Union of Literals from a string array, const array, or a TypeScript enum. */
+  Enum: (values, options) => {
+    const enumValues = getEnumValues(values);
+    return import_typebox3.Type.Union(
+      enumValues.map((v) => import_typebox3.Type.Literal(v)),
+      options
+      //@ts-expect-error ignore
+    );
+  },
+  /** Creates a string schema with 'ipv4' format. */
+  IP: (options) => import_typebox3.Type.String({ ...options, format: "ipv4" }),
+  /** Creates a string schema with 'ipv6' format. */
+  IPv6: (options) => import_typebox3.Type.String({ ...options, format: "ipv6" }),
+  /** Creates a string schema with 'email' format. */
+  Email: (options) => import_typebox3.Type.String({ ...options, format: "email" }),
+  /** Creates a string schema with 'uri' format. */
+  URL: (options) => import_typebox3.Type.String({ ...options, format: "uri" }),
+  /** Creates an Any schema. */
+  Any: () => import_typebox3.Type.Any(),
+  /** Creates an Optional schema. */
+  Optional: (schema) => import_typebox3.Type.Optional(schema),
+  /** Creates a Number schema that defaults to a random value if not provided. */
+  Random: (options) => {
+    const { max = 100, ...rest } = options || {};
+    return import_typebox3.Type.Number({
+      ...rest,
+      [Symbol.for("isRandom")]: true,
+      max
+    });
+  }
+};
+var c = {
+  ..._c,
+  string: _c.String,
+  number: _c.Number,
+  boolean: _c.Boolean,
+  object: _c.Object,
+  array: _c.Array,
+  record: _c.Record,
+  enum: _c.Enum,
+  ip: _c.IP,
+  ipv6: _c.IPv6,
+  email: _c.Email,
+  url: _c.URL,
+  any: _c.Any,
+  optional: _c.Optional,
+  random: _c.Random
+};
+var k = c;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConfigFS,
+  ConfigJS,
+  ConfigJSDriver,
+  FileFSConfigJS,
+  KFS_JOIN_SYMBOL,
+  KFS_MANY_SYMBOL,
+  Kfg,
+  KfgDriver,
+  KfgFS,
+  KfgFileFS,
+  c,
+  cfs,
+  envDriver,
+  jsonDriver,
+  k,
+  kfs
+});