@cenk1cenk2/oclif-common 3.9.5 → 3.9.7

package/dist/interfaces/class.interface.d.ts

@@ -0,0 +1,3 @@
+type ClassType<T> = new (...args: any[]) => T;
+
+export { ClassType };

package/dist/interfaces/class.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 class_interface_exports = {};
+module.exports = __toCommonJS(class_interface_exports);

package/dist/interfaces/config-command.interface.d.ts

@@ -0,0 +1,12 @@
+import { LockerService } from '../lib/locker/locker.service.js';
+import '../lib/locker/locker.interface.js';
+import '../utils/merge.constants.js';
+import '../lib/parser/parser.interface.js';
+
+type ConfigCommandChoices<T extends string> = Record<T, () => void | Promise<void>>;
+interface ConfigCommandSetup<T extends string = string, LockFile = any> {
+    choices: ConfigCommandChoices<T>;
+    locker?: LockerService<LockFile>;
+}
+
+export { ConfigCommandChoices, ConfigCommandSetup };

package/dist/interfaces/config-command.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 config_command_interface_exports = {};
+module.exports = __toCommonJS(config_command_interface_exports);

package/dist/interfaces/index.d.ts

@@ -0,0 +1,10 @@
+export { ClassType } from './class.interface.js';
+export { ConfigCommandChoices, ConfigCommandSetup } from './config-command.interface.js';
+export { InferArgs, InferFlags } from './oclif.interface.js';
+export { DeepPartial } from './type-helper.interface.js';
+export { Arg, ArgInput, Flag, FlagInput, InferredFlags } from '@oclif/core/lib/interfaces';
+export { Flags } from '@oclif/core';
+import '../lib/locker/locker.service.js';
+import '../lib/locker/locker.interface.js';
+import '../utils/merge.constants.js';
+import '../lib/parser/parser.interface.js';

package/dist/interfaces/index.js

@@ -0,0 +1,20 @@
+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 interfaces_exports = {};
+module.exports = __toCommonJS(interfaces_exports);
+__reExport(interfaces_exports, require("./class.interface"), module.exports);
+__reExport(interfaces_exports, require("./config-command.interface"), module.exports);
+__reExport(interfaces_exports, require("./oclif.interface"), module.exports);
+__reExport(interfaces_exports, require("./type-helper.interface"), module.exports);

package/dist/interfaces/oclif.interface.d.ts

@@ -0,0 +1,9 @@
+import { Command } from '@oclif/core';
+export { Flags } from '@oclif/core';
+import { InferredFlags } from '@oclif/core/lib/interfaces';
+export { Arg, ArgInput, Flag, FlagInput, InferredFlags } from '@oclif/core/lib/interfaces';
+
+type InferFlags<T extends typeof Command> = InferredFlags<T['globalFlags'] & T['flags']>;
+type InferArgs<T extends typeof Command> = Record<T['args'][number]['name'], string>;
+
+export { InferArgs, InferFlags };

package/dist/interfaces/oclif.interface.js

@@ -0,0 +1,27 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var oclif_interface_exports = {};
+__export(oclif_interface_exports, {
+  Flags: () => import_core.Flags
+});
+module.exports = __toCommonJS(oclif_interface_exports);
+var import_core = require("@oclif/core");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Flags
+});

package/dist/interfaces/type-helper.interface.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Makes the object deep partial.
+ */
+type DeepPartial<T> = {
+    [P in keyof T]?: DeepPartial<T[P]>;
+};
+
+export { DeepPartial };

package/dist/interfaces/type-helper.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 type_helper_interface_exports = {};
+module.exports = __toCommonJS(type_helper_interface_exports);

package/dist/lib/config/config.constants.d.ts

@@ -0,0 +1,8 @@
+declare enum ConfigEnvKeys {
+    NAME = "__name",
+    PARSER = "__format",
+    ELEMENT = "__element",
+    ELEMENT_REPLACER = "${i}"
+}
+
+export { ConfigEnvKeys };

