koishi-plugin-rzgtboeyndxsklmq-commons 1.0.1

package/lib/index.d.ts

@@ -0,0 +1,8 @@
+import { Context, Schema } from 'koishi';
+export * from './utils/BeanHelper';
+export * from './utils/File';
+export declare const name = "rzgtboeyndxsklmq-commons";
+export interface Config {
+}
+export declare const Config: Schema<Config>;
+export declare function apply(ctx: Context, config: Config): void;

package/lib/index.js

@@ -0,0 +1,233 @@
+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 __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], 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(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  BeanHelper: () => BeanHelper,
+  BeanType: () => BeanType,
+  Config: () => Config,
+  apply: () => apply,
+  name: () => name,
+  readDirFiles: () => readDirFiles
+});
+module.exports = __toCommonJS(src_exports);
+var import_koishi = require("koishi");
+
+// src/utils/BeanHelper.ts
+var BeanType = class {
+  constructor(beanHelper) {
+    this.beanHelper = beanHelper;
+    this.ctx = beanHelper.getByName("ctx");
+    this.config = beanHelper.getByName("config");
+    return this;
+  }
+  static {
+    __name(this, "BeanType");
+  }
+  ctx;
+  config;
+  start() {
+  }
+  destroy() {
+  }
+};
+var BeanHelper = class _BeanHelper {
+  static {
+    __name(this, "BeanHelper");
+  }
+  static buildLazyProxyHandler(getObj, hooks) {
+    const handlerMap = {};
+    let needInit = true;
+    Reflect.ownKeys(Reflect).forEach((key) => {
+      handlerMap[key] = (target, ...args) => {
+        const obj = getObj();
+        if (needInit) {
+          needInit = false;
+          Reflect.ownKeys(obj).forEach((k) => target[k] = obj[k]);
+          Reflect.setPrototypeOf(target, Reflect.getPrototypeOf(obj));
+        }
+        if (key === "set") {
+          Reflect[key].apply(Reflect, [target, args[0], args[1]]);
+        } else if (key === "deleteProperty") {
+          Reflect[key].apply(Reflect, [target, args]);
+        }
+        let res;
+        if (key === "get") {
+          res = hooks?.get ? hooks.get(obj, args[0]) : Reflect[key].apply(Reflect, [obj, args[0]]);
+          if (typeof res === "function") {
+            res = res.bind(args[1]);
+          }
+        } else {
+          res = Reflect[key].apply(Reflect, [obj, ...args]);
+        }
+        return res;
+      };
+    });
+    return handlerMap;
+  }
+  static buildLazyProxy(getObj) {
+    return new Proxy({}, _BeanHelper.buildLazyProxyHandler(getObj));
+  }
+  static buildLazyRevocableProxy(getObj) {
+    return Proxy.revocable({}, _BeanHelper.buildLazyProxyHandler(getObj));
+  }
+  classPool = [];
+  ctx;
+  config;
+  constructor() {
+    this.proxy(() => this.ctx, "ctx");
+    this.proxy(() => this.config, "config");
+  }
+  setCtx(ctx, config) {
+    this.ctx = ctx;
+    this.config = config;
+  }
+  touchAll() {
+    let i = 0;
+    let len = 0;
+    while (len != this.classPool.length && i++ < 99999) {
+      len = this.classPool.length;
+      this.classPool.forEach((classInfo) => {
+        return classInfo?.proxy?.["__"];
+      });
+    }
+  }
+  async start() {
+    this.touchAll();
+    for (const classInfo of this.classPool) {
+      if (classInfo.proxy instanceof BeanType) {
+        await classInfo.proxy.start();
+      }
+    }
+  }
+  async destroy() {
+    for (const classInfo of this.classPool) {
+      if (classInfo.proxy instanceof BeanType) {
+        await classInfo.proxy.destroy();
+      }
+      classInfo.proxyRevoke?.();
+    }
+    this.classPool = null;
+  }
+  instance(clazz) {
+    let classInfo = this.classPool.find(
+      (classInfo2) => classInfo2.class === clazz
+    );
+    if (classInfo) {
+      return classInfo.proxy;
+    }
+    classInfo = {
+      name: clazz.name,
+      class: clazz,
+      instance: null,
+      proxy: null,
+      proxyRevoke: null
+    };
+    const proxyRevocable = _BeanHelper.buildLazyRevocableProxy(() => {
+      if (!classInfo.instance) {
+        classInfo.instance = new classInfo.class(this);
+      }
+      return classInfo.instance;
+    });
+    classInfo.proxy = proxyRevocable.proxy;
+    classInfo.proxyRevoke = proxyRevocable.revoke;
+    this.classPool.push(classInfo);
+    return classInfo.proxy;
+  }
+  proxy(getObj, name2) {
+    const proxyRevocable = _BeanHelper.buildLazyRevocableProxy(getObj);
+    const classInfo = {
+      name: name2,
+      proxy: proxyRevocable.proxy,
+      proxyRevoke: proxyRevocable.revoke
+    };
+    this.classPool.push(classInfo);
+    return classInfo.proxy;
+  }
+  getByName(name2) {
+    const classInfo = this.classPool.find(
+      (classInfo2) => classInfo2.name === name2
+    );
+    return classInfo.proxy || classInfo.instance;
+  }
+  put(instance, name2, clazz) {
+    if (!clazz) {
+      clazz = instance.constructor;
+    }
+    if (!name2) {
+      name2 = clazz.name;
+    }
+    this.classPool.push({
+      name: name2,
+      class: clazz,
+      instance
+    });
+    return instance;
+  }
+};
+
+// src/utils/File.ts
+var import_promises = __toESM(require("node:fs/promises"));
+var import_node_path = __toESM(require("node:path"));
+async function readDirFiles(dirPath, needDir = false) {
+  const files = await import_promises.default.readdir(dirPath, {
+    withFileTypes: true
+  });
+  const paths = [];
+  files.sort((a, b) => (a.isFile() ? 1 : 0) - (b.isFile() ? 1 : 0));
+  for (const file of files) {
+    if (file.isDirectory()) {
+      if (needDir) {
+        paths.push(import_node_path.default.join(import_node_path.default.resolve(dirPath, file.name), import_node_path.default.sep));
+      }
+      paths.push(...await readDirFiles(import_node_path.default.join(dirPath, file.name)));
+    } else if (file.isFile()) {
+      paths.push(import_node_path.default.resolve(dirPath, file.name));
+    }
+  }
+  return paths;
+}
+__name(readDirFiles, "readDirFiles");
+
+// src/index.ts
+var name = "rzgtboeyndxsklmq-commons";
+var Config = import_koishi.Schema.object({});
+function apply(ctx, config) {
+}
+__name(apply, "apply");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BeanHelper,
+  BeanType,
+  Config,
+  apply,
+  name,
+  readDirFiles
+});

