koishi-plugin-rzgtboeyndxsklmq-commons 1.0.5 → 1.0.6

package/lib/index.d.ts

@@ -1,6 +1,7 @@
 import { Context, Schema } from "koishi";
 export * from "./utils/BeanHelper";
-export * from "./utils/File";
+export * from "./utils/Strings";
+export * from "./utils/Files";
 export * from "./utils/Test";
 export declare const name = "rzgtboeyndxsklmq-commons";
 export interface Config {

package/lib/index.js

@@ -31,40 +31,22 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var src_exports = {};
 __export(src_exports, {
   BeanHelper: () => BeanHelper,
-  BeanType: () => BeanType,
   Config: () => Config,
+  Files: () => Files,
+  Strings: () => Strings,
+  Test: () => Test,
   apply: () => apply,
-  name: () => name,
-  readDirFiles: () => readDirFiles,
-  test: () => test,
-  test2: () => test2
+  name: () => name
 });
 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) {
+  static buildLazyProxyHandler(getObj, options) {
     const handlerMap = {};
     let needInit = true;
     Reflect.ownKeys(Reflect).forEach((key) => {
@@ -74,17 +56,18 @@ var BeanHelper = class _BeanHelper {
           needInit = false;
           Reflect.ownKeys(obj).forEach((k) => target[k] = obj[k]);
           Reflect.setPrototypeOf(target, Reflect.getPrototypeOf(obj));
+          target[_BeanHelper.PlaceholderObject] = true;
         }
         if (key === "set") {
-          Reflect[key].apply(Reflect, [target, args[0], args[1]]);
+          Reflect.set(target, args[0], args[1]);
         } else if (key === "deleteProperty") {
-          Reflect[key].apply(Reflect, [target, args]);
+          Reflect.deleteProperty(target, args[0]);
         }
         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]);
+          res = options?.hooks?.get ? options.hooks.get(obj, args[0]) : Reflect[key].apply(Reflect, [obj, args[0]]);
+          if (typeof res === "function" && !options?.notBind) {
+            res = res.bind(options?.bindOriginal ? obj : args[1]);
           }
         } else {
           res = Reflect[key].apply(Reflect, [obj, ...args]);
@@ -94,17 +77,23 @@ var BeanHelper = class _BeanHelper {
     });
     return handlerMap;
   }
