@cenk1cenk2/oclif-common 1.0.0

package/dist/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export { notFoundHook } from './not-found.hook.js';
+import '@oclif/core';

package/dist/hooks/index.js

@@ -0,0 +1,232 @@
+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(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/hooks/index.ts
+var hooks_exports = {};
+__export(hooks_exports, {
+  notFoundHook: () => notFoundHook
+});
+module.exports = __toCommonJS(hooks_exports);
+
+// src/hooks/not-found.hook.ts
+var import_core = require("@oclif/core");
+
+// src/utils/logger/pipe/pipe-process-to-listr.ts
+var import_through = __toESM(require("through"));
+
+// src/utils/logger/pipe/pipe-process-to-logger.ts
+var import_through2 = __toESM(require("through"));
+
+// src/utils/logger/logger.constants.ts
+var LogLevels = /* @__PURE__ */ ((LogLevels2) => {
+  LogLevels2["SILENT"] = "SILENT";
+  LogLevels2["DIRECT"] = "DIRECT";
+  LogLevels2["FATAL"] = "FATAL";
+  LogLevels2["ERROR"] = "ERROR";
+  LogLevels2["WARN"] = "WARN";
+  LogLevels2["INFO"] = "INFO";
+  LogLevels2["VERBOSE"] = "VERBOSE";
+  LogLevels2["DEBUG"] = "DEBUG";
+  LogLevels2["TRACE"] = "TRACE";
+  return LogLevels2;
+})(LogLevels || {});
+
+// src/utils/logger/logger.interface.ts
+var WINSTON_INSTANCE = "WINSTON_DEFAULT_LOGGER";
+
+// src/utils/logger/logger.ts
+var import_os = require("os");
+var import_winston = __toESM(require("winston"));
+
+// src/utils/color.ts
+var colorette = __toESM(require("colorette"));
+var color = colorette.createColors({ useColor: true });
+
+// src/utils/figures.ts
+var import_figures = __toESM(require("figures"));
+
+// src/utils/logger/logger.ts
+var Logger = class {
+  constructor(context, options) {
+    this.context = context;
+    this.options = options;
+    const level = options?.level.toUpperCase();
+    this.options = {
+      useIcons: true,
+      ...options,
+      level: Object.values(LogLevels).includes(level) ? level : "INFO" /* INFO */
+    };
+    if (Logger.instance) {
+      this.logger = Logger.instance;
+    } else {
+      this.logger = this.initiateLogger();
+      Logger.instance = this.logger;
+    }
+  }
+  log(level, data, ...args) {
+    return this.parseMessage(level, data, args);
+  }
+  direct(data, ...args) {
+    return this.parseMessage("DIRECT" /* DIRECT */, data, args);
+  }
+  fatal(data, ...args) {
+    return this.parseMessage("FATAL" /* FATAL */, data, args);
+  }
+  error(data, ...args) {
+    return this.parseMessage("ERROR" /* ERROR */, data, args);
+  }
+  warn(data, ...args) {
+    return this.parseMessage("WARN" /* WARN */, data, args);
+  }
+  info(data, ...args) {
+    return this.parseMessage("INFO" /* INFO */, data, args);
+  }
+  debug(data, ...args) {
+    return this.parseMessage("DEBUG" /* DEBUG */, data, args);
+  }
+  verbose(data, ...args) {
+    return this.parseMessage("VERBOSE" /* VERBOSE */, data, args);
+  }
+  trace(data, ...args) {
+    return this.parseMessage("TRACE" /* TRACE */, data, args);
+  }
+  run(data, ...args) {
+    return this.parseMessage("INFO" /* INFO */, data, args, { status: "RUN" /* RUN */ });
+  }
+  end(data, ...args) {
+    return this.parseMessage("INFO" /* INFO */, data, args, { status: "END" /* END */ });
+  }
+  initiateLogger() {
+    const logFormat = import_winston.format.printf(({ level, message, context, status }) => {
+      let multiLineMessage;
+      multiLineMessage = message.split(import_os.EOL);
+      multiLineMessage = multiLineMessage.filter((msg) => msg.trim() !== "").filter(Boolean);
+      multiLineMessage = multiLineMessage.map((msg) => {
+        return this.logColoring({
+          level,
+          message: msg,
+          context,
+          status
+        });
+      });
+      return multiLineMessage.join(import_os.EOL);
+    });
+    const logger = import_winston.default.loggers.add(WINSTON_INSTANCE, {
+      level: this.options.level,
+      format: import_winston.format.combine(import_winston.format.splat(), import_winston.format.json({ space: 2 }), import_winston.format.prettyPrint(), logFormat),
+      levels: Object.values(LogLevels).reduce((o, level, i) => {
+        return {
+          ...o,
+          [level]: i
+        };
+      }, {}),
+      silent: this.options.level === "SILENT" /* SILENT */,
+      transports: [
+        new import_winston.transports.Console({
+          stderrLevels: ["FATAL" /* FATAL */, "ERROR" /* ERROR */]
+        })
+      ]
+    });
+    logger.log("TRACE" /* TRACE */, "Initiated new logger with level: %s", this.options.level, { context: this.constructor.name });
+    return logger;
+  }
+  parseMessage(level, data, args, format2) {
+    this.logger.log(level, data.toString(), ...args ?? [], { context: this.context, ...format2 ?? {} });
+  }
+  logColoring({ level, message, context, status }) {
+    let icon;
+    let coloring = (input) => {
+      return input;
+    };
+    let msgColoring = (input) => {
+      return input;
+    };
+    switch (level) {
+      case "DIRECT" /* DIRECT */:
+        return message;
+      case "FATAL" /* FATAL */:
+        coloring = (input) => color.bgRed(color.white(input));
+        if (this.options?.useIcons) {
+          icon = import_figures.default.cross;
+        }
+        break;
+      case "ERROR" /* ERROR */:
+        coloring = color.red;
+        if (this.options?.useIcons) {
+          icon = import_figures.default.cross;
+        }
+        break;
+      case "WARN" /* WARN */:
+        coloring = color.yellow;
+        if (this.options?.useIcons) {
+          icon = import_figures.default.warning;
+        }
+        break;
+      case "INFO" /* INFO */:
+        coloring = color.green;
+        if (this.options?.useIcons) {
+          icon = import_figures.default.pointerSmall;
+        }
+        break;
+      case "VERBOSE" /* VERBOSE */:
+        coloring = color.dim;
+        if (this.options?.useIcons) {
+          icon = import_figures.default.circleQuestionMark;
+        }
+        break;
+      case "DEBUG" /* DEBUG */:
+        coloring = color.cyan;
+        msgColoring = color.dim;
+        if (this.options?.useIcons) {
+          icon = "\uF188";
+        }
+        break;
+      case "TRACE" /* TRACE */:
+        coloring = color.magenta;
+        msgColoring = color.dim;
+        if (this.options?.useIcons) {
+          icon = "\uF188";
+        }
+        break;
+    }
+    if (!icon) {
+      icon = `[${level.at(0).toUpperCase()}]`;
+    }
+    return `${coloring(icon)}${context ? " " + coloring(`[${context}]`) : ""}${status ? " " + coloring(`[${status}]`) : ""} ${msgColoring(message)}`;
+  }
+};
+
+// src/hooks/not-found.hook.ts
+var notFoundHook = async (opts) => {
+  const logger = new Logger(opts.config.name);
+  logger.fatal("Command not found. Take a look at help. You can also use --[h]elp flag for subcommands.", { custom: opts.config.name });
+  logger.direct("");
+  const help = new import_core.Help(opts.config);
+  await help.showHelp(["--all"]);
+  process.exit(127);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  notFoundHook
+});

