@cenk1cenk2/oclif-common 3.9.6 → 3.9.8

package/dist/base.command-d3038122.d.ts

@@ -0,0 +1,77 @@
+import { Command as Command$1 } from '@oclif/core';
+import { ListrContext, Manager, PromptOptions } from 'listr2';
+import { Logger } from './utils/logger/logger.js';
+import { GlobalConfig } from './lib/config/config.interface.js';
+import { FileSystemService } from './lib/fs/filesystem.service.js';
+import { SetCtxDefaultsOptions, SetCtxAssignOptions } from './utils/defaults.js';
+import { ParserService } from './lib/parser/parser.service.js';
+import { StoreService } from './lib/store/store.service.js';
+import { ValidatorService } from './lib/validator/validator.service.js';
+import { InferFlags, InferArgs } from './interfaces/oclif.interface.js';
+import { LockableData } from './lib/locker/locker.interface.js';
+import { LogLevels } from './utils/logger/logger.constants.js';
+import { MergeStrategy } from './utils/merge.constants.js';
+
+declare class ConfigService implements GlobalConfig {
+    oclif: Command['config'];
+    command: Command['ctor'];
+    private static instance;
+    defaults: string;
+    root: string;
+    parser: ParserService;
+    logLevel: LogLevels;
+    isVerbose: boolean;
+    isDebug: boolean;
+    isSilent: boolean;
+    ci: boolean;
+    json: boolean;
+    private logger;
+    constructor(oclif: Command['config'], command: Command['ctor'], config: GlobalConfig);
+    read<T extends LockableData = LockableData>(path: string): Promise<T>;
+    extend<T extends LockableData = LockableData>(paths: (string | Partial<T>)[], strategy?: MergeStrategy): Promise<T>;
+    merge<T extends LockableData = LockableData>(configs: Partial<T>[], strategy?: MergeStrategy): T;
+    env<T extends LockableData = LockableData>(definition: string | Record<PropertyKey, any>, config: T): Promise<T>;
+    write<T extends LockableData = LockableData>(path: string, data: T): Promise<void>;
+    private recalculate;
+}
+
+declare class Command<Ctx extends ListrContext = ListrContext, Flags extends Record<PropertyKey, any> = InferFlags<typeof Command>, Args extends Record<PropertyKey, any> = InferArgs<typeof Command>, Store extends Record<PropertyKey, any> = Record<PropertyKey, any>> extends Command$1 {
+    context: string;
+    logger: Logger;
+    tasks: Manager<Ctx, 'default' | 'verbose' | 'silent' | 'simple'>;
+    validator: ValidatorService;
+    cs: ConfigService;
+    parser: ParserService;
+    fs: FileSystemService;
+    store: StoreService<Store>;
+    flags: Flags;
+    args: Args;
+    /**
+     * Construct the class if you dont want to extend init or constructor.
+     */
+    shouldRunBefore(): void | Promise<void>;
+    /**
+     * Deconstruct the class if you dont want to extend finally or catch.
+     */
+    shouldRunAfter(_ctx?: Ctx): void | Promise<void>;
+    run(): Promise<any>;
+    _run<T>(): Promise<T | undefined>;
+    exit(code?: number): void;
+    /** Run all tasks from task manager. */
+    runTasks<C extends Ctx = Ctx>(): Promise<C>;
+    /** Gets prompt from user. */
+    prompt<T = any>(options: PromptOptions): Promise<T>;
+    protected setCtxDefaults<T extends Ctx = Ctx>(...defaults: SetCtxDefaultsOptions<T>[]): void;
+    protected setCtxAssign<K = Record<PropertyKey, any>>(...assigns: SetCtxAssignOptions<K>[]): void;
+    /** Initial functions / constructor */
+    protected init(): Promise<void>;
+    /** Tasks to run before end of the command. */
+    protected finally<C extends Ctx = Ctx>(): Promise<{
+        ctx: C;
+    }>;
+    /** Catch any error occurred during command. */
+    protected catch(e: Error, exit?: number): Promise<void>;
+    private greet;
+}
+
+export { Command as C, ConfigService as a };

package/dist/commands/base.command.d.ts

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

package/dist/commands/base.command.js

