@cenk1cenk2/oclif-common 3.9.6 → 3.9.7

package/dist/lib/fs/index.js

@@ -0,0 +1,17 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var fs_exports = {};
+module.exports = __toCommonJS(fs_exports);
+__reExport(fs_exports, require("./filesystem.service"), module.exports);

package/dist/lib/index.d.ts

@@ -0,0 +1,29 @@
+export { ConfigIterator, GlobalConfig } from './config/config.interface.js';
+export { a as ConfigService } from '../base.command-d3038122.js';
+export { FileSystemService } from './fs/filesystem.service.js';
+export { CommonLockerData, LockData, LockableData, UnlockData } from './locker/locker.interface.js';
+export { LockerService } from './locker/locker.service.js';
+export { EnvironmentVariableParser } from './parser/env-parser.service.js';
+export { GenericParser } from './parser/parser.interface.js';
+export { ParserService } from './parser/parser.service.js';
+export { YamlParser } from './parser/yaml-parser.service.js';
+export { JsonParser } from './parser/json-parser.service.js';
+export { DataStore } from './store/store.interface.js';
+export { StoreService } from './store/store.service.js';
+export { ValidatorServiceOptions } from './validator/validator.interface.js';
+export { ValidatorService } from './validator/validator.service.js';
+export { setup } from './setup.js';
+export { default as fs } from 'fs-extra';
+import '../utils/logger/logger.constants.js';
+import '@oclif/core';
+import 'listr2';
+import '../utils/logger/logger.js';
+import '../utils/logger/logger.interface.js';
+import 'winston';
+import '../utils/defaults.js';
+import '../interfaces/oclif.interface.js';
+import '@oclif/core/lib/interfaces';
+import '../utils/merge.constants.js';
+import '../interfaces/class.interface.js';
+import 'class-transformer';
+import 'class-validator';

package/dist/lib/index.js

@@ -0,0 +1,23 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var lib_exports = {};
+module.exports = __toCommonJS(lib_exports);
+__reExport(lib_exports, require("./config"), module.exports);
+__reExport(lib_exports, require("./fs"), module.exports);
+__reExport(lib_exports, require("./locker"), module.exports);
+__reExport(lib_exports, require("./parser"), module.exports);
+__reExport(lib_exports, require("./store"), module.exports);
+__reExport(lib_exports, require("./validator"), module.exports);
+__reExport(lib_exports, require("./setup"), module.exports);

package/dist/lib/locker/index.d.ts

@@ -0,0 +1,4 @@
+export { CommonLockerData, LockData, LockableData, UnlockData } from './locker.interface.js';
+export { LockerService } from './locker.service.js';
+import '../../utils/merge.constants.js';
+import '../parser/parser.interface.js';

package/dist/lib/locker/index.js

@@ -0,0 +1,18 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var locker_exports = {};
+module.exports = __toCommonJS(locker_exports);
+__reExport(locker_exports, require("./locker.interface"), module.exports);
+__reExport(locker_exports, require("./locker.service"), module.exports);

package/dist/lib/locker/locker.interface.d.ts

@@ -0,0 +1,17 @@
+import { MergeStrategy } from '../../utils/merge.constants.js';
+
+interface CommonLockerData {
+    path?: string | string[];
+    enabled?: boolean;
+    root?: boolean;
+}
+type LockableData = any;
+interface LockData<T extends LockableData = LockableData> extends Partial<CommonLockerData> {
+    data: T;
+    merge?: MergeStrategy;
+}
+interface UnlockData extends CommonLockerData {
+    path: string | string[];
+}
+
+export { CommonLockerData, LockData, LockableData, UnlockData };

package/dist/lib/locker/locker.interface.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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);
+var locker_interface_exports = {};
+module.exports = __toCommonJS(locker_interface_exports);

package/dist/lib/locker/locker.service.d.ts

@@ -0,0 +1,30 @@
+import { LockableData, LockData, UnlockData } from './locker.interface.js';
+import { GenericParser } from '../parser/parser.interface.js';
+import '../../utils/merge.constants.js';
+
+declare class LockerService<LockFile extends LockableData = LockableData> {
+    private file;
+    private parser?;
+    private root?;
+    private toLock;
+    private toUnlock;
+    private logger;
+    private fs;
+    constructor(file: string, parser?: GenericParser, root?: string[], context?: string);
+    hasLock(): boolean;
+    hasUnlock(): boolean;
+    addLock<T extends LockableData = LockableData>(...data: LockData<T>[]): void;
+    addUnlock(...data: UnlockData[]): void;
+    lockAll(): Promise<void>;
+    unlockAll(): Promise<void>;
+    all(): Promise<void>;
+    lock<T extends LockableData = LockableData>(...data: LockData<T>[]): Promise<void>;
+    unlock(...data: UnlockData[]): Promise<void>;
+    read(): Promise<LockFile>;
+    tryRead(): Promise<LockFile | undefined>;
+    write(data: LockFile): Promise<void>;
+    private buildPath;
+    private normalizePath;
+}
+
+export { LockerService };

