@initx-plugin/core 0.0.18 → 0.0.20

package/dist/index.d.mts

@@ -1,3 +1,21 @@
+interface PackageInfo {
+    root: string;
+    name: string;
+    version: string;
+    description: string;
+    author: string;
+    homepage?: string;
+}
+interface InitxPluginInfo {
+    packageInfo: PackageInfo;
+    instance: InitxPlugin;
+}
+type MatchedPlugin = HandlerInfo & {
+    packageInfo: PackageInfo;
+};
+declare function loadPlugins(): Promise<InitxPluginInfo[]>;
+declare function matchPlugins(plugins: InitxPluginInfo[], { key, cliOptions }: InitxBaseContext, ...others: string[]): MatchedPlugin[];
+
 type MaybeArray<T> = T | T[];
 type MaybePromise<T> = T | Promise<T>;
 interface BaseMatchers {
@@ -11,11 +29,12 @@ interface BaseMatchers {
 }
 type TypeMatchers = Record<string, BaseMatchers>;
 type Matchers = MaybeArray<BaseMatchers> | TypeMatchers;
+type PluginConfig = Record<string, any>;
 interface HandlerInfo {
     handler: () => MaybePromise<void>;
     description: string;
 }
-interface InitxCtx {
+interface InitxBaseContext {
     /**
      * Matching string
      *
@@ -36,10 +55,23 @@ interface InitxCtx {
      */
     optionsList: string[];
 }
-declare abstract class InitxHandler {
+interface InitxContext<TConfig extends PluginConfig = PluginConfig> extends InitxBaseContext {
+    /**
+     * Store
+     *
+     * Store data in memory, and write to disk when the program exits
+     */
+    store: TConfig;
+    /**
+     * Package info
+     */
+    packageInfo: PackageInfo;
+}
+declare abstract class InitxPlugin<TConfig extends PluginConfig = PluginConfig> {
     abstract matchers: Matchers;
-    abstract handle(options: InitxCtx, ...others: string[]): MaybePromise<void>;
-    run(options: InitxCtx, ...others: string[]): HandlerInfo[];
+    abstract handle(options: InitxContext<TConfig>, ...others: string[]): MaybePromise<void>;
+    defaultConfig?: TConfig;
+    run(context: InitxContext<TConfig>, ...others: string[]): HandlerInfo[];
     private matchBaseMatchers;
     private matchArrayBaseMatchers;
     private matchTypeMatchers;
@@ -47,19 +79,10 @@ declare abstract class InitxHandler {
     private isArrayBaseMatchers;
     private isObject;
     private isPassed;
+    private executeHandle;
 }
 
-interface PackageInfo {
-    name: string;
-    version: string;
-    description: string;
-    author: string;
-    homepage?: string;
-}
-interface InitxPlugin {
-    packageInfo: PackageInfo;
-    handler: InitxHandler;
-}
-declare function loadPlugins(): Promise<InitxPlugin[]>;
+declare function createStore({ name }: PackageInfo, defaultStore?: Record<string, any>): any;
+declare function writeStore({ name }: PackageInfo): void;
 
-export { type HandlerInfo, type InitxCtx, InitxHandler, type InitxPlugin, type PackageInfo, loadPlugins };
+export { type HandlerInfo, type InitxBaseContext, type InitxContext, InitxPlugin, type InitxPluginInfo, type MatchedPlugin, type PackageInfo, createStore, loadPlugins, matchPlugins, writeStore };

package/dist/index.d.ts

@@ -1,3 +1,21 @@
+interface PackageInfo {
+    root: string;
+    name: string;
+    version: string;
+    description: string;
+    author: string;
+    homepage?: string;
+}
+interface InitxPluginInfo {
+    packageInfo: PackageInfo;
+    instance: InitxPlugin;
+}
+type MatchedPlugin = HandlerInfo & {
+    packageInfo: PackageInfo;
+};
+declare function loadPlugins(): Promise<InitxPluginInfo[]>;
+declare function matchPlugins(plugins: InitxPluginInfo[], { key, cliOptions }: InitxBaseContext, ...others: string[]): MatchedPlugin[];
+
 type MaybeArray<T> = T | T[];
 type MaybePromise<T> = T | Promise<T>;
 interface BaseMatchers {
@@ -11,11 +29,12 @@ interface BaseMatchers {
 }
 type TypeMatchers = Record<string, BaseMatchers>;
 type Matchers = MaybeArray<BaseMatchers> | TypeMatchers;
+type PluginConfig = Record<string, any>;
 interface HandlerInfo {
     handler: () => MaybePromise<void>;
     description: string;
 }
-interface InitxCtx {
+interface InitxBaseContext {
     /**
      * Matching string
      *
@@ -36,10 +55,23 @@ interface InitxCtx {
      */
     optionsList: string[];
 }
-declare abstract class InitxHandler {
+interface InitxContext<TConfig extends PluginConfig = PluginConfig> extends InitxBaseContext {
+    /**
+     * Store
+     *
+     * Store data in memory, and write to disk when the program exits
+     */
+    store: TConfig;
+    /**
+     * Package info
+     */
+    packageInfo: PackageInfo;
+}
+declare abstract class InitxPlugin<TConfig extends PluginConfig = PluginConfig> {
     abstract matchers: Matchers;
-    abstract handle(options: InitxCtx, ...others: string[]): MaybePromise<void>;
-    run(options: InitxCtx, ...others: string[]): HandlerInfo[];
+    abstract handle(options: InitxContext<TConfig>, ...others: string[]): MaybePromise<void>;
+    defaultConfig?: TConfig;
+    run(context: InitxContext<TConfig>, ...others: string[]): HandlerInfo[];
     private matchBaseMatchers;
     private matchArrayBaseMatchers;
     private matchTypeMatchers;
@@ -47,19 +79,10 @@ declare abstract class InitxHandler {
     private isArrayBaseMatchers;
     private isObject;
     private isPassed;
+    private executeHandle;
 }
 
-interface PackageInfo {
-    name: string;
-    version: string;
-    description: string;
-    author: string;
-    homepage?: string;
-}
-interface InitxPlugin {
-    packageInfo: PackageInfo;
-    handler: InitxHandler;
-}
-declare function loadPlugins(): Promise<InitxPlugin[]>;
+declare function createStore({ name }: PackageInfo, defaultStore?: Record<string, any>): any;
+declare function writeStore({ name }: PackageInfo): void;
 
-export { type HandlerInfo, type InitxCtx, InitxHandler, type InitxPlugin, type PackageInfo, loadPlugins };
+export { type HandlerInfo, type InitxBaseContext, type InitxContext, InitxPlugin, type InitxPluginInfo, type MatchedPlugin, type PackageInfo, createStore, loadPlugins, matchPlugins, writeStore };

package/dist/index.mjs

@@ -1,55 +1,127 @@
 import path from 'node:path';
+import { homedir } from 'node:os';
 import fs from 'fs-extra';
+import { defu } from 'defu';
 import { c } from '@initx-plugin/utils';
 
-class InitxHandler {
-  run(options, ...others) {
+const INITX_DIR = path.resolve(homedir(), ".initx");
+const STORE_FILE_NAME = "store.json";
+const REWRITED_FILE_NAME = ".rewrited";
+const resolveStore = (name) => path.resolve(INITX_DIR, name, STORE_FILE_NAME);
+const resolveRewrited = (name) => path.resolve(INITX_DIR, name, REWRITED_FILE_NAME);
+function createStore({ name }, defaultStore = {}) {
+  fs.ensureDirSync(path.resolve(INITX_DIR, name));
+  const storePath = resolveStore(name);
+  const generateResult = (resultData) => {
+    writeJson(storePath, resultData);
+    return useProxy(name, resultData);
+  };
+  if (!fs.existsSync(storePath)) {
+    return generateResult(defaultStore);
+  }
+  let json;
+  try {
+    const fileJson = fs.readJsonSync(storePath);
+    json = defu(fileJson, defaultStore);
+  } catch (e) {
+    json = defaultStore;
+  }
+  return generateResult(json);
+}
+function writeStore({ name }) {
+  const rewritedPath = resolveRewrited(name);
+  if (!fs.existsSync(rewritedPath)) {
+    return;
+  }
+  const rewrited = fs.readJsonSync(rewritedPath);
+  writeJson(resolveStore(name), rewrited);
+  fs.removeSync(rewritedPath);
+}
+function writeJson(path2, data) {
+  fs.writeJsonSync(path2, data, {
+    spaces: 2
+  });
+}
+function useProxy(name, obj = {}) {
+  const isPlainObject = (value) => {
+    return Object.prototype.toString.call(value) === "[object Object]";
+  };
+  const createDeepProxy = (target) => {
+    return new Proxy(target, {
+      get(target2, key) {
+        const value = Reflect.get(target2, key);
+        if (isPlainObject(value)) {
+          return createDeepProxy(value);
+        }
+        return value;
+      },
+      set(target2, key, value) {
+        const success = Reflect.set(target2, key, value);
+        fs.writeJsonSync(resolveRewrited(name), target2);
+        return success;
+      }
+    });
+  };
+  return createDeepProxy(obj);
+}
+
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+class InitxPlugin {
+  constructor() {
+    __publicField(this, "defaultConfig");
+  }
+  run(context, ...others) {
     if (this.isBaseMatchers(this.matchers)) {
-      return this.matchBaseMatchers(this.matchers, options, ...others);
+      return this.matchBaseMatchers(this.matchers, context, ...others);
     }
     if (this.isArrayBaseMatchers(this.matchers)) {
-      return this.matchArrayBaseMatchers(this.matchers, options, ...others);
+      return this.matchArrayBaseMatchers(this.matchers, context, ...others);
     }
     if (this.isObject(this.matchers)) {
-      return this.matchTypeMatchers(this.matchers, options, ...others);
+      return this.matchTypeMatchers(this.matchers, context, ...others);
     }
     return [];
   }
   // BaseMatchers
-  matchBaseMatchers(matchers, options, ...others) {
-    if (!this.isPassed(matchers.matching, options.key)) {
+  matchBaseMatchers(matchers, context, ...others) {
+    if (!this.isPassed(matchers.matching, context.key)) {
       return [];
     }
     return [
       {
-        handler: () => this.handle(options, ...others),
+        handler: () => this.executeHandle(context, ...others),
         description: matchers.description
       }
     ];
   }
-  matchArrayBaseMatchers(matchers, options, ...others) {
+  matchArrayBaseMatchers(matchers, context, ...others) {
     const handlers = [];
     for (let i = 0; i < matchers.length; i++) {
       const matcher = matchers[i];
-      const isPassed = this.isPassed(matcher.matching, options.key);
+      const isPassed = this.isPassed(matcher.matching, context.key);
       if (isPassed) {
         handlers.push({
-          handler: () => this.handle(options, ...others),
+          handler: () => this.executeHandle(context, ...others),
           description: matcher.description
         });
       }
     }
     return handlers;
   }
-  matchTypeMatchers(matchers, options, ...others) {
+  matchTypeMatchers(matchers, context, ...others) {
     const handlers = [];
     const keys = Object.keys(matchers);
     for (let i = 0; i < keys.length; i++) {
       const matcher = matchers[keys[i]];
-      const isPassed = this.isPassed(matcher.matching, options.key);
+      const isPassed = this.isPassed(matcher.matching, context.key);
       if (isPassed) {
         handlers.push({
-          handler: () => this.handle(options, keys[i], ...others),
+          handler: () => this.executeHandle(context, keys[i], ...others),
           description: matcher.description
         });
       }
@@ -75,6 +147,10 @@ class InitxHandler {
       return test.test(key);
     });
   }
+  async executeHandle(context, ...others) {
+    await this.handle(context, ...others);
+    writeStore(context.packageInfo);
+  }
 }
 
 async function loadPlugins() {
@@ -83,17 +159,23 @@ async function loadPlugins() {
   const communityPlugins = fs.readdirSync(nodeModules);
   const officialPluginPath = path.join(nodeModules, "@initx-plugin");
   const officialPlugins = fs.existsSync(officialPluginPath) ? fs.readdirSync(officialPluginPath).map((name) => `@initx-plugin/${name}`) : [];
+  const regexps = {
+    plugin: /^(?:@initx-plugin\/|initx-plugin-)/,
+    exclude: /@initx-plugin\/(?:core|utils)$/
+  };
   const pluginsName = [
     ...officialPlugins,
     ...communityPlugins
   ].filter(
-    (name) => /^(?:@initx-plugin\/|initx-plugin-)/.test(name) && !/@initx-plugin\/(?:core|utils)$/.test(name)
+    (name) => regexps.plugin.test(name) && !regexps.exclude.test(name)
   );
   const x = await import('importx');
   return Promise.all(pluginsName.map(async (dirname) => {
-    const InitxHandlerClass = await x.import(path.join(nodeModules, dirname), import.meta.url).then((x2) => x2.default);
+    const pluginRoot = path.join(nodeModules, dirname);
+    const InitxPluginClass = await x.import(pluginRoot, import.meta.url).then((x2) => x2.default);
     const packageAll = JSON.parse(fs.readFileSync(path.join(nodeModules, dirname, "package.json"), "utf-8"));
     const packageInfo = {
+      root: pluginRoot,
       name: packageAll.name,
       version: packageAll.version,
       description: packageAll.description,
@@ -102,9 +184,29 @@ async function loadPlugins() {
     };
     return {
       packageInfo,
-      handler: new InitxHandlerClass()
+      instance: new InitxPluginClass()
     };
   }));
 }
+function matchPlugins(plugins, { key, cliOptions }, ...others) {
+  const matchedHandlers = [];
+  for (const plugin of plugins) {
+    const { instance, packageInfo } = plugin;
+    const store = createStore(packageInfo, instance.defaultConfig);
+    const matched = instance.run({
+      key,
+      store,
+      cliOptions,
+      packageInfo,
+      optionsList: Object.keys(cliOptions).filter((key2) => cliOptions[key2] === true).map((key2) => `--${key2}`)
+    }, ...others);
+    matchedHandlers.push(...matched.map((item) => ({
+      handler: item.handler,
+      description: item.description,
+      packageInfo
+    })));
+  }
+  return matchedHandlers;
+}
 
-export { InitxHandler, loadPlugins };
+export { InitxPlugin, createStore, loadPlugins, matchPlugins, writeStore };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@initx-plugin/core",
   "type": "module",
-  "version": "0.0.18",
+  "version": "0.0.20",
   "description": "core module for initx plugins",
   "license": "MIT",
   "homepage": "https://github.com/initx-collective/initx#readme",
@@ -22,9 +22,10 @@
     "dist"
   ],
   "dependencies": {
+    "defu": "^6.1.4",
     "fs-extra": "^11.2.0",
     "importx": "^0.5.0",
-    "@initx-plugin/utils": "0.0.18"
+    "@initx-plugin/utils": "0.0.20"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4"