@@ -0,0 +1,174 @@
+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 base_command_exports = {};
+__export(base_command_exports, {
+  Command: () => Command
+});
+module.exports = __toCommonJS(base_command_exports);
+var import_core = require("@oclif/core");
+var import_listr2 = require("listr2");
+var import_readline = require("readline");
+var import_reflect_metadata = require("reflect-metadata");
+var import_constants = require("../constants");
+var import_lib = require("../lib");
+var import_parser = require("../lib/parser/parser.service");
+var import_utils = require("../utils");
+var import_logger = require("../utils/logger");
+class Command extends import_core.Command {
+  constructor() {
+    super(...arguments);
+    this.flags = {};
+    this.args = {};
+  }
+  shouldRunBefore() {
+  }
+  shouldRunAfter(_ctx) {
+  }
+  run() {
+    throw new Error("The command should have a run function to do something!");
+  }
+  async _run() {
+    let result;
+    try {
+      delete process.env[this.config.scopedEnvVarKey("REDIRECTED")];
+      await this.init();
+      result = await this.run();
+      await this.finally();
+    } catch (error) {
+      await this.catch(error, 127);
+    }
+    if (result && this.jsonEnabled()) {
+      import_utils.CliUx.ux.styledJSON(this.toSuccessJson(result));
+    }
+    return result;
+  }
+  exit(code) {
+    this.logger.trace("Code -> %d", code, { status: import_logger.LogFieldStatus.EXIT });
+    process.exit(code ?? 0);
+  }
+  runTasks() {
+    return this.tasks.runAll();
+  }
+  prompt(options) {
+    return (0, import_listr2.createPrompt)(options, {
+      error: true,
+      stdout: process.stdout
+    });
+  }
+  setCtxDefaults(...defaults) {
+    (0, import_utils.setCtxDefaults)(this.tasks.options.ctx, ...defaults);
+    this.logger.trace("Updated context with defaults: %o", this.tasks.options.ctx, { status: "ctx" });
+  }
+  setCtxAssign(...assigns) {
+    (0, import_utils.setCtxAssign)(this.tasks.options.ctx, ...assigns);
+    this.logger.trace("Updated context with assign: %o", this.tasks.options.ctx, { status: "ctx" });
+  }
+  async init() {
+    this.constructor.flags = Object.assign({}, import_constants.CLI_FLAGS, this.constructor.flags);
+    await super.init();
+    let err;
+    try {
+      const { flags, args } = await this.parse();
+      this.flags = flags;
+      this.args = args;
+    } catch (e) {
+      err = e;
+    }
+    this.cs = new import_lib.ConfigService(this.config, this.ctor, {
+      logLevel: this.flags["log-level"],
+      ci: this.flags.ci,
+      json: this.flags.json
+    });
+    this.context = this.cs.command.id ? this.cs.command.id : this.cs.command.name;
+    this.logger = new import_logger.Logger(null, { level: this.cs.logLevel });
+    this.store = new import_lib.StoreService();
+    this.greet();
+    if (err) {
+      throw err;
+    }
+    this.logger.stage("Initiating services.");
+    this.parser = new import_parser.ParserService();
+    this.fs = new import_lib.FileSystemService();
+    this.validator = new import_lib.ValidatorService();
+    this.tasks = new import_listr2.Manager({
+      rendererFallback: this.cs.isDebug,
+      rendererSilent: this.cs.isSilent,
+      nonTTYRendererOptions: {
+        logEmptyTitle: false,
+        logTitleChange: false,
+        logger: import_logger.ListrLogger
+      },
+      ctx: {}
+    });
+    if (this.cs.oclif.windows) {
+      (0, import_readline.createInterface)({
+        input: process.stdin,
+        output: process.stdout
+      }).on("SIGINT", () => {
+        process.kill(process.pid, "SIGINT");
+      });
+    }
+    const terminate = /* @__PURE__ */ __name(() => {
+      this.logger.fatal("Caught terminate signal.", { status: import_logger.LogFieldStatus.TERMINATE });
+      process.exit(1);
+    }, "terminate");
+    process.on("SIGINT", terminate);
+    process.on("SIGTERM", terminate);
+    this.logger.stage("Running shouldRunBefore.");
+    await this.shouldRunBefore();
+    this.logger.stage("Finished shouldRunBefore.");
+  }
+  async finally() {
+    this.logger.stage("Running tasks.");
+    const ctx = await this.runTasks();
+    this.logger.stage("Finished tasks.");
+    this.logger.stage("Running shouldRunAfter.");
+    await this.shouldRunAfter(ctx);
+    this.logger.stage("Finished shouldRunAfter.");
+    return { ctx };
+  }
+  catch(e, exit) {
+    if (!this.logger) {
+      console.error("Logger has not been initiated yet!");
+      console.error(e.message);
+      console.debug(e.stack);
+    }
+    this.logger.fatal(e.message);
+    this.logger.debug(e.stack, { context: "crash" });
+    if (exit > 0) {
+      this.exit(exit);
+    }
+    return;
+  }
+  greet() {
+    if (this.cs.isSilent || this.cs.json) {
+      return;
+    }
+    const logo = this.store.get("logo") ?? `${this.cs.oclif.name} v${this.cs.oclif.version}`;
+    this.logger.direct(logo);
+    if (!this.store.has("logo")) {
+      this.logger.direct("-".repeat(logo.length));
+    }
+  }
+}
+__name(Command, "Command");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Command
+});

