修正文档

History.md

@@ -1,3 +1,8 @@
+2.4.3 / 2024-09-29
+==================
+  * 修复`Object.defineProperty`定义声明
+  * 增加`Promise.withResolvers`
+
 2.4.2 / 2024-09-12
 ==================
   * 优化字符串转义

Readme.md

@@ -7,8 +7,8 @@
 
 ```js
 ├── Obejct
-│   └── .empty(any)    // 判断对象是否为空对象
+│   ├── .empty(any)    // 判断对象是否为空对象
-│   └── .groupBy(arr, fn)    // 数组分组, 返回分组后的对象
+│   ├── .groupBy(arr, fn)    // 数组分组, 返回分组后的对象
 │   └── .hasOwn(any, key)    // 安全版的 Object.prototype.hasOwnProperty()
 ├── Obejct.prototype
 │   └── .toParams()    // 把对象转为 key1=value1&key2=value2 格式
@@ -32,12 +32,12 @@
 ├── Set.prototype
 │   ├── .union(other)    // 合并2个集合
 │   ├── .equals(other)    // 判断2个集合是否一致(仅元素相同, 无关顺序)
-│   ├── .difference(fn)    // 返回不存在于另一个集合的所有元素集合
+│   ├── .difference(other)    // 返回不存在于另一个集合的所有元素集合
-│   ├── .symmetricDifference(fn)    // 返回当前集合与给定集合中, 不同时存在的所有元素集合
+│   ├── .symmetricDifference(other)    // 返回当前集合与给定集合中, 不同时存在的所有元素集合
-│   ├── .intersection(fn)    // 返回共有的元素集合
+│   ├── .intersection(other)    // 返回共有的元素集合
-│   ├── .isSubsetOf(fn)    // 判断当前集合是否为给定集合的子集
+│   ├── .isSubsetOf(other)    // 判断当前集合是否为给定集合的子集
-│   ├── .isSupersetOf(fn)    // 判断当前集合是否为给定集合的子超集
+│   ├── .isSupersetOf(other)    // 判断当前集合是否为给定集合的超集
-│   ├── .isDisjointFrom(fn)    // 判断当前集合,是否与给定集合完全不重合
+│   ├── .isDisjointFrom(other)    // 判断当前集合,是否与给定集合完全不重合
 │
 ├── Date
 │   └── .isDate(any)    // 判断对象是否为 日期对象
@@ -64,10 +64,11 @@
 │   ├── .parse(str)    // 将安全范围内的数字字符串转为数字类型
 │   └── .fromString(str)    // 将字符串转为数字类型
 ├── Number.prototype
-│   ├── .toFixed(digits)    // 修正版的toFixed
+│   └── .toFixed(digits)    // 修正版的toFixed
 │
 └── Promise
-    └── .defer()    // 创建一个延迟的Promise对象
+    ├── .defer()    // 创建一个延迟的Promise对象
+    └── .withResolvers()    // 创建一个延迟的Promise对象, 同defer
 ```
 
 

index.d.ts