package/lib/utils/BeanHelper.d.ts

@@ -0,0 +1,40 @@
+import type { Context, Awaitable } from "koishi";
+export declare abstract class BeanType<C extends object> {
+    protected beanHelper: BeanHelper<C>;
+    protected ctx: Context;
+    protected config: C;
+    constructor(beanHelper: BeanHelper<C>);
+    start(): Awaitable<void>;
+    destroy(): Awaitable<void>;
+}
+type Constructor<T = any> = new (...args: any[]) => T;
+export interface ClassInfo<T> {
+    name: string;
+    class?: Constructor<T>;
+    instance?: T;
+    proxy?: T;
+    proxyRevoke?: () => void;
+}
+export declare class BeanHelper<C extends object> {
+    static buildLazyProxyHandler<T extends object>(getObj: () => T, hooks?: {
+        get: (obj: any, prop: PropertyKey) => any;
+    }): ProxyHandler<T>;
+    static buildLazyProxy<T extends object>(getObj: () => T): T;
+    static buildLazyRevocableProxy<T extends object>(getObj: () => T): {
+        proxy: T;
+        revoke: () => void;
+    };
+    private classPool;
+    ctx: Context;
+    config: C;
+    constructor();
+    setCtx(ctx: Context, config: C): void;
+    private touchAll;
+    start(): Promise<void>;
+    destroy(): Promise<void>;
+    instance<T extends BeanType<C>>(clazz: Constructor<T>): T;
+    proxy<T extends object>(getObj: () => T, name: string): T;
+    getByName<T>(name: string): T;
+    put<T>(instance: T, name?: string, clazz?: Constructor): T;
+}
+export {};

package/lib/utils/File.d.ts

@@ -0,0 +1 @@
+export declare function readDirFiles(dirPath: string, needDir?: boolean): Promise<string[]>;

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "koishi-plugin-rzgtboeyndxsklmq-commons",
+  "description": "",
+  "version": "1.0.1",
+  "main": "lib/index.js",
+  "typings": "lib/index.d.ts",
+  "scripts": {
+    "build": "cd ../../ && yarn build rzgtboeyndxsklmq-commons",
+    "pub": "cd ../../ && yarn pub rzgtboeyndxsklmq-commons",
+    "fastPub": "cd ../../ && yarn bump -3 rzgtboeyndxsklmq-commons && yarn build rzgtboeyndxsklmq-commons && yarn pub rzgtboeyndxsklmq-commons"
+  },
+  "files": [
+    "lib",
+    "dist"
+  ],
+  "contributors": [
+    "pgnqukezrdxmhjso"
+  ],
+  "homepage": "https://github.com/pgnqukezrdxmhjso/koishi-plugin-rzgtboeyndxsklmq-commons",
+  "bugs": {
+    "url": "https://github.com/pgnqukezrdxmhjso/koishi-plugin-rzgtboeyndxsklmq-commons/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pgnqukezrdxmhjso/koishi-plugin-rzgtboeyndxsklmq-commons.git"
+  },
+  "license": "MIT",
+  "keywords": [
+    "koishi",
+    "commons"
+  ],
+  "peerDependencies": {
+    "koishi": "^4.18.10"
+  }
+}

package/readme.md

@@ -0,0 +1,5 @@
+# koishi-plugin-rzgtboeyndxsklmq-commons
+
+[![npm](https://img.shields.io/npm/v/koishi-plugin-rzgtboeyndxsklmq-commons?style=flat-square)](https://www.npmjs.com/package/koishi-plugin-rzgtboeyndxsklmq-commons)
+
+