package/dist/lib/config/config.constants.js

@@ -0,0 +1,33 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var config_constants_exports = {};
+__export(config_constants_exports, {
+  ConfigEnvKeys: () => ConfigEnvKeys
+});
+module.exports = __toCommonJS(config_constants_exports);
+var ConfigEnvKeys = /* @__PURE__ */ ((ConfigEnvKeys2) => {
+  ConfigEnvKeys2["NAME"] = "__name";
+  ConfigEnvKeys2["PARSER"] = "__format";
+  ConfigEnvKeys2["ELEMENT"] = "__element";
+  ConfigEnvKeys2["ELEMENT_REPLACER"] = "${i}";
+  return ConfigEnvKeys2;
+})(ConfigEnvKeys || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConfigEnvKeys
+});

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

@@ -0,0 +1,15 @@
+import { LogLevels } from '../../utils/logger/logger.constants.js';
+
+interface GlobalConfig {
+    logLevel: LogLevels;
+    ci: boolean;
+    json: boolean;
+}
+interface ConfigIterator {
+    key: (string | number)[];
+    env: string;
+    parser?: string;
+    extensions?: ConfigIterator[];
+}
+
+export { ConfigIterator, GlobalConfig };

package/dist/lib/config/config.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 config_interface_exports = {};
+module.exports = __toCommonJS(config_interface_exports);

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

@@ -0,0 +1,24 @@
+import './config.interface.js';
+export { a as ConfigService } from '../../base.command-d3038122.js';
+import '../locker/locker.interface.js';
+import '../parser/parser.service.js';
+import '../../utils/logger/logger.constants.js';
+import '../../utils/merge.constants.js';
+import '@oclif/core';
+import 'listr2';
+import '../../utils/logger/logger.js';
+import '../../utils/logger/logger.interface.js';
+import 'winston';
+import '../fs/filesystem.service.js';
+import 'fs-extra';
+import '../../utils/defaults.js';
+import '../store/store.service.js';
+import '../store/store.interface.js';
+import '../validator/validator.service.js';
+import '../validator/validator.interface.js';
+import 'class-transformer';
+import 'class-validator';
+import '../../interfaces/class.interface.js';
+import '../../interfaces/oclif.interface.js';
+import '@oclif/core/lib/interfaces';
+import '../parser/parser.interface.js';

package/dist/lib/config/config.service.js