@@ -0,0 +1,89 @@
+// String prototype extensions
+interface String {
+  splice(start: number, len: number, fill?: string): string
+  htmlspecialchars(sign?: 'ENT_QUOTES' | 'ENT_NOQUOTES'): string
+  tohtml(): string
+  xss(): string
+  escape(): string
+  at(num: number): string
+  toJson(): Record<string, string>
+  lt(v: string): boolean
+  lte(v: string): boolean
+  gt(v: string): boolean
+  gte(v: string): boolean
+  eq(v: string): boolean
+}
+
+// Set prototype extensions
+interface Set<T> {
+  union(other: Set<T>): Set<T>
+  difference(other: Set<T>): Set<T>
+  symmetricDifference(other: Set<T>): Set<T>
+  intersection(other: Set<T>): Set<T>
+  isSubsetOf(other: Set<T>): boolean
+  isSupersetOf(other: Set<T>): boolean
+  isDisjointFrom(other: Set<T>): boolean
+  equals(other: Set<T>): boolean
+}
+
+// Promise extensions
+interface PromiseConstructor {
+  defer<T>(): {
+    promise: Promise<T>
+    resolve: (value: T | PromiseLike<T>) => void
+    reject: (reason?: any) => void
+  }
+  withResolvers<T>(): {
+    promise: Promise<T>
+    resolve: (value: T | PromiseLike<T>) => void
+    reject: (reason?: any) => void
+  }
+}
+
+// Object extensions
+interface ObjectConstructor {
+  empty(obj: any): boolean
+  groupBy<T>(arr: T[], fn: (item: T) => string): Record<string, T[]>
+  hasOwn(obj: any, key: string): boolean
+}
+
+interface Object {
+  toParams(): string
+}
+
+// Number extensions
+interface NumberConstructor {
+  parse(val: string | number): string | number
+  fromString(val: string): number
+}
+
+// Map extensions
+interface MapConstructor {
+  groupBy<T, K>(arr: T[], fn: (item: T) => K): Map<K, T[]>
+}
+
+// Date prototype extensions
+interface Date {
+  getFullWeek(): number
+  getWeek(): number
+  format(str?: string): string
+}
+
+// Array prototype extensions
+interface Array<T> {
+  flat(deep?: number, arr?: T[]): T[]
+  flatMap<U>(callback: (value: T, index: number, array: T[]) => U | U[]): U[]
+  at(num: number): T
+  findLast(
+    predicate: (value: T, index: number, obj: T[]) => boolean
+  ): T | undefined
+  findLastIndex(
+    predicate: (value: T, index: number, obj: T[]) => boolean
+  ): number
+  toSorted(compareFn?: (a: T, b: T) => number): T[]
+  toReversed(): T[]
+  toSpliced(start: number, deleteCount?: number, ...items: T[]): T[]
+  with(index: number, value: T): T[]
+  group(callback: (value: T) => string): Record<string, T[]>
+  groupToMap<K>(callback: (value: T) => K): Map<K, T[]>
+}

package.json

@@ -1,6 +1,6 @@
 {
   "name": "es.shim",
-  "version": "2.4.2",
+  "version": "2.5.0",
   "description": "实现部分新API, 以及一些常用的扩展方法",
   "keyworks": [
     "es5",
@@ -13,8 +13,10 @@
     "shim"
   ],
   "main": "dist/index.js",
+  "types": "index.d.ts",
   "files": [
-    "dist/*"
+    "dist/*",
+    "index.d.ts"
   ],
   "scripts": {
     "start": "node ./build.js"

src/lib/array.js

@@ -17,13 +17,15 @@ Object.defineProperty(Array.prototype, 'flat', {
     }
 
     return arr
-  }
+  },
+  writable: true
 })
 
 Object.defineProperty(Array.prototype, 'flatMap', {
   value(fn) {
     return this.map(fn).flat()
-  }
+  },
+  writable: true
 })
 
 if (!Array.prototype.at) {

src/lib/number.js

@@ -10,7 +10,8 @@ const NATIVE_TO_FIXED = Number.prototype.toFixed
 Object.defineProperty(Number.prototype, 'toFixed', {
   value(n) {
     return NATIVE_TO_FIXED.call(this + Number.EPSILON, n)
-  }
+  },
+  writable: true
 })
 
 // 简单的数字处理

src/lib/promise.js

@@ -13,3 +13,7 @@ if (!Promise.defer) {
     return obj
   }
 }
+
+if (!Promise.withResolvers) {
+  Promise.withResolvers = Promise.defer
+}

src/lib/set.js

@@ -75,7 +75,7 @@ if (!Set.prototype.union) {
     }
   })
 
-  // 判断当前集合是否为给定集合的子超集
+  // 判断当前集合是否为给定集合的超集
   Object.defineProperty(Set.prototype, 'isSupersetOf', {
     value(other) {
       for (let it of other) {
@@ -101,8 +101,10 @@ if (!Set.prototype.union) {
 }
 
 // 判断2个集合是否一致(仅元素相同, 无关顺序)
+if (!Set.prototype.equals) {
   Object.defineProperty(Set.prototype, 'equals', {
     value(other) {
       return this.size === other.size && this.isSubsetOf(other)
     }
   })
+}