package/dist/lib/locker/locker.service.js

@@ -0,0 +1,170 @@
+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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var locker_service_exports = {};
+__export(locker_service_exports, {
+  LockerService: () => LockerService
+});
+module.exports = __toCommonJS(locker_service_exports);
+var import_object_path_immutable = __toESM(require("object-path-immutable"));
+var import_fs = require("../fs");
+var import_parser = require("../parser");
+var import_utils = require("../../utils");
+var import_logger = require("../../utils/logger");
+class LockerService {
+  constructor(file, parser, root, context) {
+    this.file = file;
+    this.parser = parser;
+    this.root = root;
+    this.toLock = [];
+    this.toUnlock = [];
+    this.fs = new import_fs.FileSystemService();
+    this.logger = new import_logger.Logger(context ?? this.constructor.name);
+    if (!this.parser) {
+      const parser2 = new import_parser.ParserService();
+      this.parser = parser2.getParser(file);
+    }
+  }
+  hasLock() {
+    return this.toLock.length > 0;
+  }
+  hasUnlock() {
+    return this.toUnlock.length > 0;
+  }
+  addLock(...data) {
+    this.toLock = [...this.toLock, ...data];
+  }
+  addUnlock(...data) {
+    this.toUnlock = [...this.toUnlock, ...data];
+  }
+  async lockAll() {
+    if (this.hasLock()) {
+      await this.lock(...this.toLock);
+      this.toLock = [];
+    }
+  }
+  async unlockAll() {
+    if (this.toUnlock.length > 0) {
+      await this.unlock(...this.toUnlock);
+      this.toUnlock = [];
+    }
+  }
+  async all() {
+    await this.unlockAll();
+    await this.lockAll();
+  }
+  async lock(...data) {
+    let lock = await this.tryRead() ?? {};
+    data.forEach((d) => {
+      if (d?.enabled === false) {
+        return;
+      } else if (!d?.data || Array.isArray(d?.data) && d.data.length === 0 || typeof d?.data === "object" && Object.keys(d.data).length === 0) {
+        return;
+      }
+      const path = this.buildPath(d);
+      if (d?.merge) {
+        let parsed;
+        if (typeof d.data === "object") {
+          parsed = (0, import_utils.merge)(d.merge, import_object_path_immutable.default.get(lock, path, Array.isArray(d.data) ? [] : {}), d.data);
+        } else {
+          this.logger.warn('"%s" path with type "%s" is not mergeable.', path, typeof d.data);
+          parsed = d.data;
+        }
+        lock = import_object_path_immutable.default.set(lock, path, parsed);
+        this.logger.verbose("Merge lock: %s -> %o", path, d.data);
+      } else {
+        lock = import_object_path_immutable.default.set(lock, path, d.data);
+        this.logger.verbose("Override lock: %s -> %o", path, d.data);
+      }
+    });
+    await this.write(lock);
+  }
+  async unlock(...data) {
+    let lock = await this.tryRead();
+    if (!lock) {
+      this.logger.verbose("Lock file not found. Nothing to unlock.");
+      return;
+    }
+    if (data.length > 0) {
+      data.forEach((d) => {
+        if (d?.enabled === false) {
+          return;
+        }
+        const path = this.buildPath(d);
+        lock = import_object_path_immutable.default.del(lock, path);
+        this.logger.verbose("Unlocked: %s", path);
+        for (let i = path.length - 1; i >= 0; i--) {
+          const parentPath = path.slice(0, i);
+          const parent = import_object_path_immutable.default.get(lock, parentPath);
+          if (!parent || Array.isArray(parent) && parent.length === 0 || typeof parent === "object" && Object.keys(parent).length === 0) {
+            this.logger.verbose("Unlocked parent: %s -> %s", path, parentPath);
+            lock = import_object_path_immutable.default.del(lock, parentPath);
+          } else {
+            break;
+          }
+        }
+      });
+    } else {
+      lock = import_object_path_immutable.default.del(lock, this.root);
+      this.logger.verbose("Unlocked module: %s", this.root);
+    }
+    await this.write(lock ?? {});
+  }
+  async read() {
+    return this.parser.parse(await this.fs.read(this.file));
+  }
+  async tryRead() {
+    try {
+      return this.parser.parse(await this.fs.read(this.file));
+    } catch {
+      this.logger.trace("Can not read lockfile: %s", this.file);
+    }
+  }
+  async write(data) {
+    if (!data || Array.isArray(data) && data.length === 0 || typeof data === "object" && Object.keys(data).length === 0) {
+      this.logger.trace("Trying to write empty lock file, deleting it instead: %s", this.file);
+      return this.fs.remove(this.file);
+    }
+    return this.fs.write(this.file, this.parser.stringify(data));
+  }
+  buildPath(d) {
+    if (d?.root !== true && this.root?.length) {
+      return [...this.root, ...this.normalizePath(d.path)];
+    }
+    return this.normalizePath(d.path);
+  }
+  normalizePath(path) {
+    if (Array.isArray(path)) {
+      return path.map((p) => p.toString());
+    } else if (typeof path === "string") {
+      return path.split(".");
+    }
+    return [];
+  }
+}
+__name(LockerService, "LockerService");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LockerService
+});