@@ -0,0 +1,172 @@
+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 config_service_exports = {};
+__export(config_service_exports, {
+  ConfigService: () => ConfigService
+});
+module.exports = __toCommonJS(config_service_exports);
+var import_object_path_immutable = __toESM(require("object-path-immutable"));
+var import_path = require("path");
+var import_config = require("./config.constants");
+var import_constants = require("../../constants");
+var import_parser = require("../parser/parser.service");
+var import_utils = require("../../utils");
+var import_logger = require("../../utils/logger");
+class ConfigService {
+  constructor(oclif, command, config) {
+    this.oclif = oclif;
+    this.command = command;
+    if (ConfigService.instance) {
+      return ConfigService.instance;
+    }
+    this.root = this.oclif.root;
+    this.defaults = (0, import_path.join)(this.oclif.root, import_constants.FileConstants.CONFIG_SERVICE_DEFAULTS_DIR);
+    this.logger = new import_logger.Logger(this.constructor.name, { level: config.logLevel });
+    Object.assign(this, config);
+    this.recalculate();
+    this.parser = new import_parser.ParserService();
+    ConfigService.instance = this;
+    this.logger.trace("Created a new instance.");
+  }
+  async read(path) {
+    const config = await this.parser.read(path);
+    this.logger.trace("Read config from: %s", path);
+    return config;
+  }
+  async extend(paths, strategy = import_utils.MergeStrategy.OVERWRITE) {
+    this.logger.trace("Will generate config from: %o with %s", paths, strategy);
+    const configs = (await Promise.all(
+      paths.map(async (path) => {
+        try {
+          const config = typeof path === "string" ? await this.parser.read(path) : path;
+          this.logger.trace("Extending config from: %s", path);
+          return config;
+        } catch (e) {
+          this.logger.trace("Failed to extend config from: %s", e.message);
+        }
+      })
+    )).filter(Boolean);
+    return this.merge(configs, strategy);
+  }
+  merge(configs, strategy = import_utils.MergeStrategy.OVERWRITE) {
+    if (configs.length === 0) {
+      throw new Error("Nothing to merge, configuration files are empty.");
+    }
+    return (0, import_utils.merge)(strategy, ...configs);
+  }
+  async env(definition, config) {
+    const env = typeof definition === "string" ? await this.parser.read(definition) : definition;
+    this.logger.trace("Environment variable extensions read: %o", definition);
+    const iter = /* @__PURE__ */ __name(async (obj, parent) => {
+      const data = await Promise.all(
+        Object.entries(obj).map(async ([key, value]) => {
+          const location = [...parent ?? [], key];
+          if (typeof value === "string") {
+            return [{ key: location, env: value }];
+          } else if (typeof value === "object") {
+            let extensions;
+            if (import_config.ConfigEnvKeys.ELEMENT in value) {
+              extensions = await iter(value[import_config.ConfigEnvKeys.ELEMENT], [...location, import_config.ConfigEnvKeys.ELEMENT]);
+              this.logger.trace("Expanding location to elements: %s -> %s", location, extensions.map((extension) => extension.key.join(".")).join(", "));
+            }
+            if (import_config.ConfigEnvKeys.NAME in value && import_config.ConfigEnvKeys.PARSER in value) {
+              const variable = [
+                {
+                  key: location,
+                  env: value[import_config.ConfigEnvKeys.NAME],
+                  parser: value[import_config.ConfigEnvKeys.PARSER],
+                  extensions
+                }
+              ];
+              return variable;
+            } else {
+              return iter(value, location);
+            }
+          }
+        })
+      );
+      return data.flatMap((d) => d).filter(Boolean);
+    }, "iter");
+    const parsed = await iter(env);
+    const cb = /* @__PURE__ */ __name((config2, variable, data) => {
+      if (variable.parser) {
+        try {
+          data = this.parser.parse(variable.parser, data);
+        } catch (e) {
+          this.logger.trace("Can not parse environment environment variable for config: %s -> %s with %s", variable.key.join("."), variable.env, variable.parser);
+          throw e;
+        }
+      }
+      this.logger.trace("Overwriting config with environment variable: %s -> %s", variable.key.join("."), variable.env);
+      return import_object_path_immutable.default.set(config2, variable.key, data);
+    }, "cb");
+    parsed.forEach((variable) => {
+      let data;
+      data = process.env[variable.env];
+      if (data) {
+        config = cb(config, variable, data);
+      }
+      if (variable.extensions && variable.extensions.length > 0) {
+        const timeout = 6e4;
+        const startedAt = Date.now();
+        for (let i = 0; i < Infinity; i++) {
+          if (Date.now() - startedAt > timeout) {
+            throw new Error(`Timed-out in ${timeout}ms while looking for element environment variables.`);
+          }
+          const extensions = variable.extensions.map((extension) => {
+            const clone = JSON.parse(JSON.stringify(extension));
+            clone.env = clone.env.replace(import_config.ConfigEnvKeys.ELEMENT_REPLACER, i.toString());
+            clone.key[clone.key.findIndex((value) => value === import_config.ConfigEnvKeys.ELEMENT)] = i.toString();
+            data = process.env[clone.env];
+            if (!data) {
+              this.logger.trace("No extension for environment variable: %s -> %s", clone.key.join("."), clone.env);
+              return;
+            }
+            config = cb(config, clone, data);
+            return true;
+          }).filter(Boolean);
+          if (extensions.length === 0) {
+            this.logger.trace("No more extensions for environment variables: %s -> %d", variable.key.join("."), i);
+            break;
+          }
+        }
+      }
+    });
+    return config;
+  }
+  async write(path, data) {
+    return this.parser.write(path, data);
+  }
+  recalculate() {
+    this.isVerbose = (0, import_utils.isVerbose)(this.logLevel);
+    this.isDebug = (0, import_utils.isDebug)(this.logLevel);
+    this.isSilent = (0, import_utils.isSilent)(this.logLevel);
+  }
+}
+__name(ConfigService, "ConfigService");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConfigService
+});

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