package/dist/commands/config.command.d.ts

@@ -0,0 +1,71 @@
+import * as _oclif_core_lib_cli_ux_styled_progress from '@oclif/core/lib/cli-ux/styled/progress';
+import * as _oclif_core_lib_cli_ux_open from '@oclif/core/lib/cli-ux/open';
+import * as _oclif_core_lib_cli_ux_styled_tree from '@oclif/core/lib/cli-ux/styled/tree';
+import * as _oclif_core_lib_cli_ux_styled_json from '@oclif/core/lib/cli-ux/styled/json';
+import * as _oclif_core_lib_cli_ux_styled_header from '@oclif/core/lib/cli-ux/styled/header';
+import * as _oclif_core_lib_cli_ux_prompt from '@oclif/core/lib/cli-ux/prompt';
+import * as _oclif_core_lib_errors from '@oclif/core/lib/errors';
+import { ListrContext } from 'listr2';
+import { C as Command } from '../base.command-d3038122.js';
+import { ConfigCommandChoices, ConfigCommandSetup } from '../interfaces/config-command.interface.js';
+import { InferFlags, InferArgs } from '../interfaces/oclif.interface.js';
+import { CliUx } from '@oclif/core';
+import { LockerService } from '../lib/locker/locker.service.js';
+import '../utils/logger/logger.js';
+import '../utils/logger/logger.constants.js';
+import '../utils/logger/logger.interface.js';
+import 'winston';
+import '../lib/config/config.interface.js';
+import '../lib/fs/filesystem.service.js';
+import 'fs-extra';
+import '../utils/defaults.js';
+import '../lib/parser/parser.service.js';
+import '../lib/parser/parser.interface.js';
+import '../interfaces/class.interface.js';
+import '../lib/locker/locker.interface.js';
+import '../utils/merge.constants.js';
+import '../lib/store/store.service.js';
+import '../lib/store/store.interface.js';
+import '../lib/validator/validator.service.js';
+import '../lib/validator/validator.interface.js';
+import 'class-transformer';
+import 'class-validator';
+import '@oclif/core/lib/interfaces';
+
+declare class ConfigCommand<CommandChoices extends string = string, LockFile = any, Ctx extends ListrContext = ListrContext, Flags extends Record<PropertyKey, any> = InferFlags<typeof ConfigCommand>, Args extends Record<PropertyKey, any> = InferArgs<typeof ConfigCommand>, Store extends Record<PropertyKey, any> = Record<PropertyKey, any>> extends Command<Ctx, Flags, Args, Store> {
+    choices: ConfigCommandChoices<CommandChoices>;
+    locker: LockerService<LockFile>;
+    protected ux: {
+        config: CliUx.Config;
+        warn: typeof _oclif_core_lib_errors.warn;
+        error: typeof _oclif_core_lib_errors.error;
+        exit: typeof _oclif_core_lib_errors.exit;
+        readonly prompt: typeof _oclif_core_lib_cli_ux_prompt.prompt;
+        readonly anykey: typeof _oclif_core_lib_cli_ux_prompt.anykey;
+        readonly confirm: typeof _oclif_core_lib_cli_ux_prompt.confirm;
+        readonly action: CliUx.ActionBase;
+        readonly prideAction: CliUx.ActionBase;
+        styledObject(obj: any, keys?: string[]): void;
+        readonly styledHeader: typeof _oclif_core_lib_cli_ux_styled_header.default;
+        readonly styledJSON: typeof _oclif_core_lib_cli_ux_styled_json.default;
+        readonly table: typeof CliUx.Table.table;
+        readonly tree: typeof _oclif_core_lib_cli_ux_styled_tree.default;
+        readonly open: typeof _oclif_core_lib_cli_ux_open.default;
+        readonly wait: (ms?: number) => Promise<unknown>;
+        readonly progress: typeof _oclif_core_lib_cli_ux_styled_progress.default;
+        done(): Promise<void>;
+        trace(format: string, ...args: string[]): void;
+        debug(format: string, ...args: string[]): void;
+        info(format: string, ...args: string[]): void;
+        log(format?: string, ...args: string[]): void;
+        url(text: string, uri: string, params?: {}): void;
+        annotation(text: string, annotation: string): void;
+        flush(ms?: number): Promise<void>;
+    };
+    run(): Promise<any>;
+    setup(): ConfigCommandSetup<CommandChoices, LockFile> | Promise<ConfigCommandSetup<CommandChoices, LockFile>>;
+    protected table(...options: Parameters<typeof CliUx.ux.table>): void;
+    protected select(): Promise<string>;
+}
+
+export { ConfigCommand };