package/dist/lib/parser/env-parser.service.d.ts

@@ -0,0 +1,13 @@
+import { GenericParser } from './parser.interface.js';
+
+declare class EnvironmentVariableParser implements GenericParser {
+    static extensions: string[];
+    private static instance;
+    private logger;
+    private LINE;
+    constructor();
+    parse<T = unknown>(data: string | Buffer): T;
+    stringify<T = any>(data: T): string;
+}
+
+export { EnvironmentVariableParser };

package/dist/lib/parser/env-parser.service.js

@@ -0,0 +1,62 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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);
+var env_parser_service_exports = {};
+__export(env_parser_service_exports, {
+  EnvironmentVariableParser: () => EnvironmentVariableParser
+});
+module.exports = __toCommonJS(env_parser_service_exports);
+var import_os = require("os");
+var import_logger = require("../../utils/logger");
+const _EnvironmentVariableParser = class {
+  constructor() {
+    this.LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm;
+    if (_EnvironmentVariableParser.instance) {
+      return _EnvironmentVariableParser.instance;
+    }
+    _EnvironmentVariableParser.instance = this;
+    this.logger = new import_logger.Logger(this.constructor.name);
+    this.logger.trace("Created a new instance.");
+  }
+  parse(data) {
+    try {
+      return data.toString().split(import_os.EOL).reduce((o, line) => {
+        const match = this.LINE.exec(line);
+        const key = match[1];
+        const value = match[2] ?? "";
+        return {
+          ...o,
+          [key]: value
+        };
+      }, {});
+    } catch (e) {
+      this.logger.trace("Error during parsing environment file: %s", e.message);
+      throw e;
+    }
+  }
+  stringify(data) {
+    return Object.entries(data).map(([k, v]) => `${k}=${v}`).join(import_os.EOL) + import_os.EOL;
+  }
+};
+let EnvironmentVariableParser = _EnvironmentVariableParser;
+__name(EnvironmentVariableParser, "EnvironmentVariableParser");
+EnvironmentVariableParser.extensions = ["env"];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EnvironmentVariableParser
+});

package/dist/lib/parser/index.d.ts

@@ -0,0 +1,8 @@
+export { EnvironmentVariableParser } from './env-parser.service.js';
+export { GenericParser } from './parser.interface.js';
+export { ParserService } from './parser.service.js';
+export { YamlParser } from './yaml-parser.service.js';
+export { JsonParser } from './json-parser.service.js';
+import '../../interfaces/class.interface.js';
+import '../locker/locker.interface.js';
+import '../../utils/merge.constants.js';

package/dist/lib/parser/index.js

@@ -0,0 +1,21 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var parser_exports = {};
+module.exports = __toCommonJS(parser_exports);
+__reExport(parser_exports, require("./env-parser.service"), module.exports);
+__reExport(parser_exports, require("./parser.interface"), module.exports);
+__reExport(parser_exports, require("./parser.service"), module.exports);
+__reExport(parser_exports, require("./yaml-parser.service"), module.exports);
+__reExport(parser_exports, require("./json-parser.service"), module.exports);

package/dist/lib/parser/json-parser.service.d.ts

@@ -0,0 +1,12 @@
+import { GenericParser } from './parser.interface.js';
+
+declare class JsonParser implements GenericParser {
+    static extensions: string[];
+    private static instance;
+    private logger;
+    constructor();
+    parse<T = unknown>(data: string | Buffer): T;
+    stringify<T = any>(data: T): string;
+}
+
+export { JsonParser };

package/dist/lib/parser/json-parser.service.js

@@ -0,0 +1,52 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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);
+var json_parser_service_exports = {};
+__export(json_parser_service_exports, {
+  JsonParser: () => JsonParser
+});
+module.exports = __toCommonJS(json_parser_service_exports);
+var import_logger = require("../../utils/logger");
+const _JsonParser = class {
+  constructor() {
+    if (_JsonParser.instance) {
+      return _JsonParser.instance;
+    }
+    _JsonParser.instance = this;
+    this.logger = new import_logger.Logger(this.constructor.name);
+    this.logger.trace("Created a new instance.");
+  }
+  parse(data) {
+    try {
+      return JSON.parse(data.toString());
+    } catch (e) {
+      this.logger.trace("Error during parsing JSON file: %s", e.message);
+      throw e;
+    }
+  }
+  stringify(data) {
+    return JSON.stringify(data, null, 2);
+  }
+};
+let JsonParser = _JsonParser;
+__name(JsonParser, "JsonParser");
+JsonParser.extensions = ["json"];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  JsonParser
+});

