@initx-plugin/core 0.0.6 → 0.0.8

package/dist/index.cjs

@@ -0,0 +1,54 @@
+'use strict';
+
+class InitxHandler {
+  run(options, ...others) {
+    const handlers = [];
+    if (!Array.isArray(this.matchers) && this.matchers.matching && this.matchers.description && this.isPassed(this.matchers.matching, options.key)) {
+      handlers.push({
+        handler: () => this.handle(options, ...others),
+        description: this.matchers.description
+      });
+      return handlers;
+    }
+    if (this.isObject(this.matchers)) {
+      const keys = Object.keys(this.matchers);
+      for (let i = 0; i < keys.length; i++) {
+        const matcher = this.matchers[keys[i]];
+        const isPassed = this.isPassed(matcher.matching, options.key);
+        if (isPassed) {
+          handlers.push({
+            handler: () => this.handle(options, keys[i], ...others),
+            description: matcher.description
+          });
+          break;
+        }
+      }
+      return handlers;
+    }
+    for (let i = 0; i < this.matchers.length; i++) {
+      const matcher = this.matchers[i];
+      const isPassed = this.isPassed(matcher.matching, options.key);
+      if (isPassed) {
+        handlers.push({
+          handler: () => this.handle(options, ...others),
+          description: matcher.description
+        });
+      }
+    }
+    return handlers;
+  }
+  isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+  isPassed(matchers, key) {
+    const tests = Array.isArray(matchers) ? matchers : [matchers];
+    return tests.some((test) => {
+      if (typeof test === "string") {
+        return test === key;
+      }
+      return test.test(key);
+    });
+  }
+}
+
+exports.InitxHandler = InitxHandler;

package/dist/index.d.cts

@@ -0,0 +1,47 @@
+type MaybeArray<T> = T | T[];
+type MaybePromise<T> = T | Promise<T>;
+interface BaseMatchers {
+    matching: MaybeArray<string | RegExp>;
+    /**
+     * Description of the handler
+     *
+     * If multiple handlers are matched, this description will be displayed
+     */
+    description: string;
+}
+type TypeMatchers = Record<string, BaseMatchers>;
+type Matchers = MaybeArray<BaseMatchers> | TypeMatchers;
+interface HandlerInfo {
+    handler: () => MaybePromise<void>;
+    description: string;
+}
+interface InitxOptions {
+    /**
+     * Matching string
+     *
+     * The key that was used to match the handler
+     */
+    key: string;
+    /**
+     * CLI options
+     *
+     * cac package parsed options
+     */
+    cliOptions: Record<string, any>;
+    /**
+     * Options list
+     *
+     * cli options list, like
+     * @example ['--global']
+     */
+    optionsList: string[];
+}
+declare abstract class InitxHandler {
+    abstract matchers: Matchers;
+    abstract handle(options: InitxOptions, ...others: string[]): MaybePromise<void>;
+    run(options: InitxOptions, ...others: string[]): HandlerInfo[];
+    private isObject;
+    private isPassed;
+}
+
+export { InitxHandler, type InitxOptions };

package/dist/index.d.mts

@@ -1,15 +1,47 @@
 type MaybeArray<T> = T | T[];
 type MaybePromise<T> = T | Promise<T>;
-type BaseMatchers = MaybeArray<string | RegExp>;
+interface BaseMatchers {
+    matching: MaybeArray<string | RegExp>;
+    /**
+     * Description of the handler
+     *
+     * If multiple handlers are matched, this description will be displayed
+     */
+    description: string;
+}
 type TypeMatchers = Record<string, BaseMatchers>;
-type Matchers = BaseMatchers | TypeMatchers;
+type Matchers = MaybeArray<BaseMatchers> | TypeMatchers;
+interface HandlerInfo {
+    handler: () => MaybePromise<void>;
+    description: string;
+}
+interface InitxOptions {
+    /**
+     * Matching string
+     *
+     * The key that was used to match the handler
+     */
+    key: string;
+    /**
+     * CLI options
+     *
+     * cac package parsed options
+     */
+    cliOptions: Record<string, any>;
+    /**
+     * Options list
+     *
+     * cli options list, like
+     * @example ['--global']
+     */
+    optionsList: string[];
+}
 declare abstract class InitxHandler {
     abstract matchers: Matchers;
-    abstract handle(value: string, ...others: string[]): MaybePromise<void>;
-    abstract handle<T>(value: string, type: T, ...others: string[]): MaybePromise<void>;
-    run(value: string, ...others: string[]): Promise<void>;
+    abstract handle(options: InitxOptions, ...others: string[]): MaybePromise<void>;
+    run(options: InitxOptions, ...others: string[]): HandlerInfo[];
     private isObject;
     private isPassed;
 }
 