package/dist/commands/config.command.js

@@ -0,0 +1,60 @@
+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 config_command_exports = {};
+__export(config_command_exports, {
+  ConfigCommand: () => ConfigCommand
+});
+module.exports = __toCommonJS(config_command_exports);
+var import_base = require("./base.command");
+var import_utils = require("../utils");
+class ConfigCommand extends import_base.Command {
+  constructor() {
+    super(...arguments);
+    this.ux = import_utils.CliUx.ux;
+  }
+  async run() {
+    this.logger.stage("Setting up config command.");
+    const setup = await this.setup();
+    this.choices = setup.choices;
+    this.locker = setup.locker;
+    this.logger.stage("User selection for configuration.");
+    const response = await this.select();
+    this.logger.stage("Will run selection: %s", response);
+    return this.choices[response].bind(this)();
+  }
+  setup() {
+    throw new Error("The command should be setup first!");
+  }
+  table(...options) {
+    this.ux.table(...options);
+  }
+  async select() {
+    const response = await this.prompt({
+      type: "Select",
+      message: "Please select what to do with the configuration.",
+      choices: Object.keys(this.choices)
+    });
+    return response;
+  }
+}
+__name(ConfigCommand, "ConfigCommand");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConfigCommand
+});

package/dist/commands/index.d.ts

@@ -0,0 +1,34 @@
+export { C as Command } from '../base.command-d3038122.js';
+export { ConfigCommand } from './config.command.js';
+import '@oclif/core';
+import 'listr2';
+import '../utils/logger/logger.js';
+import '../utils/logger/logger.constants.js';
+import '../utils/logger/logger.interface.js';
+import 'winston';
+import '../lib/config/config.interface.js';
+import '../lib/fs/filesystem.service.js';
+import 'fs-extra';
+import '../utils/defaults.js';
+import '../lib/parser/parser.service.js';
+import '../lib/parser/parser.interface.js';
+import '../interfaces/class.interface.js';
+import '../lib/locker/locker.interface.js';
+import '../utils/merge.constants.js';
+import '../lib/store/store.service.js';
+import '../lib/store/store.interface.js';
+import '../lib/validator/validator.service.js';
+import '../lib/validator/validator.interface.js';
+import 'class-transformer';
+import 'class-validator';
+import '../interfaces/oclif.interface.js';
+import '@oclif/core/lib/interfaces';
+import '@oclif/core/lib/cli-ux/styled/progress';
+import '@oclif/core/lib/cli-ux/open';
+import '@oclif/core/lib/cli-ux/styled/tree';
+import '@oclif/core/lib/cli-ux/styled/json';
+import '@oclif/core/lib/cli-ux/styled/header';
+import '@oclif/core/lib/cli-ux/prompt';
+import '@oclif/core/lib/errors';
+import '../interfaces/config-command.interface.js';
+import '../lib/locker/locker.service.js';

package/dist/commands/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 commands_exports = {};
+module.exports = __toCommonJS(commands_exports);
+__reExport(commands_exports, require("./base.command"), module.exports);
+__reExport(commands_exports, require("./config.command"), module.exports);

