@cenk1cenk2/oclif-common 2.1.0 → 2.2.0

package/dist/index.d.ts

@@ -134,15 +134,6 @@ declare class GenericParser {
     stringify<T = any>(data: T): string | Promise<string>;
 }
 
-declare class YamlParser implements GenericParser {
-    static extensions: string[];
-    static instance: YamlParser;
-    private readonly logger;
-    constructor();
-    parse<T = unknown>(data: string | Buffer): T;
-    stringify<T = any>(data: T): string;
-}
-
 declare class LockerService<LockFile extends LockableData = LockableData> {
     private file;
     private parser;
@@ -154,12 +145,12 @@ declare class LockerService<LockFile extends LockableData = LockableData> {
     constructor(file: string, parser: GenericParser, root?: string);
     hasLock(): boolean;
     hasUnlock(): boolean;
-    addLock<T extends LockableData>(data: LockData<T> | LockData<T>[]): void;
-    addUnlock(data?: UnlockData | UnlockData[]): void;
+    addLock<T extends LockableData = LockableData>(...data: LockData<T>[]): void;
+    addUnlock(data?: UnlockData[]): void;
     lockAll(): Promise<void>;
     unlockAll(): Promise<void>;
-    lock<T extends LockableData = LockableData>(data: LockData<T> | LockData<T>[]): Promise<void>;
-    unlock(data?: UnlockData | UnlockData[]): Promise<void>;
+    lock<T extends LockableData = LockableData>(...data: LockData<T>[]): Promise<void>;
+    unlock(...data: UnlockData[]): Promise<void>;
     read(): Promise<LockFile>;
     write(data: LockFile): Promise<void>;
     private buildPath;
@@ -190,7 +181,8 @@ declare class ConfigService<Config extends BaseConfig = BaseConfig> {
     parser: ParserService;
     private readonly logger;
     constructor(command: Command<any, Config>);
-    read<T extends LockableData = LockableData>(paths: string): Promise<T>;
+    read<T extends LockableData = LockableData>(path: string): Promise<T>;
+    extend<T extends LockableData = LockableData>(strategy: MergeStrategy, ...paths: string[]): Promise<T>;
     write<T extends LockableData = LockableData>(path: string, data: T): Promise<void>;
 }
 
@@ -216,6 +208,15 @@ declare class FileSystemService {
     mkdirSync(directory: string): void;
 }
 
+declare class YamlParser implements GenericParser {
+    static extensions: string[];
+    static instance: YamlParser;
+    private readonly logger;
+    constructor();
+    parse<T = unknown>(data: string | Buffer): T;
+    stringify<T = any>(data: T): string;
+}
+
 interface ValidatorServiceOptions {
     validator?: ValidatorOptions;
     transformer?: ClassTransformOptions;
@@ -257,31 +258,38 @@ declare class Command<Ctx extends ListrContext = ListrContext, Config extends Ba
      */
     shouldRunAfter(_ctx?: Ctx): void | Promise<void>;
     /** Run all tasks from task manager. */
-    runTasks(): Promise<Ctx>;
+    runTasks<C extends Ctx = Ctx>(): Promise<C>;
     /** Tasks to run before end of the command. */
-    finally(): Promise<{
-        ctx: Ctx;
+    finally<C extends Ctx = Ctx>(): Promise<{
+        ctx: C;
     }>;
     /** Catch any error occurred during command. */
     catch(e: Error): Promise<void>;
     /** Gets prompt from user. */
     prompt<T = any>(options: PromptOptions): Promise<T>;
+    setDefaultsInCtx<T = Ctx, K = Record<string, any>>(options: {
+        assign?: {
+            from: K;
+            keys: (keyof K)[];
+        };
+        default?: Partial<T>[];
+    }): void;
     exit(code?: number): void;
     private greet;
 }
 
 declare type ConfigCommandChoices<T extends string> = Record<T, () => void | Promise<void>>;
-interface ConfigCommandSetup<T extends string> {
+interface ConfigCommandSetup<T extends string = string, LockFile = any> {
     choices: ConfigCommandChoices<T>;
-    locker: LockerService;
+    locker: LockerService<LockFile>;
 }
 
-declare abstract class ConfigCommand<CommandChoices extends string, Ctx extends ListrContext = ListrContext, Config extends BaseConfig = BaseConfig> extends Command<Ctx, Config> {
+declare abstract class ConfigCommand<CommandChoices extends string = string, LockFile = any, Ctx extends ListrContext = ListrContext, Config extends BaseConfig = BaseConfig> extends Command<Ctx, Config> {
     choices: ConfigCommandChoices<CommandChoices>;
-    locker: LockerService;
+    locker: LockerService<LockFile>;
     run(): Promise<void>;
     private generate;
-    abstract setup(): ConfigCommandSetup<CommandChoices> | Promise<ConfigCommandSetup<CommandChoices>>;
+    abstract setup(): ConfigCommandSetup<CommandChoices, LockFile> | Promise<ConfigCommandSetup<CommandChoices, LockFile>>;
 }
 
 declare enum FileConstants {

package/dist/index.js

@@ -614,7 +614,7 @@ var _ParserService = class {
   }
   getParser(file) {
     const ext = this.fs.extname(file);
-    const Parser = this.parsers.find((parser) => parser.extensions.includes(ext.substring(1)));
+    const Parser = this.parsers.find((parser) => parser.extensions.includes(ext.replace(/^\./, "")));
     if (!Parser) {
       throw new Error(`Parser for the extension is not configured: ${ext}`);
     }
@@ -697,10 +697,11 @@ var ConfigService = class {
     this.parser = new ParserService();
     this.logger.trace("Created a new instance.");
   }
-  async read(strategy, ...paths) {
-    if (!Array.isArray(paths)) {
-      paths = [paths];
-    }
+  async read(path) {
+    const config2 = await this.parser.read(path);
+    return config2;
+  }
+  async extend(strategy, ...paths) {
     const configs = await Promise.all(
       paths.map(async (path) => {
         try {
@@ -712,7 +713,7 @@ var ConfigService = class {
         }
       })
     );
-    return merge(strategy ?? "OVERWRITE" /* OVERWRITE */, {}, ...configs);
+    return merge(strategy, {}, ...configs);
   }
   async write(path, data) {
     return this.parser.write(path, data);
@@ -742,28 +743,25 @@ var LockerService = class {
   hasUnlock() {
     return this.toUnlock.length > 0;
   }
-  addLock(data) {
-    this.toLock = [...this.toLock, ...Array.isArray(data) ? data : [data]];
+  addLock(...data) {
+    this.toLock = [...this.toLock, ...data];
   }
   addUnlock(data) {
-    this.toUnlock = [...this.toUnlock, ...Array.isArray(data) ? data : [data]];
+    this.toUnlock = [...this.toUnlock, ...data];
   }
   async lockAll() {
     if (this.hasLock()) {
-      await this.lock(this.toLock);
+      await this.lock(...this.toLock);
       this.toLock = [];
     }
   }
   async unlockAll() {
     if (this.toUnlock.length > 0) {
-      await this.unlock(this.toUnlock);
+      await this.unlock(...this.toUnlock);
       this.toUnlock = [];
     }
   }
-  async lock(data) {
-    if (!Array.isArray(data)) {
-      data = [data];
-    }
+  async lock(...data) {
     let lock = await this.read() ?? {};
     await Promise.all(
       data.map(async (d) => {
@@ -782,25 +780,22 @@ var LockerService = class {
             parsed = d.data;
           }
           lock = import_object_path_immutable.default.set(lock, path, parsed);
-          this.logger.verbose(`Merge lock: "${path}"`);
+          this.logger.verbose("Merge lock: %s", path);
         } else {
           lock = import_object_path_immutable.default.set(lock, path, d.data);
-          this.logger.verbose(`Override lock: "${path}"`);
+          this.logger.verbose("Override lock: %s", path);
         }
       })
     );
     await this.write(lock);
   }
-  async unlock(data) {
-    if (data && !Array.isArray(data)) {
-      data = [data];
-    }
+  async unlock(...data) {
     let lock = await this.read();
     if (!lock) {
       this.logger.verbose("Lock file not found. Nothing to unlock.");
       return;
     }
-    if (Array.isArray(data) && data.length > 0) {
+    if (data.length > 0) {
       await Promise.all(
         data.map(async (d) => {
           if (d?.enabled === false) {
@@ -808,12 +803,12 @@ var LockerService = class {
           }
           const path = this.buildPath(d);
           lock = import_object_path_immutable.default.del(lock, path);
-          this.logger.verbose(`Unlocked: ${path}`, { custom: "locker" });
+          this.logger.verbose("Unlocked: %s", path, { custom: "locker" });
         })
       );
     } else {
       lock = import_object_path_immutable.default.del(lock, this.root);
-      this.logger.verbose(`Unlocked module: ${this.root}`, { custom: "locker" });
+      this.logger.verbose("Unlocked module: %s", this.root, { custom: "locker" });
     }
     await this.write(lock);
   }
@@ -992,6 +987,16 @@ var Command = class extends import_core.Command {
       throw e;
     }
   }
+  setDefaultsInCtx(options) {
+    options.assign?.keys.forEach((i) => {
+      if (options.assign.from[i]) {
+        this.tasks.ctx[i] = options.assign.from[i];
+      }
+    });
+    options.default?.forEach((i) => {
+      Object.assign(this.tasks.ctx, i);
+    });
+  }
   exit(code) {
     this.logger.trace("Exitting with code: %d", code);
     process.exit(code ?? 0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cenk1cenk2/oclif-common",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "Oclif common package for oclif2 projects.",
   "repository": "https://gitlab.kilic.dev/libraries/oclif-tools",
   "author": {