package/dist/hooks/index.mjs

@@ -0,0 +1,200 @@
+// src/hooks/not-found.hook.ts
+import { Help } from "@oclif/core";
+
+// src/utils/logger/pipe/pipe-process-to-listr.ts
+import through from "through";
+
+// src/utils/logger/pipe/pipe-process-to-logger.ts
+import through2 from "through";
+
+// src/utils/logger/logger.constants.ts
+var LogLevels = /* @__PURE__ */ ((LogLevels2) => {
+  LogLevels2["SILENT"] = "SILENT";
+  LogLevels2["DIRECT"] = "DIRECT";
+  LogLevels2["FATAL"] = "FATAL";
+  LogLevels2["ERROR"] = "ERROR";
+  LogLevels2["WARN"] = "WARN";
+  LogLevels2["INFO"] = "INFO";
+  LogLevels2["VERBOSE"] = "VERBOSE";
+  LogLevels2["DEBUG"] = "DEBUG";
+  LogLevels2["TRACE"] = "TRACE";
+  return LogLevels2;
+})(LogLevels || {});
+
+// src/utils/logger/logger.interface.ts
+var WINSTON_INSTANCE = "WINSTON_DEFAULT_LOGGER";
+
+// src/utils/logger/logger.ts
+import { EOL } from "os";
+import winston, { format, transports } from "winston";
+
+// src/utils/color.ts
+import * as colorette from "colorette";
+var color = colorette.createColors({ useColor: true });
+
+// src/utils/figures.ts
+import figures from "figures";
+
+// src/utils/logger/logger.ts
+var Logger = class {
+  constructor(context, options) {
+    this.context = context;
+    this.options = options;
+    const level = options?.level.toUpperCase();
+    this.options = {
+      useIcons: true,
+      ...options,
+      level: Object.values(LogLevels).includes(level) ? level : "INFO" /* INFO */
+    };
+    if (Logger.instance) {
+      this.logger = Logger.instance;
+    } else {
+      this.logger = this.initiateLogger();
+      Logger.instance = this.logger;
+    }
+  }
+  log(level, data, ...args) {
+    return this.parseMessage(level, data, args);
+  }
+  direct(data, ...args) {
+    return this.parseMessage("DIRECT" /* DIRECT */, data, args);
+  }
+  fatal(data, ...args) {
+    return this.parseMessage("FATAL" /* FATAL */, data, args);
+  }
+  error(data, ...args) {
+    return this.parseMessage("ERROR" /* ERROR */, data, args);
+  }
+  warn(data, ...args) {
+    return this.parseMessage("WARN" /* WARN */, data, args);
+  }
+  info(data, ...args) {
+    return this.parseMessage("INFO" /* INFO */, data, args);
+  }
+  debug(data, ...args) {
+    return this.parseMessage("DEBUG" /* DEBUG */, data, args);
+  }
+  verbose(data, ...args) {
+    return this.parseMessage("VERBOSE" /* VERBOSE */, data, args);
+  }
+  trace(data, ...args) {
+    return this.parseMessage("TRACE" /* TRACE */, data, args);
+  }
+  run(data, ...args) {
+    return this.parseMessage("INFO" /* INFO */, data, args, { status: "RUN" /* RUN */ });
+  }
+  end(data, ...args) {
+    return this.parseMessage("INFO" /* INFO */, data, args, { status: "END" /* END */ });
+  }
+  initiateLogger() {
+    const logFormat = format.printf(({ level, message, context, status }) => {
+      let multiLineMessage;
+      multiLineMessage = message.split(EOL);
+      multiLineMessage = multiLineMessage.filter((msg) => msg.trim() !== "").filter(Boolean);
+      multiLineMessage = multiLineMessage.map((msg) => {
+        return this.logColoring({
+          level,
+          message: msg,
+          context,
+          status
+        });
+      });
+      return multiLineMessage.join(EOL);
+    });
+    const logger = winston.loggers.add(WINSTON_INSTANCE, {
+      level: this.options.level,
+      format: format.combine(format.splat(), format.json({ space: 2 }), format.prettyPrint(), logFormat),
+      levels: Object.values(LogLevels).reduce((o, level, i) => {
+        return {
+          ...o,
+          [level]: i
+        };
+      }, {}),
+      silent: this.options.level === "SILENT" /* SILENT */,
+      transports: [
+        new transports.Console({
+          stderrLevels: ["FATAL" /* FATAL */, "ERROR" /* ERROR */]
+        })
+      ]
+    });
+    logger.log("TRACE" /* TRACE */, "Initiated new logger with level: %s", this.options.level, { context: this.constructor.name });
+    return logger;
+  }
+  parseMessage(level, data, args, format2) {
+    this.logger.log(level, data.toString(), ...args ?? [], { context: this.context, ...format2 ?? {} });
+  }
+  logColoring({ level, message, context, status }) {
+    let icon;
+    let coloring = (input) => {
+      return input;
+    };
+    let msgColoring = (input) => {
+      return input;
+    };
+    switch (level) {
+      case "DIRECT" /* DIRECT */:
+        return message;
+      case "FATAL" /* FATAL */:
+        coloring = (input) => color.bgRed(color.white(input));
+        if (this.options?.useIcons) {
+          icon = figures.cross;
+        }
+        break;
+      case "ERROR" /* ERROR */:
+        coloring = color.red;
+        if (this.options?.useIcons) {
+          icon = figures.cross;
+        }
+        break;
+      case "WARN" /* WARN */:
+        coloring = color.yellow;
+        if (this.options?.useIcons) {
+          icon = figures.warning;
+        }
+        break;
+      case "INFO" /* INFO */:
+        coloring = color.green;
+        if (this.options?.useIcons) {
+          icon = figures.pointerSmall;
+        }
+        break;
+      case "VERBOSE" /* VERBOSE */:
+        coloring = color.dim;
+        if (this.options?.useIcons) {
+          icon = figures.circleQuestionMark;
+        }
+        break;
+      case "DEBUG" /* DEBUG */:
+        coloring = color.cyan;
+        msgColoring = color.dim;
+        if (this.options?.useIcons) {
+          icon = "\uF188";
+        }
+        break;
+      case "TRACE" /* TRACE */:
+        coloring = color.magenta;
+        msgColoring = color.dim;
+        if (this.options?.useIcons) {
+          icon = "\uF188";
+        }
+        break;
+    }
+    if (!icon) {
+      icon = `[${level.at(0).toUpperCase()}]`;
+    }
+    return `${coloring(icon)}${context ? " " + coloring(`[${context}]`) : ""}${status ? " " + coloring(`[${status}]`) : ""} ${msgColoring(message)}`;
+  }
+};
+
+// src/hooks/not-found.hook.ts
+var notFoundHook = async (opts) => {
+  const logger = new Logger(opts.config.name);
+  logger.fatal("Command not found. Take a look at help. You can also use --[h]elp flag for subcommands.", { custom: opts.config.name });
+  logger.direct("");
+  const help = new Help(opts.config);
+  await help.showHelp(["--all"]);
+  process.exit(127);
+};
+export {
+  notFoundHook
+};