-  static buildLazyProxy(getObj) {
-    return new Proxy({}, _BeanHelper.buildLazyProxyHandler(getObj));
+  static buildLazyProxy(getObj, options) {
+    return new Proxy(
+      {},
+      _BeanHelper.buildLazyProxyHandler(getObj, options)
+    );
   }
-  static buildLazyRevocableProxy(getObj) {
-    return Proxy.revocable({}, _BeanHelper.buildLazyProxyHandler(getObj));
+  static buildLazyRevocableProxy(getObj, options) {
+    return Proxy.revocable(
+      {},
+      _BeanHelper.buildLazyProxyHandler(getObj, options)
+    );
   }
   classPool = [];
   ctx;
   config;
   constructor() {
-    this.proxy(() => this.ctx, "ctx");
+    this.proxy(() => this.ctx, "ctx", { notBind: true });
     this.proxy(() => this.config, "config");
   }
   setCtx(ctx, config) {
@@ -124,21 +113,21 @@ var BeanHelper = class _BeanHelper {
   async start() {
     this.touchAll();
     for (const classInfo of this.classPool) {
-      if (classInfo.proxy instanceof BeanType) {
+      if (classInfo.proxy instanceof _BeanHelper.BeanType) {
         await classInfo.proxy.start();
       }
     }
   }
   async destroy() {
     for (const classInfo of this.classPool) {
-      if (classInfo.proxy instanceof BeanType) {
+      if (classInfo.proxy instanceof _BeanHelper.BeanType) {
         await classInfo.proxy.destroy();
       }
       classInfo.proxyRevoke?.();
     }
     this.classPool = null;
   }
-  instance(clazz) {
+  instance(clazz, options) {
     let classInfo = this.classPool.find(
       (classInfo2) => classInfo2.class === clazz
     );
@@ -157,14 +146,14 @@ var BeanHelper = class _BeanHelper {
         classInfo.instance = new classInfo.class(this);
       }
       return classInfo.instance;
-    });
+    }, options);
     classInfo.proxy = proxyRevocable.proxy;
     classInfo.proxyRevoke = proxyRevocable.revoke;
     this.classPool.push(classInfo);
     return classInfo.proxy;
   }
-  proxy(getObj, name2) {
-    const proxyRevocable = _BeanHelper.buildLazyRevocableProxy(getObj);
+  proxy(getObj, name2, options) {
+    const proxyRevocable = _BeanHelper.buildLazyRevocableProxy(getObj, options);
     const classInfo = {
       name: name2,
       proxy: proxyRevocable.proxy,
@@ -194,90 +183,145 @@ var BeanHelper = class _BeanHelper {
     return instance;
   }
 };
+((BeanHelper2) => {
+  BeanHelper2.PlaceholderObject = Symbol("PlaceholderObject");
+  class BeanType {
+    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() {
+    }
+  }
+  BeanHelper2.BeanType = BeanType;
+})(BeanHelper || (BeanHelper = {}));
+
+// src/utils/Strings.ts
+var Strings;
+((Strings2) => {
+  function isEmpty(str) {
+    return !str;
+  }
+  Strings2.isEmpty = isEmpty;
+  __name(isEmpty, "isEmpty");
+  function isNotEmpty(str) {
+    return !Strings2.isEmpty(str);
+  }
+  Strings2.isNotEmpty = isNotEmpty;
+  __name(isNotEmpty, "isNotEmpty");
+  function isBlank(str) {
+    return Strings2.isEmpty(str) || str.trim().length === 0;
+  }
+  Strings2.isBlank = isBlank;
+  __name(isBlank, "isBlank");
+  function isNotBlank(str) {
+    return !Strings2.isBlank(str);
+  }
+  Strings2.isNotBlank = isNotBlank;
+  __name(isNotBlank, "isNotBlank");
+})(Strings || (Strings = {}));
 
-// src/utils/File.ts
+// src/utils/Files.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, {
-    recursive: true,
-    withFileTypes: true
-  });
-  const paths = [];
-  files.forEach((file) => {
-    if (file.isDirectory()) {
-      if (!needDir) {
-        return;
+var Files;
+((Files2) => {
+  async function readDirFiles(dirPath, needDir = false) {
+    const files = await import_promises.default.readdir(dirPath, {
+      recursive: true,
+      withFileTypes: true
+    });
+    const paths = [];
+    files.forEach((file) => {
+      if (file.isDirectory()) {
+        if (!needDir) {
+          return;
+        }
+        paths.push(import_node_path.default.join(file.parentPath, file.name, import_node_path.default.sep));
+      } else if (file.isFile()) {
+        paths.push(import_node_path.default.join(file.parentPath, file.name));
       }
-      paths.push(import_node_path.default.join(file.parentPath, file.name, import_node_path.default.sep));
-    } else if (file.isFile()) {
-      paths.push(import_node_path.default.join(file.parentPath, file.name));
-    }
-  });
-  return paths;
-}
-__name(readDirFiles, "readDirFiles");
+    });
+    return paths;
+  }
+  Files2.readDirFiles = readDirFiles;
+  __name(readDirFiles, "readDirFiles");
+})(Files || (Files = {}));
 
 // src/utils/Test.ts
-async function test(name2, count, serial, run) {
-  const timeout = setInterval(() => {
-    process.stdout.write(".");
-  }, 100);
-  let timeConsumings = [];
-  timeConsumings.length = count;
-  const testStartTime = Date.now();
-  if (serial) {
-    for (let i = 0; i < count; i++) {
-      const time = Date.now();
-      await run();
-      timeConsumings[i] = Date.now() - time;
-    }
-  } else {
-    timeConsumings = [...timeConsumings];
-    await Promise.all(
-      timeConsumings.map((_, i) => {
-        return new Promise((resolve) => {
-          setImmediate(async () => {
-            const time = Date.now();
-            await run();
-            timeConsumings[i] = Date.now() - time;
-            resolve(0);
+var Test;
+((Test2) => {
+  async function test(name2, count, serial, run) {
+    const timeout = setInterval(() => {
+      process.stdout.write(".");
+    }, 100);
+    let timeConsumings = [];
+    timeConsumings.length = count;
+    const testStartTime = Date.now();
+    if (serial) {
+      for (let i = 0; i < count; i++) {
+        const time = Date.now();
+        await run();
+        timeConsumings[i] = Date.now() - time;
+      }
+    } else {
+      timeConsumings = [...timeConsumings];
+      await Promise.all(
+        timeConsumings.map((_, i) => {
+          return new Promise((resolve) => {
+            setImmediate(async () => {
+              const time = Date.now();
+              await run();
+              timeConsumings[i] = Date.now() - time;
+              resolve(0);
+            });
           });
-        });
-      })
-    );
-  }
-  const testTime = Date.now() - testStartTime;
-  clearInterval(timeout);
-  if (count < 2) {
-    console.log(`
+        })
+      );
+    }
+    const testTime = Date.now() - testStartTime;
+    clearInterval(timeout);
+    if (count < 2) {
+      console.log(`
 run: ${name2};	total: ${timeConsumings[0]};`);
-    return;
-  }
-  let total = 0;
-  let average = 0;
-  let highest = 0;
-  let lowest = null;
-  for (let i = 1; i < timeConsumings.length; i++) {
-    const t = timeConsumings[i];
-    if (lowest == null || t < lowest) {
-      lowest = t;
+      return;
     }
-    highest = Math.max(t, highest);
-    total += t;
-  }
-  average = total / (count - 1);
-  console.log(
-    `
+    let total = 0;
+    let average = 0;
+    let highest = 0;
+    let lowest = null;
+    for (let i = 1; i < timeConsumings.length; i++) {
+      const t = timeConsumings[i];
+      if (lowest == null || t < lowest) {
+        lowest = t;
+      }
+      highest = Math.max(t, highest);
+      total += t;
+    }
+    average = total / (count - 1);
+    console.log(
+      `
 run: ${name2};	serial: ${serial};	count: ${count};	testTime: ${testTime};	total: ${total};	first: ${timeConsumings[0]};	average: ${average};	highest: ${highest};	lowest: ${lowest};`
-  );
-}
-__name(test, "test");
-async function test2(name2, count, run) {
-  await test(name2, count, true, run);
-  await test(name2, count, false, run);
-}
-__name(test2, "test2");
+    );
+  }
+  Test2.test = test;
+  __name(test, "test");
+  async function test2(name2, count, run) {
+    await test(name2, count, true, run);
+    await test(name2, count, false, run);
+  }
+  Test2.test2 = test2;
+  __name(test2, "test2");
+})(Test || (Test = {}));
 
 // src/index.ts
 var name = "rzgtboeyndxsklmq-commons";
@@ -288,11 +332,10 @@ __name(apply, "apply");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BeanHelper,
-  BeanType,
   Config,
+  Files,
+  Strings,
+  Test,
   apply,
-  name,
-  readDirFiles,
-  test,
-  test2
+  name
 });

package/lib/utils/BeanHelper.d.ts

@@ -1,26 +1,9 @@
 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): {
+    static buildLazyProxyHandler<T extends object>(getObj: () => T, options?: BeanHelper.ProxyOptions): ProxyHandler<T>;
+    static buildLazyProxy<T extends object>(getObj: () => T, options?: BeanHelper.ProxyOptions): T;
+    static buildLazyRevocableProxy<T extends object>(getObj: () => T, options?: BeanHelper.ProxyOptions): {
         proxy: T;
         revoke: () => void;
     };
@@ -32,9 +15,34 @@ export declare class BeanHelper<C extends object> {
     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;
+    instance<T extends BeanHelper.BeanType<C>>(clazz: Constructor<T>, options?: BeanHelper.ProxyOptions): T;
+    proxy<T extends object>(getObj: () => T, name: string, options?: BeanHelper.ProxyOptions): T;
     getByName<T>(name: string): T;
     put<T>(instance: T, name?: string, clazz?: Constructor): T;
 }
+export declare namespace BeanHelper {
+    const PlaceholderObject: unique symbol;
+    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>;
+    }
+    interface ClassInfo<T> {
+        name: string;
+        class?: Constructor<T>;
+        instance?: T;
+        proxy?: T;
+        proxyRevoke?: () => void;
+    }
+    interface ProxyOptions {
+        notBind?: boolean;
+        bindOriginal?: boolean;
+        hooks?: {
+            get: (obj: any, prop: PropertyKey) => any;
+        };
+    }
+}
 export {};

package/lib/utils/Files.d.ts

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

package/lib/utils/Strings.d.ts

@@ -0,0 +1,6 @@
+export declare namespace Strings {
+    function isEmpty(str: string): boolean;
+    function isNotEmpty(str: string): boolean;
+    function isBlank(str: string): boolean;
+    function isNotBlank(str: string): boolean;
+}

package/lib/utils/Test.d.ts

@@ -1,2 +1,4 @@
-export declare function test(name: string, count: number, serial: boolean, run: () => any): Promise<void>;
-export declare function test2(name: string, count: number, run: () => any): Promise<void>;
+export declare namespace Test {
+    function test(name: string, count: number, serial: boolean, run: () => any): Promise<void>;
+    function test2(name: string, count: number, run: () => any): Promise<void>;
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "koishi-plugin-rzgtboeyndxsklmq-commons",
   "description": "",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
   "scripts": {

package/lib/utils/File.d.ts

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

package/lib/utils/I18n.d.ts

@@ -1,2 +0,0 @@
-import { Context } from "koishi";
-export declare function loadLocales(ctx: Context, dirPath: string): void;