-export { InitxHandler };
+export { InitxHandler, type InitxOptions };

package/dist/index.d.ts

@@ -1,15 +1,47 @@
 type MaybeArray<T> = T | T[];
 type MaybePromise<T> = T | Promise<T>;
-type BaseMatchers = MaybeArray<string | RegExp>;
+interface BaseMatchers {
+    matching: MaybeArray<string | RegExp>;
+    /**
+     * Description of the handler
+     *
+     * If multiple handlers are matched, this description will be displayed
+     */
+    description: string;
+}
 type TypeMatchers = Record<string, BaseMatchers>;
-type Matchers = BaseMatchers | TypeMatchers;
+type Matchers = MaybeArray<BaseMatchers> | TypeMatchers;
+interface HandlerInfo {
+    handler: () => MaybePromise<void>;
+    description: string;
+}
+interface InitxOptions {
+    /**
+     * Matching string
+     *
+     * The key that was used to match the handler
+     */
+    key: string;
+    /**
+     * CLI options
+     *
+     * cac package parsed options
+     */
+    cliOptions: Record<string, any>;
+    /**
+     * Options list
+     *
+     * cli options list, like
+     * @example ['--global']
+     */
+    optionsList: string[];
+}
 declare abstract class InitxHandler {
     abstract matchers: Matchers;
-    abstract handle(value: string, ...others: string[]): MaybePromise<void>;
-    abstract handle<T>(value: string, type: T, ...others: string[]): MaybePromise<void>;
-    run(value: string, ...others: string[]): Promise<void>;
+    abstract handle(options: InitxOptions, ...others: string[]): MaybePromise<void>;
+    run(options: InitxOptions, ...others: string[]): HandlerInfo[];
     private isObject;
     private isPassed;
 }
 
-export { InitxHandler };
+export { InitxHandler, type InitxOptions };

package/dist/index.mjs

@@ -1,33 +1,50 @@
 class InitxHandler {
-  async run(value, ...others) {
+  run(options, ...others) {
+    const handlers = [];
+    if (!Array.isArray(this.matchers) && this.matchers.matching && this.matchers.description && this.isPassed(this.matchers.matching, options.key)) {
+      handlers.push({
+        handler: () => this.handle(options, ...others),
+        description: this.matchers.description
+      });
+      return handlers;
+    }
     if (this.isObject(this.matchers)) {
       const keys = Object.keys(this.matchers);
       for (let i = 0; i < keys.length; i++) {
         const matcher = this.matchers[keys[i]];
-        const isPassed2 = this.isPassed(matcher, value);
-        if (isPassed2) {
-          this.handle(value, keys[i], ...others);
+        const isPassed = this.isPassed(matcher.matching, options.key);
+        if (isPassed) {
+          handlers.push({
+            handler: () => this.handle(options, keys[i], ...others),
+            description: matcher.description
+          });
           break;
         }
       }
-      return;
+      return handlers;
     }
-    const isPassed = this.isPassed(this.matchers, value);
-    if (!isPassed) {
-      return;
+    for (let i = 0; i < this.matchers.length; i++) {
+      const matcher = this.matchers[i];
+      const isPassed = this.isPassed(matcher.matching, options.key);
+      if (isPassed) {
+        handlers.push({
+          handler: () => this.handle(options, ...others),
+          description: matcher.description
+        });
+      }
     }
-    await this.handle(value, ...others);
+    return handlers;
   }
   isObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
   }
-  isPassed(matchers, value) {
+  isPassed(matchers, key) {
     const tests = Array.isArray(matchers) ? matchers : [matchers];
     return tests.some((test) => {
       if (typeof test === "string") {
-        return test === value;
+        return test === key;
       }
-      return test.test(value);
+      return test.test(key);
     });
   }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@initx-plugin/core",
   "type": "module",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "core module for initx plugins",
   "author": "imba97",
   "license": "MIT",
@@ -16,7 +16,7 @@
   "keywords": [
     "initx"
   ],
-  "main": "dist/index.mjs",
+  "main": "dist/index.cjs",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
   "files": [