@ceale/util 1.19.0 → 1.21.0

package/README.md

@@ -10,7 +10,7 @@
     - removeAllSuffixes()
     - toCamelCase()
     - toKebabCase()
-- Function.prototype
+- namespace: `ClassUtil`
     - isDirectSubclass()
     - isSubclass()
     - isDirectInstance()
@@ -44,11 +44,16 @@
 - `type.ts`
     - assert()
     - expand()
+    - `type` anyobject
+    - `type` AnyClass
+    - `type` RequireOne
+- `enum_v2.ts`:
+    - Enum()
+    - EnumOf<>
+- `enum_v1.ts`
     - defineEnum()
     - Enum()
     - EnumKeys<>
-    - `type` anyobject
-    - `type` AnyClass
 - Object.prototype
     - hasKeys()
     - inKeys()

package/dist/cjs/index.js

@@ -20,14 +20,15 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  ClassUtil: () => ClassUtil,
   CubicBezier: () => CubicBezier,
-  Enum: () => Enum,
+  Enum: () => Enum2,
+  EnumV1: () => enum_v1_exports,
   QuadraticBezier: () => QuadraticBezier,
   assert: () => assert,
   css: () => css,
   cubicCurve: () => cubicCurve,
   debounce: () => debounce,
-  defineEnum: () => defineEnum,
   expand: () => expand,
   quadraticCurve: () => quadraticCurve,
   sleep: () => sleep,
@@ -138,55 +139,38 @@ var uri;
 })(uri || (uri = {}));
 
 // src/class.ts