@@ -0,0 +1,24 @@
+export { ConfigIterator, GlobalConfig } from './config.interface.js';
+export { a as ConfigService } from '../../base.command-d3038122.js';
+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 '../fs/filesystem.service.js';
+import 'fs-extra';
+import '../../utils/defaults.js';
+import '../parser/parser.service.js';
+import '../parser/parser.interface.js';
+import '../../interfaces/class.interface.js';
+import '../locker/locker.interface.js';
+import '../../utils/merge.constants.js';
+import '../store/store.service.js';
+import '../store/store.interface.js';
+import '../validator/validator.service.js';
+import '../validator/validator.interface.js';
+import 'class-transformer';
+import 'class-validator';
+import '../../interfaces/oclif.interface.js';
+import '@oclif/core/lib/interfaces';

package/dist/lib/config/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 config_exports = {};
+module.exports = __toCommonJS(config_exports);
+__reExport(config_exports, require("./config.interface"), module.exports);
+__reExport(config_exports, require("./config.service"), module.exports);

package/dist/lib/fs/filesystem.service.d.ts

@@ -0,0 +1,28 @@
+import fs from 'fs-extra';
+export { default as fs } from 'fs-extra';
+
+declare class FileSystemService {
+    private static instance;
+    private logger;
+    constructor();
+    exists(path: string): boolean;
+    stats(path: string): fs.Stats;
+    dirname(path: string): string;
+    extname(path: string): string;
+    read(file: string): Promise<string>;
+    readSync(file: string): string;
+    write(file: string, data: string | Buffer, options?: fs.WriteFileOptions): Promise<void>;
+    writeSync(file: string, data: string | Buffer, options?: fs.WriteFileOptions): void;
+    append(file: string, data: string | Buffer, options?: fs.WriteFileOptions): Promise<void>;
+    appendSync(file: string, data: string | Buffer): void;
+    remove(file: string, options?: fs.RmOptions): Promise<void>;
+    removeSync(file: string, options?: fs.RmOptions): void;
+    emptyDir(directory: string): Promise<void>;
+    emptyDirSync(directory: string): void;
+    removeDir(directory: string): Promise<void>;
+    removeDirSync(directory: string): void;
+    mkdir(directory: string): Promise<void>;
+    mkdirSync(directory: string): void;
+}
+
+export { FileSystemService };

package/dist/lib/fs/filesystem.service.js