package/dist/hooks/not-found.hook.d.ts

@@ -0,0 +1,5 @@
+import { Hook } from '@oclif/core';
+
+declare const notFoundHook: Hook<'command_not_found'>;
+
+export { notFoundHook };

package/dist/hooks/not-found.hook.js

@@ -0,0 +1,230 @@
+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(
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/hooks/not-found.hook.ts
+var not_found_hook_exports = {};
+__export(not_found_hook_exports, {
+  notFoundHook: () => notFoundHook
+});
+module.exports = __toCommonJS(not_found_hook_exports);
+var import_core = require("@oclif/core");
+
+// src/utils/logger/pipe/pipe-process-to-listr.ts
+var import_through = __toESM(require("through"));
+
+// src/utils/logger/pipe/pipe-process-to-logger.ts
+var import_through2 = __toESM(require("through"));
+
+// src/utils/logger/logger.constants.ts
+var LogLevels = /* @__PURE__ */ ((LogLevels2) => {
+  LogLevels2["SILENT"] = "SILENT";
+  LogLevels2["DIRECT"] = "DIRECT";
+  LogLevels2["FATAL"] = "FATAL";
+  LogLevels2["ERROR"] = "ERROR";
+  LogLevels2["WARN"] = "WARN";
+  LogLevels2["INFO"] = "INFO";
+  LogLevels2["VERBOSE"] = "VERBOSE";
+  LogLevels2["DEBUG"] = "DEBUG";
+  LogLevels2["TRACE"] = "TRACE";
+  return LogLevels2;
+})(LogLevels || {});
+
+// src/utils/logger/logger.interface.ts
+var WINSTON_INSTANCE = "WINSTON_DEFAULT_LOGGER";
+
+// src/utils/logger/logger.ts
+var import_os = require("os");
+var import_winston = __toESM(require("winston"));
+
+// src/utils/color.ts
+var colorette = __toESM(require("colorette"));
+var color = colorette.createColors({ useColor: true });
+
+// src/utils/figures.ts
+var import_figures = __toESM(require("figures"));
+
+// src/utils/logger/logger.ts
+var Logger = class {
+  constructor(context, options) {
+    this.context = context;
+    this.options = options;
+    const level = options?.level.toUpperCase();
+    this.options = {
+      useIcons: true,
+      ...options,
+      level: Object.values(LogLevels).includes(level) ? level : "INFO" /* INFO */
+    };
+    if (Logger.instance) {
+      this.logger = Logger.instance;
+    } else {
+      this.logger = this.initiateLogger();
+      Logger.instance = this.logger;
+    }
+  }
+  log(level, data, ...args) {
+    return this.parseMessage(level, data, args);
+  }
+  direct(data, ...args) {
+    return this.parseMessage("DIRECT" /* DIRECT */, data, args);
+  }
+  fatal(data, ...args) {
+    return this.parseMessage("FATAL" /* FATAL */, data, args);
+  }
+  error(data, ...args) {
+    return this.parseMessage("ERROR" /* ERROR */, data, args);
+  }
+  warn(data, ...args) {
+    return this.parseMessage("WARN" /* WARN */, data, args);
+  }
+  info(data, ...args) {
+    return this.parseMessage("INFO" /* INFO */, data, args);
+  }
+  debug(data, ...args) {
+    return this.parseMessage("DEBUG" /* DEBUG */, data, args);
+  }
+  verbose(data, ...args) {
+    return this.parseMessage("VERBOSE" /* VERBOSE */, data, args);
+  }
+  trace(data, ...args) {
+    return this.parseMessage("TRACE" /* TRACE */, data, args);
+  }
+  run(data, ...args) {
+    return this.parseMessage("INFO" /* INFO */, data, args, { status: "RUN" /* RUN */ });
+  }
+  end(data, ...args) {
+    return this.parseMessage("INFO" /* INFO */, data, args, { status: "END" /* END */ });
+  }
+  initiateLogger() {
+    const logFormat = import_winston.format.printf(({ level, message, context, status }) => {
+      let multiLineMessage;
+      multiLineMessage = message.split(import_os.EOL);
+      multiLineMessage = multiLineMessage.filter((msg) => msg.trim() !== "").filter(Boolean);
+      multiLineMessage = multiLineMessage.map((msg) => {
+        return this.logColoring({
+          level,
+          message: msg,
+          context,
+          status
+        });
+      });
+      return multiLineMessage.join(import_os.EOL);
+    });
+    const logger = import_winston.default.loggers.add(WINSTON_INSTANCE, {
+      level: this.options.level,
+      format: import_winston.format.combine(import_winston.format.splat(), import_winston.format.json({ space: 2 }), import_winston.format.prettyPrint(), logFormat),
+      levels: Object.values(LogLevels).reduce((o, level, i) => {
+        return {
+          ...o,
+          [level]: i
+        };
+      }, {}),
+      silent: this.options.level === "SILENT" /* SILENT */,
+      transports: [
+        new import_winston.transports.Console({
+          stderrLevels: ["FATAL" /* FATAL */, "ERROR" /* ERROR */]
+        })
+      ]
+    });
+    logger.log("TRACE" /* TRACE */, "Initiated new logger with level: %s", this.options.level, { context: this.constructor.name });
+    return logger;
+  }
+  parseMessage(level, data, args, format2) {
+    this.logger.log(level, data.toString(), ...args ?? [], { context: this.context, ...format2 ?? {} });
+  }
+  logColoring({ level, message, context, status }) {
+    let icon;
+    let coloring = (input) => {
+      return input;
+    };
+    let msgColoring = (input) => {
+      return input;
+    };
+    switch (level) {
+      case "DIRECT" /* DIRECT */:
+        return message;
+      case "FATAL" /* FATAL */:
+        coloring = (input) => color.bgRed(color.white(input));
+        if (this.options?.useIcons) {
+          icon = import_figures.default.cross;
+        }
+        break;
+      case "ERROR" /* ERROR */:
+        coloring = color.red;
+        if (this.options?.useIcons) {
+          icon = import_figures.default.cross;
+        }
+        break;
+      case "WARN" /* WARN */:
+        coloring = color.yellow;
+        if (this.options?.useIcons) {
+          icon = import_figures.default.warning;
+        }
+        break;
+      case "INFO" /* INFO */:
+        coloring = color.green;
+        if (this.options?.useIcons) {
+          icon = import_figures.default.pointerSmall;
+        }
+        break;
+      case "VERBOSE" /* VERBOSE */:
+        coloring = color.dim;
+        if (this.options?.useIcons) {
+          icon = import_figures.default.circleQuestionMark;
+        }
+        break;
+      case "DEBUG" /* DEBUG */:
+        coloring = color.cyan;
+        msgColoring = color.dim;
+        if (this.options?.useIcons) {
+          icon = "\uF188";
+        }
+        break;
+      case "TRACE" /* TRACE */:
+        coloring = color.magenta;
+        msgColoring = color.dim;
+        if (this.options?.useIcons) {
+          icon = "\uF188";
+        }
+        break;
+    }
+    if (!icon) {
+      icon = `[${level.at(0).toUpperCase()}]`;
+    }
+    return `${coloring(icon)}${context ? " " + coloring(`[${context}]`) : ""}${status ? " " + coloring(`[${status}]`) : ""} ${msgColoring(message)}`;
+  }
+};
+
+// src/hooks/not-found.hook.ts
+var notFoundHook = async (opts) => {
+  const logger = new Logger(opts.config.name);
+  logger.fatal("Command not found. Take a look at help. You can also use --[h]elp flag for subcommands.", { custom: opts.config.name });
+  logger.direct("");
+  const help = new import_core.Help(opts.config);
+  await help.showHelp(["--all"]);
+  process.exit(127);
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  notFoundHook
+});