package/dist/lib/parser/parser.interface.d.ts

@@ -0,0 +1,7 @@
+declare class GenericParser {
+    static extensions: string[];
+    parse<T = unknown>(data: string | Buffer): T;
+    stringify<T = any>(data: T): string;
+}
+
+export { GenericParser };

package/dist/lib/parser/parser.interface.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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);
+var parser_interface_exports = {};
+module.exports = __toCommonJS(parser_interface_exports);

package/dist/lib/parser/parser.service.d.ts

@@ -0,0 +1,21 @@
+import { GenericParser } from './parser.interface.js';
+import { ClassType } from '../../interfaces/class.interface.js';
+import { LockableData } from '../locker/locker.interface.js';
+import '../../utils/merge.constants.js';
+
+declare class ParserService {
+    private static instance;
+    parsers: ClassType<GenericParser>[];
+    private logger;
+    private fs;
+    constructor(parsers?: ClassType<GenericParser>[]);
+    getParser(file: string): GenericParser;
+    setParsers(...parsers: ClassType<GenericParser>[]): void;
+    addParsers(...parsers: ClassType<GenericParser>[]): void;
+    read<T = unknown>(file: string): Promise<T>;
+    write<T = LockableData>(file: string, data: T): Promise<void>;
+    parse<T = unknown>(file: string, data: string | Buffer): T;
+    stringify<T = any>(file: string, data: T): string | Promise<string>;
+}
+
+export { ParserService };

package/dist/lib/parser/parser.service.js

@@ -0,0 +1,87 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+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);
+var parser_service_exports = {};
+__export(parser_service_exports, {
+  ParserService: () => ParserService
+});
+module.exports = __toCommonJS(parser_service_exports);
+var import_env_parser = require("./env-parser.service");
+var import_json_parser = require("./json-parser.service");
+var import_yaml_parser = require("./yaml-parser.service");
+var import_fs = require("../fs");
+var import_logger = require("../../utils/logger");
+class ParserService {
+  constructor(parsers) {
+    this.parsers = [import_yaml_parser.YamlParser, import_json_parser.JsonParser, import_env_parser.EnvironmentVariableParser];
+    if (ParserService.instance) {
+      return ParserService.instance;
+    } else {
+      if (parsers) {
+        this.parsers = parsers;
+      }
+      this.logger = new import_logger.Logger(this.constructor.name);
+      this.fs = new import_fs.FileSystemService();
+      ParserService.instance = this;
+      this.logger.trace("Created a new instance.");
+    }
+  }
+  getParser(file) {
+    const ext = (file.includes(".") ? this.fs.extname(file) : file).replace(/^\./, "");
+    const Parser = this.parsers.find((parser) => parser.extensions.includes(ext));
+    if (!Parser) {
+      throw new Error(`Parser for the extension is not configured: ${ext}`);
+    }
+    return new Parser();
+  }
+  setParsers(...parsers) {
+    this.parsers = parsers;
+    this.logger.trace(
+      "Set parsers: %s",
+      this.parsers.map((p) => p.name)
+    );
+  }
+  addParsers(...parsers) {
+    this.parsers.push(...parsers);
+    this.logger.trace(
+      "Added parser, current parsers: %s",
+      this.parsers.map((p) => p.name)
+    );
+  }
+  async read(file) {
+    return this.parse(file, await this.fs.read(file));
+  }
+  async write(file, data) {
+    return this.fs.write(file, await this.stringify(file, data));
+  }
+  parse(file, data) {
+    const parser = this.getParser(file);
+    this.logger.trace("Parsing file: %s -> %s", file, parser.constructor.name);
+    return parser.parse(data);
+  }
+  stringify(file, data) {
+    const parser = this.getParser(file);
+    this.logger.trace("Stringifying file: %s -> %s", file, parser.constructor.name);
+    return parser.stringify(data);
+  }
+}
+__name(ParserService, "ParserService");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ParserService
+});

package/dist/lib/parser/yaml-parser.service.d.ts

@@ -0,0 +1,12 @@
+import { GenericParser } from './parser.interface.js';
+
+declare class YamlParser implements GenericParser {
+    static extensions: string[];
+    private static instance;
+    private logger;
+    constructor();
+    parse<T = unknown>(data: string | Buffer): T;
+    stringify<T = any>(data: T): string;
+}
+
+export { YamlParser };