-Object.defineProperty(Function.prototype, "isDirectSubclass", {
-  value: function(potentialChild) {
-    if (typeof potentialChild !== "function" || typeof this !== "function") {
+var ClassUtil;
+((ClassUtil2) => {
+  ClassUtil2.isDirectSubclass = (parent, potentialChild) => {
+    if (typeof potentialChild !== "function" || typeof parent !== "function") {
       return false;
     }
-    return Object.getPrototypeOf(potentialChild) === this;
-  },
-  writable: true,
-  configurable: true,
-  enumerable: false
-});
-Object.defineProperty(Function.prototype, "isSubclass", {
-  value: function(potentialDescendant) {
-    if (typeof potentialDescendant !== "function" || typeof this !== "function") {
+    return Object.getPrototypeOf(potentialChild) === parent;
+  };
+  ClassUtil2.isSubclass = (parent, potentialDescendant) => {
+    if (typeof potentialDescendant !== "function" || typeof parent !== "function") {
       return false;
     }
     let current = potentialDescendant;
     while (typeof current === "function") {
-      if (current === this) {
+      if (current === parent) {
         return true;
       }
       current = Object.getPrototypeOf(current);
-      if (current === Function.prototype) break;
+      if (!current || current === Function.prototype) break;
     }
     return false;
-  },
-  writable: true,
-  configurable: true,
-  enumerable: false
-});
-Object.defineProperty(Function.prototype, "isDirectInstance", {
-  value: function(potentialInstance) {
-    if (typeof this !== "function" || potentialInstance === null || typeof potentialInstance !== "object") {
+  };
+  ClassUtil2.isDirectInstance = (targetClass, potentialInstance) => {
+    if (typeof targetClass !== "function" || potentialInstance === null || typeof potentialInstance !== "object") {
       return false;
     }
-    return Object.getPrototypeOf(potentialInstance).constructor === this;
-  },
-  writable: true,
-  configurable: true,
-  enumerable: false
-});
-Object.defineProperty(Function.prototype, "isInstance", {
-  value: function(potentialInstance) {
-    return typeof this === "function" && potentialInstance instanceof this;
-  },
-  writable: true,
-  configurable: true,
-  enumerable: false
-});
+    return Object.getPrototypeOf(potentialInstance)?.constructor === targetClass;
+  };
+  ClassUtil2.isInstance = (targetClass, potentialInstance) => {
+    return typeof targetClass === "function" && potentialInstance instanceof targetClass;
+  };
+})(ClassUtil || (ClassUtil = {}));
 
 // src/css.ts
 var css;
@@ -434,14 +418,6 @@ var tryCatch = (func, catchClass) => {
 // src/type.ts
 var assert = (variable) => variable;
 var expand = (variable) => variable;
-var defineEnum = (...keys) => keys.reduce((acc, key) => {
-  acc[key] = key;
-  return acc;
-}, {});
-var Enum = (keys) => ({
-  keys: () => Object.keys(keys),
-  includes: (key) => Object.keys(keys).includes(key)
-});
 
 // src/object.ts
 Object.defineProperty(Object.prototype, "hasKeys", {
@@ -462,3 +438,27 @@ Object.defineProperty(Object.prototype, "inKeys", {
   writable: true,
   configurable: true
 });
+
+// src/enum_v1.ts
+var enum_v1_exports = {};
+__export(enum_v1_exports, {
+  Enum: () => Enum,
+  defineEnum: () => defineEnum
+});
+var defineEnum = (...keys) => keys.reduce((acc, key) => {
+  acc[key] = key;
+  return acc;
+}, {});
+var Enum = (keys) => ({
+  keys: () => Object.keys(keys),
+  includes: (key) => Object.keys(keys).includes(key)
+});
+
+// src/enum_v2.ts
+var Enum2 = (...values) => {
+  const obj = {};
+  values.forEach((value) => obj[value.toUpperCase()] = value);
+  obj.values = () => values;
+  obj.includes = (value) => values.includes(value);
+  return obj;
+};

package/dist/esm/index.js

@@ -1,3 +1,9 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
 // src/string.ts
 Object.defineProperty(String.prototype, "removePrefix", {
   value: function(prefix) {
@@ -96,55 +102,38 @@ var uri;
 })(uri || (uri = {}));
 
 // src/class.ts
-Object.defineProperty(Function.prototype, "isDirectSubclass", {
-  value: function(potentialChild) {
-    if (typeof potentialChild !== "function" || typeof this !== "function") {
+var ClassUtil;
+((ClassUtil2) => {
+  ClassUtil2.isDirectSubclass = (parent, potentialChild) => {
+    if (typeof potentialChild !== "function" || typeof parent !== "function") {
       return false;
     }
-    return Object.getPrototypeOf(potentialChild) === this;
-  },
-  writable: true,
-  configurable: true,
-  enumerable: false
-});
-Object.defineProperty(Function.prototype, "isSubclass", {
-  value: function(potentialDescendant) {
-    if (typeof potentialDescendant !== "function" || typeof this !== "function") {
+    return Object.getPrototypeOf(potentialChild) === parent;
+  };
+  ClassUtil2.isSubclass = (parent, potentialDescendant) => {
+    if (typeof potentialDescendant !== "function" || typeof parent !== "function") {
       return false;
     }
     let current = potentialDescendant;
     while (typeof current === "function") {
-      if (current === this) {
+      if (current === parent) {
         return true;
       }
       current = Object.getPrototypeOf(current);
-      if (current === Function.prototype) break;
+      if (!current || current === Function.prototype) break;
     }
     return false;
-  },
-  writable: true,
-  configurable: true,
-  enumerable: false
-});
-Object.defineProperty(Function.prototype, "isDirectInstance", {
-  value: function(potentialInstance) {
-    if (typeof this !== "function" || potentialInstance === null || typeof potentialInstance !== "object") {
+  };
+  ClassUtil2.isDirectInstance = (targetClass, potentialInstance) => {
+    if (typeof targetClass !== "function" || potentialInstance === null || typeof potentialInstance !== "object") {
       return false;
     }
-    return Object.getPrototypeOf(potentialInstance).constructor === this;
-  },
-  writable: true,
-  configurable: true,
-  enumerable: false
-});
-Object.defineProperty(Function.prototype, "isInstance", {
-  value: function(potentialInstance) {
-    return typeof this === "function" && potentialInstance instanceof this;
-  },
-  writable: true,
-  configurable: true,
-  enumerable: false
-});
+    return Object.getPrototypeOf(potentialInstance)?.constructor === targetClass;
+  };
+  ClassUtil2.isInstance = (targetClass, potentialInstance) => {
+    return typeof targetClass === "function" && potentialInstance instanceof targetClass;
+  };
+})(ClassUtil || (ClassUtil = {}));
 
 // src/css.ts
 var css;
@@ -392,14 +381,6 @@ var tryCatch = (func, catchClass) => {
 // src/type.ts
 var assert = (variable) => variable;
 var expand = (variable) => variable;
-var defineEnum = (...keys) => keys.reduce((acc, key) => {
-  acc[key] = key;
-  return acc;
-}, {});
-var Enum = (keys) => ({
-  keys: () => Object.keys(keys),
-  includes: (key) => Object.keys(keys).includes(key)
-});
 
 // src/object.ts
 Object.defineProperty(Object.prototype, "hasKeys", {
@@ -420,15 +401,40 @@ Object.defineProperty(Object.prototype, "inKeys", {
   writable: true,
   configurable: true
 });
+
+// src/enum_v1.ts
+var enum_v1_exports = {};
+__export(enum_v1_exports, {
+  Enum: () => Enum,
+  defineEnum: () => defineEnum
+});
+var defineEnum = (...keys) => keys.reduce((acc, key) => {
+  acc[key] = key;
+  return acc;
+}, {});
+var Enum = (keys) => ({
+  keys: () => Object.keys(keys),
+  includes: (key) => Object.keys(keys).includes(key)
+});
+
+// src/enum_v2.ts
+var Enum2 = (...values) => {
+  const obj = {};
+  values.forEach((value) => obj[value.toUpperCase()] = value);
+  obj.values = () => values;
+  obj.includes = (value) => values.includes(value);
+  return obj;
+};
 export {
+  ClassUtil,
   CubicBezier,
-  Enum,
+  Enum2 as Enum,
+  enum_v1_exports as EnumV1,
   QuadraticBezier,
   assert,
   css,
   cubicCurve,
   debounce,
-  defineEnum,
   expand,
   quadraticCurve,
   sleep,

package/dist/types/class.d.ts

@@ -1,32 +1,33 @@
 import type { AnyClass } from "./type";
-declare global {
-    interface Function {
-        /**
-         * 检查 `potentialChild` 是否是当前类的直接子类
-         * @param potentialChild 潜在的子类构造函数
-         * @returns 如果是直接子类，则返回 `true`；否则返回 `false`
-         */
-        isDirectSubclass(this: AnyClass, potentialChild: unknown): boolean;
-        /**
-         * 检查 `potentialDescendant` 是否是当前类的子孙类或当前类本身
-         * @param potentialDescendant 潜在的子孙类或类本身
-         * @returns 如果是子孙类或类本身，则返回 `true`；否则返回 `false`
-         */
-        isSubclass(this: AnyClass, potentialDescendant: unknown): boolean;
-        /**
-         * 检查 `potentialInstance` 是否由当前类直接构造
-         * 判断依据: `Object.getPrototypeOf(potentialInstance).constructor === this`
-         * @param potentialInstance 潜在的实例对象
-         * @returns 如果是由当前类直接创建的实例，则返回 `true`；否则返回 `false`
-         */
-        isDirectInstance(this: AnyClass, potentialInstance: unknown): boolean;
-        /**
-         * 检查 `potentialInstance` 是否是当前类或其任何子类的实例
-         * 内部使用 `instanceof` 操作符
-         * @param potentialInstance 潜在的实例对象
-         * @returns 如果是实例，则返回 `true`；否则返回 `false`
-         */
-        isInstance(this: AnyClass, potentialInstance: unknown): boolean;
-    }
+export declare namespace ClassUtil {
+    /**
+     * 检查 `potentialChild` 是否是当前类的直接子类
+     * @param parent 当前类（父类）
+     * @param potentialChild 潜在的子类构造函数
+     * @returns 如果是直接子类，则返回 `true`；否则返回 `false`
+     */
+    const isDirectSubclass: (parent: AnyClass, potentialChild: unknown) => boolean;
+    /**
+     * 检查 `potentialDescendant` 是否是当前类的子孙类或当前类本身
+     * @param parent 当前类
+     * @param potentialDescendant 潜在的子孙类或类本身
+     * @returns 如果是子孙类或类本身，则返回 `true`；否则返回 `false`
+     */
+    const isSubclass: (parent: AnyClass, potentialDescendant: unknown) => boolean;
+    /**
+     * 检查 `potentialInstance` 是否由当前类直接构造
+     * 判断依据: `Object.getPrototypeOf(potentialInstance).constructor === targetClass`
+     * @param targetClass 当前类
+     * @param potentialInstance 潜在的实例对象
+     * @returns 如果是由当前类直接创建的实例，则返回 `true`；否则返回 `false`
+     */
+    const isDirectInstance: (targetClass: AnyClass, potentialInstance: unknown) => boolean;
+    /**
+     * 检查 `potentialInstance` 是否是当前类或其任何子类的实例
+     * 内部使用 `instanceof` 操作符
+     * @param targetClass 当前类
+     * @param potentialInstance 潜在的实例对象
+     * @returns 如果是实例，则返回 `true`；否则返回 `false`
+     */
+    const isInstance: (targetClass: AnyClass, potentialInstance: unknown) => boolean;
 }
-export {};

package/dist/types/enum_v1.d.ts

@@ -0,0 +1,43 @@
+/**
+ * 定义一个枚举类型。
+ * 返回一个枚举对象，其中每个键名与值相同。
+ * @param keys 若干个枚举的键名
+ *
+ * @example
+ * const type = defineEnum("A", "B", "C")
+ * type === (typeof type) === {
+ *     A: "A",
+ *     B: "B",
+ *     C: "C"
+ * }
+ */
+export declare const defineEnum: <T extends string>(...keys: T[]) => { [K in T]: K; };
+/**
+ * 枚举工具函数，为枚举对象提供工具方法
+ * @param keys 由 defineEnum 创建的枚举对象
+ * @returns 返回一个包含`keys`、`includes`方法的对象
+ *
+ * @example
+ * const 对吗 = defineEnum("对", "不对")
+ *
+ * // 获取所有枚举键
+ * Enum(对吗).keys() // ["对", "不对"]
+ *
+ * // 检查值是否为有效枚举值
+ * Enum(对吗).includes("对") // true
+ * Enum(对吗).includes("错") // false
+ */
+export declare const Enum: (keys: Record<string, string>) => {
+    keys: () => (keyof typeof keys)[];
+    includes: (key: any) => boolean;
+};
+/**
+ * 提取枚举的所有键组成联合类型
+ * @template E 由 defineEnum 创建的枚举对象
+ * @returns 枚举键的联合类型
+ *
+ * @example
+ * const 对吗 = defineEnum("对", "不对")
+ * Enum<typeof 对吗> // "对" | "不对"
+ */
+export type EnumKeys<E> = E[keyof E];

package/dist/types/enum_v2.d.ts

@@ -0,0 +1,28 @@
+type EnumKeyValue<T extends readonly string[]> = {
+    [K in T[number] as Uppercase<K>]: K;
+};
+interface EnumMethod<T extends readonly string[]> {
+    values(): T;
+    includes<V extends any>(value: V): boolean;
+}
+/**
+ * 提取枚举对象中的枚举值
+ */
+export type EnumOf<T extends Record<string, any>> = Extract<T[keyof T], string>;
+/**
+ * 创建一个枚举对象
+ * @param 若干个枚举值，字符串
+ * @returns 枚举对象，包含枚举值和枚举方法，枚举键为枚举值的大写
+ *
+ * @example
+ * const Example = Enum("value_a", "value_b")
+ * // {
+ * //    VALUE_A: "value_a",
+ * //    VALUE_B: "value_b"
+ * //    values(): ["value_a", "value_b"],
+ * //    includes(value: string): boolean
+ * // }
+ *
+ */
+export declare const Enum: <T extends readonly string[]>(...values: T) => EnumKeyValue<T> & EnumMethod<T>;
+export {};

package/dist/types/index.d.ts

@@ -8,3 +8,5 @@ export * from "./bezier";
 export * from "./error";
 export * from "./type";
 export * from "./object";
+export * as EnumV1 from "./enum_v1";
+export * from "./enum_v2";

package/dist/types/type.d.ts

@@ -23,45 +23,17 @@ export declare const assert: <Type = any>(variable: any) => asserts variable is
  */
 export declare const expand: <Type>(variable: any) => asserts variable is (typeof variable & Type);
 /**
- * 定义一个枚举类型。
- * 返回一个枚举对象，其中每个键名与值相同。
- * @param keys 若干个枚举的键名
- *
+ * 强制对象类型中至少包含一个指定的属性。
  * @example
- * const type = defineEnum("A", "B", "C")
- * type === (typeof type) === {
- *     A: "A",
- *     B: "B",
- *     C: "C"
- * }
+ * ```ts
+ * interface User { id: string; name: string; age: number; }
+ * // 有效：包含一个或多个属性
+ * const update: RequireOne<User> = { name: 'Gemini' };
+ * // 错误：不允许空对象
+ * const invalid: RequireOne<User> = {};
+ * ```
+ * @template T - 需要处理的基础对象接口。其中不应有可选属性，有可能会导致未预料的情况。
  */
-export declare const defineEnum: <T extends string>(...keys: T[]) => { [K in T]: K; };
-/**
- * 枚举工具函数，为枚举对象提供工具方法
- * @param keys 由 defineEnum 创建的枚举对象
- * @returns 返回一个包含`keys`、`includes`方法的对象
- *
- * @example
- * const 对吗 = defineEnum("对", "不对")
- *
- * // 获取所有枚举键
- * Enum(对吗).keys() // ["对", "不对"]
- *
- * // 检查值是否为有效枚举值
- * Enum(对吗).includes("对") // true
- * Enum(对吗).includes("错") // false
- */
-export declare const Enum: (keys: Record<string, string>) => {
-    keys: () => (keyof typeof keys)[];
-    includes: (key: any) => boolean;
-};
-/**
- * 提取枚举的所有键组成联合类型
- * @template E 由 defineEnum 创建的枚举对象
- * @returns 枚举键的联合类型
- *
- * @example
- * const 对吗 = defineEnum("对", "不对")
- * Enum<typeof 对吗> // "对" | "不对"
- */
-export type EnumKeys<E> = E[keyof E];
+export type RequireOne<T> = {
+    [K in keyof T]: Required<Pick<T, K>> & Partial<Omit<T, K>>;
+}[keyof T];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ceale/util",
-  "version": "1.19.0",
+  "version": "1.21.0",
   "author": "Ceale",
   "description": "小工具集",
   "repository": {