@@ -0,0 +1,162 @@
+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 filesystem_service_exports = {};
+__export(filesystem_service_exports, {
+  FileSystemService: () => FileSystemService,
+  fs: () => import_fs_extra.default
+});
+module.exports = __toCommonJS(filesystem_service_exports);
+var import_fs_extra = __toESM(require("fs-extra"));
+var import_path = require("path");
+var import_logger = require("../../utils/logger");
+class FileSystemService {
+  constructor() {
+    if (FileSystemService.instance) {
+      return FileSystemService.instance;
+    } else {
+      FileSystemService.instance = this;
+      this.logger = new import_logger.Logger(this.constructor.name);
+      this.logger.trace("Created a new instance.");
+    }
+  }
+  exists(path) {
+    return import_fs_extra.default.existsSync(path);
+  }
+  stats(path) {
+    return import_fs_extra.default.statSync(path, { throwIfNoEntry: true });
+  }
+  dirname(path) {
+    return (0, import_path.dirname)(path);
+  }
+  extname(path) {
+    return (0, import_path.extname)(path);
+  }
+  async read(file) {
+    try {
+      const raw = await import_fs_extra.default.readFile(file, "utf-8");
+      return raw;
+    } catch (e) {
+      throw new Error(`Error while reading file from "${file}": ${e.message}`);
+    }
+  }
+  readSync(file) {
+    try {
+      const raw = import_fs_extra.default.readFileSync(file, "utf-8");
+      return raw;
+    } catch (e) {
+      throw new Error(`Error while reading file from "${file}": ${e.message}`);
+    }
+  }
+  async write(file, data, options = {}) {
+    try {
+      await import_fs_extra.default.writeFile(file, data, { encoding: "utf-8", ...options });
+    } catch (e) {
+      throw new Error(`Error while writing file to "${file}": ${e.message}`);
+    }
+  }
+  writeSync(file, data, options = {}) {
+    try {
+      import_fs_extra.default.writeFileSync(file, data, { encoding: "utf-8", ...options });
+    } catch (e) {
+      throw new Error(`Error while writing file to "${file}": ${e.message}`);
+    }
+  }
+  async append(file, data, options) {
+    try {
+      await import_fs_extra.default.appendFile(file, data, options);
+    } catch (e) {
+      throw new Error(`Error while appending to file  "${file}": ${e.message}`);
+    }
+  }
+  appendSync(file, data) {
+    try {
+      import_fs_extra.default.appendFileSync(file, data);
+    } catch (e) {
+      throw new Error(`Error while appending to file  "${file}": ${e.message}`);
+    }
+  }
+  async remove(file, options) {
+    try {
+      await import_fs_extra.default.rm(file, options);
+    } catch (e) {
+      throw new Error(`Error while deleting the file "${file}": ${e.message}`);
+    }
+  }
+  removeSync(file, options) {
+    try {
+      import_fs_extra.default.rmSync(file, options);
+    } catch (e) {
+      throw new Error(`Error while deleting the file "${file}": ${e.message}`);
+    }
+  }
+  async emptyDir(directory) {
+    try {
+      await import_fs_extra.default.emptyDir(directory);
+    } catch (e) {
+      throw new Error(`Error while emptying the directory "${directory}": ${e.message}`);
+    }
+  }
+  emptyDirSync(directory) {
+    try {
+      import_fs_extra.default.emptyDirSync(directory);
+    } catch (e) {
+      throw new Error(`Error while emptying the directory "${directory}": ${e.message}`);
+    }
+  }
+  async removeDir(directory) {
+    try {
+      await import_fs_extra.default.rmdir(directory);
+    } catch (e) {
+      throw new Error(`Error while removing the directory "${directory}": ${e.message}`);
+    }
+  }
+  removeDirSync(directory) {
+    try {
+      import_fs_extra.default.rmdirSync(directory);
+    } catch (e) {
+      throw new Error(`Error while removing the directory "${directory}": ${e.message}`);
+    }
+  }
+  async mkdir(directory) {
+    try {
+      await import_fs_extra.default.mkdirp(directory);
+    } catch (e) {
+      throw new Error(`Error while creating the directory "${directory}": ${e.message}`);
+    }
+  }
+  mkdirSync(directory) {
+    try {
+      import_fs_extra.default.mkdirSync(directory);
+    } catch (e) {
+      throw new Error(`Error while creating the directory "${directory}": ${e.message}`);
+    }
+  }
+}
+__name(FileSystemService, "FileSystemService");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FileSystemService,
+  fs
+});

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

@@ -0,0 +1,2 @@
+export { FileSystemService } from './filesystem.service.js';
+export { default as fs } from 'fs-extra';