package/dist/constants/file.constants.d.ts

@@ -0,0 +1,5 @@
+declare enum FileConstants {
+    CONFIG_SERVICE_DEFAULTS_DIR = "config"
+}
+
+export { FileConstants };

package/dist/constants/file.constants.js

@@ -0,0 +1,30 @@
+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 file_constants_exports = {};
+__export(file_constants_exports, {
+  FileConstants: () => FileConstants
+});
+module.exports = __toCommonJS(file_constants_exports);
+var FileConstants = /* @__PURE__ */ ((FileConstants2) => {
+  FileConstants2["CONFIG_SERVICE_DEFAULTS_DIR"] = "config";
+  return FileConstants2;
+})(FileConstants || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FileConstants
+});

package/dist/constants/global-flags.constants.d.ts

@@ -0,0 +1,5 @@
+import { FlagInput } from '@oclif/core/lib/interfaces';
+
+declare const CLI_FLAGS: FlagInput;
+
+export { CLI_FLAGS };

package/dist/constants/global-flags.constants.js

@@ -0,0 +1,53 @@
+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 global_flags_constants_exports = {};
+__export(global_flags_constants_exports, {
+  CLI_FLAGS: () => CLI_FLAGS
+});
+module.exports = __toCommonJS(global_flags_constants_exports);
+var import_help_groups = require("./help-groups.constants");
+var import_interfaces = require("../interfaces");
+var import_logger = require("../utils/logger");
+const CLI_FLAGS = {
+  ["log-level"]: import_interfaces.Flags.enum({
+    default: import_logger.LogLevels.INFO,
+    env: "LOG_LEVEL",
+    description: "Set the log level of the application.",
+    options: [...Object.values(import_logger.LogLevels).map((level) => level.toLowerCase())],
+    helpGroup: import_help_groups.HelpGroups.CLI,
+    parse: async (input) => input?.toUpperCase()
+  }),
+  ci: import_interfaces.Flags.boolean({
+    default: false,
+    hidden: true,
+    env: "CI",
+    description: "Instruct whether this is running the CI/CD configuration.",
+    helpGroup: import_help_groups.HelpGroups.CLI
+  }),
+  json: import_interfaces.Flags.boolean({
+    default: false,
+    hidden: true,
+    env: "JSON",
+    description: "Put the CLI to respond in JSON.",
+    helpGroup: import_help_groups.HelpGroups.CLI
+  })
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CLI_FLAGS
+});

package/dist/constants/help-groups.constants.d.ts

@@ -0,0 +1,5 @@
+declare enum HelpGroups {
+    CLI = "CLI"
+}
+
+export { HelpGroups };

package/dist/constants/help-groups.constants.js

@@ -0,0 +1,30 @@
+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 help_groups_constants_exports = {};
+__export(help_groups_constants_exports, {
+  HelpGroups: () => HelpGroups
+});
+module.exports = __toCommonJS(help_groups_constants_exports);
+var HelpGroups = /* @__PURE__ */ ((HelpGroups2) => {
+  HelpGroups2["CLI"] = "CLI";
+  return HelpGroups2;
+})(HelpGroups || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  HelpGroups
+});

package/dist/constants/index.d.ts

@@ -0,0 +1,4 @@
+export { FileConstants } from './file.constants.js';
+export { CLI_FLAGS } from './global-flags.constants.js';
+export { HelpGroups } from './help-groups.constants.js';
+import '@oclif/core/lib/interfaces';

package/dist/constants/index.js

@@ -0,0 +1,19 @@
+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 constants_exports = {};
+module.exports = __toCommonJS(constants_exports);
+__reExport(constants_exports, require("./file.constants"), module.exports);
+__reExport(constants_exports, require("./global-flags.constants"), module.exports);
+__reExport(constants_exports, require("./help-groups.constants"), module.exports);

package/dist/hooks/index.d.ts

@@ -1,4 +1,6 @@
 export { notFoundHook } from './not-found.hook.js';
 export { updateNotifierHook } from './update-notifier.hook.js';
-export { s as storeHook } from '../store.hook-519df5f8.js';
+export { storeHook } from './store.hook.js';
 import '@oclif/core';
+import '../lib/store/store.service.js';
+import '../lib/store/store.interface.js';