kn-es-features 1.0.0 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kn-es-features",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "ES2015/2022/2025/2026所有特性的测试案例集合",
   "keywords": [
     "es2015",
@@ -18,6 +18,7 @@
       "import": "./dist/esfeatures.js",
       "require": "./dist/esfeatures.umd.cjs"
     },
+    "./polyfills": "./dist/polyfills.iife.js",
     "./src": "./src/index.js"
   },
   "files": [
@@ -25,14 +26,17 @@
     "src"
   ],
   "scripts": {
-    "build": "vite build",
-    "polyfill": "vite build --config vite.polyfill.config.js"
+    "build": "vite build & npm run polyfill",
+    "polyfill": "vite build --config vite.polyfill.config.js",
+    "validate": "vite --config vite.validate.config.js",
+    "validate:build": "vite build --config vite.validate.config.js"
   },
   "devDependencies": {
     "@babel/core": "~7.29.0",
     "@babel/preset-env": "~7.29.3",
     "@rollup/plugin-babel": "~7.0.0",
     "core-js": "~3.49.0",
+    "regenerator-runtime": "~0.14.1",
     "terser": "~5.46.2",
     "vite": "~4.5.14"
   }

package/src/features/es2015/01-let-const.js

@@ -11,44 +11,11 @@ export function testLetConst() {
     assert(results[0] === 0 && results[2] === 2, 'let 循环变量应为独立值')
   })
 
-  test('let 不可重复声明', () => {
-    try {
-      // 用 Function 构造器在独立作用域测试
-      new Function('"use strict"; let x = 1; let x = 2;')()
-      assert(false, '应抛出 SyntaxError')
-    } catch (e) {
-      assert(e instanceof SyntaxError || e instanceof TypeError, '应为语法错误')
-    }
-  })
-
-  test('let 暂时性死区(TDZ)', () => {
-    try {
-      new Function('"use strict"; console.log(y); let y = 1;')()
-      assert(false, '应抛出 ReferenceError')
-    } catch (e) {
-      assert(true)
-    }
-  })
-
   test('const 声明常量', () => {
     const PI = 3.14159
     assert(PI === 3.14159, 'const 值应保持不变')
   })
 
-  test('const 不可重新赋值', () => {
-    try {
-      new Function('"use strict"; const x = 1; x = 2;')()
-      assert(false, '应抛出 TypeError')
-    } catch (e) {
-      assert(e instanceof TypeError, '应为 TypeError')
-    }
-  })
-
-  test('const 对象属性可修改', () => {
-    const obj = { a: 1 }
-    obj.a = 2
-    assert(obj.a === 2, 'const 对象的属性可以修改')
-  })
 
   return getResults()
 }

package/src/features/es2015/02-arrow-functions.js

@@ -8,61 +8,5 @@ export function testArrowFunctions() {
     assert(add(2, 3) === 5, '箭头函数返回值应为 5')
   })
 
-  test('单参数省略括号', () => {
-    const double = n => n * 2
-    assert(double(4) === 8, '单参数箭头函数应正常工作')
-  })
-
-  test('无参数需要括号', () => {
-    const greet = () => 'hello'
-    assert(greet() === 'hello', '无参数箭头函数应正常工作')
-  })
-
-  test('多行函数体需要花括号和 return', () => {
-    const calc = (a, b) => {
-      const sum = a + b
-      return sum * 2
-    }
-    assert(calc(2, 3) === 10, '多行箭头函数应正确计算')
-  })
-
-  test('返回对象字面量需要括号', () => {
-    const makeObj = (x) => ({ value: x })
-    const obj = makeObj(42)
-    assert(obj.value === 42, '箭头函数返回对象应正确包裹')
-  })
-
-  test('this 词法绑定', () => {
-    function Timer() {
-      this.count = 0
-      const tick = () => {
-        this.count++
-      }
-      tick()
-      tick()
-    }
-    const t = new Timer()
-    assert(t.count === 2, '箭头函数 this 应绑定外层作用域')
-  })
-
-  test('没有 arguments 对象', () => {
-    const fn = () => typeof arguments === 'undefined' || true
-    // 在模块顶层 arguments 未定义，所以箭头函数内也未定义
-    assert(true, '箭头函数无独立 arguments')
-  })
-
-  test('不能用作构造函数（原生环境）', () => {
-    const Fn = () => {}
-    // Babel 将箭头函数编译为普通函数时，此限制在运行时不可复现，故跳过检测
-    const isNativeArrow = Fn.prototype === undefined
-    if (!isNativeArrow) return  // 编译降级环境跳过
-    try {
-      new Fn()
-      assert(false, '应抛出 TypeError')
-    } catch (e) {
-      assert(e instanceof TypeError, '箭头函数不能 new')
-    }
-  })
-
   return getResults()
 }

package/src/features/es2015/03-template-literals.js

@@ -9,43 +9,5 @@ export function testTemplateLiterals() {
     assert(str === 'Hello, ES2015!', '模板字符串插值应正确')
   })
 
-  test('表达式插值', () => {
-    const a = 3, b = 4
-    const str = `${a} + ${b} = ${a + b}`
-    assert(str === '3 + 4 = 7', '模板字符串支持表达式')
-  })
-
-  test('多行字符串', () => {
-    const multi = `第一行
-第二行`
-    assert(multi.includes('\n'), '模板字符串支持多行')
-  })
-
-  test('嵌套模板', () => {
-    const items = ['a', 'b', 'c']
-    const list = `items: ${items.map(i => `[${i}]`).join(', ')}`
-    assert(list === 'items: [a], [b], [c]', '模板字符串可以嵌套')
-  })
-
-  test('标签模板 - 基本用法', () => {
-    function tag(strings, ...values) {
-      return strings.raw[0] + values[0].toUpperCase()
-    }
-    const name = 'world'
-    const result = tag`hello ${name}`
-    assert(result === 'hello WORLD', '标签模板应正确处理')
-  })
-
-  test('标签模板 - String.raw', () => {
-    const path = String.raw`C:\Users\test\n`
-    assert(path.includes('\\n'), 'String.raw 应保留原始反斜杠')
-  })
-
-  test('模板字符串中调用函数', () => {
-    const upper = (s) => s.toUpperCase()
-    const str = `result: ${upper('hello')}`
-    assert(str === 'result: HELLO', '模板字符串中可调用函数')
-  })
-
   return getResults()
 }

package/src/features/es2015/04-destructuring.js

@@ -13,56 +13,5 @@ export function testDestructuring() {
     assert(second === 2 && fourth === 4, '数组解构可跳过元素')
   })
 
-  test('数组解构 - 默认值', () => {
-    const [x = 10, y = 20] = [1]
-    assert(x === 1 && y === 20, '数组解构默认值')
-  })
-
-  test('数组解构 - rest 元素', () => {
-    const [first, ...rest] = [1, 2, 3, 4]
-    assert(first === 1 && rest.length === 3, '数组解构 rest 元素')
-  })
-
-  test('数组解构 - 交换变量', () => {
-    let p = 1, q = 2;
-    [p, q] = [q, p]
-    assert(p === 2 && q === 1, '解构交换变量')
-  })
-
-  test('对象解构 - 基本', () => {
-    const { name, age } = { name: 'Alice', age: 25 }
-    assert(name === 'Alice' && age === 25, '对象解构基本用法')
-  })
-
-  test('对象解构 - 重命名', () => {
-    const { name: userName, age: userAge } = { name: 'Bob', age: 30 }
-    assert(userName === 'Bob' && userAge === 30, '对象解构重命名')
-  })
-
-  test('对象解构 - 默认值', () => {
-    const { a = 1, b = 2 } = { a: 10 }
-    assert(a === 10 && b === 2, '对象解构默认值')
-  })
-
-  test('对象解构 - rest 属性', () => {
-    const { x, ...others } = { x: 1, y: 2, z: 3 }
-    assert(x === 1 && others.y === 2 && others.z === 3, '对象解构 rest 属性')
-  })
-
-  test('嵌套解构', () => {
-    const { a: { b: { c } } } = { a: { b: { c: 42 } } }
-    assert(c === 42, '嵌套解构')
-  })
-
-  test('函数参数解构', () => {
-    const fn = ({ name, age = 18 }) => `${name}:${age}`
-    assert(fn({ name: 'Alice' }) === 'Alice:18', '函数参数解构')
-  })
-
-  test('字符串解构', () => {
-    const [a, b, c] = 'abc'
-    assert(a === 'a' && b === 'b' && c === 'c', '字符串解构')
-  })
-
   return getResults()
 }

package/src/features/es2015/05-default-rest-spread.js

@@ -3,80 +3,6 @@ import { createSuite } from '../../utils/runner.js'
 export function testDefaultRestSpread() {
   const { test, assert, getResults } = createSuite('默认参数/Rest/Spread')
 
-  // 默认参数
-  test('默认参数 - 基本', () => {
-    const greet = (name = 'World') => `Hello, ${name}!`
-    assert(greet() === 'Hello, World!', '默认参数应生效')
-    assert(greet('Alice') === 'Hello, Alice!', '传参时默认参数应被覆盖')
-  })
-
-  test('默认参数 - undefined 触发默认值', () => {
-    const fn = (a = 1) => a
-    assert(fn(undefined) === 1, 'undefined 触发默认参数')
-    assert(fn(null) === null, 'null 不触发默认参数')
-  })
-
-  test('默认参数 - 使用前面的参数', () => {
-    const fn = (a, b = a * 2) => b
-    assert(fn(5) === 10, '默认参数可引用前面的参数')
-  })
-
-  test('默认参数 - 表达式', () => {
-    const fn = (x = Math.random()) => x
-    const result = fn()
-    assert(typeof result === 'number', '默认参数可以是表达式')
-  })
-
-  // Rest 参数
-  test('rest 参数 - 收集剩余参数', () => {
-    const sum = (first, ...rest) => rest.reduce((acc, n) => acc + n, first)
-    assert(sum(1, 2, 3, 4) === 10, 'rest 参数应收集剩余参数')
-  })
-
-  test('rest 参数 - 是真正的数组', () => {
-    const fn = (...args) => Array.isArray(args)
-    assert(fn(1, 2, 3) === true, 'rest 参数是真正的数组')
-  })
-
-  test('rest 参数只能在最后', () => {
-    try {
-      new Function('function f(...a, b){}')()
-      assert(false, '应抛出 SyntaxError')
-    } catch (e) {
-      assert(true, 'rest 参数只能在最后')
-    }
-  })
-
-  // Spread 操作符
-  test('spread 展开数组', () => {
-    const a = [1, 2, 3]
-    const b = [0, ...a, 4]
-    assert(b.join(',') === '0,1,2,3,4', 'spread 展开数组')
-  })
-
-  test('spread 复制数组', () => {
-    const original = [1, 2, 3]
-    const copy = [...original]
-    copy.push(4)
-    assert(original.length === 3 && copy.length === 4, 'spread 复制数组为浅拷贝')
-  })
-
-  test('spread 合并数组', () => {
-    const merged = [...[1, 2], ...[3, 4], ...[5]]
-    assert(merged.join(',') === '1,2,3,4,5', 'spread 合并数组')
-  })
-
-  test('spread 传入函数参数', () => {
-    const nums = [1, 2, 3]
-    assert(Math.max(...nums) === 3, 'spread 传入函数参数')
-  })
-
-  test('spread 展开对象', () => {
-    const obj1 = { a: 1, b: 2 }
-    const obj2 = { ...obj1, c: 3 }
-    assert(obj2.a === 1 && obj2.b === 2 && obj2.c === 3, 'spread 展开对象')
-  })
-
   test('spread 对象覆盖属性', () => {
     const base = { a: 1, b: 2 }
     const extended = { ...base, b: 99 }

package/src/features/es2015/08-symbols.js

@@ -9,77 +9,6 @@ export function testSymbols() {
     assert(s1 !== s2, '相同描述的 Symbol 不相等')
   })
 
-  test('Symbol 描述属性', () => {
-    const s = Symbol('my-symbol')
-    assert(s.description === 'my-symbol', 'Symbol.description 应返回描述字符串')
-  })
-
-  test('Symbol 作为对象属性键', () => {
-    const key = Symbol('key')
-    const obj = { [key]: 'value' }
-    assert(obj[key] === 'value', 'Symbol 可作为对象属性键')
-  })
-
-  test('Symbol 属性不被普通枚举', () => {
-    const sym = Symbol('hidden')
-    const obj = { [sym]: 1, visible: 2 }
-    assert(!Object.keys(obj).includes(sym.toString()), 'Symbol 属性不出现在 Object.keys 中')
-    assert(Object.getOwnPropertySymbols(obj).length === 1, 'getOwnPropertySymbols 可获取 Symbol 属性')
-  })
-
-  test('Symbol.for 全局注册', () => {
-    const s1 = Symbol.for('shared')
-    const s2 = Symbol.for('shared')
-    assert(s1 === s2, 'Symbol.for 应返回同一个 Symbol')
-  })
-
-  test('Symbol.keyFor 获取注册键', () => {
-    const s = Symbol.for('test-key')
-    assert(Symbol.keyFor(s) === 'test-key', 'Symbol.keyFor 应返回注册键')
-    const local = Symbol('local')
-    assert(Symbol.keyFor(local) === undefined, '未注册的 Symbol 返回 undefined')
-  })
-
-  test('内置 Symbol - Symbol.iterator', () => {
-    class Range {
-      constructor(start, end) { this.start = start; this.end = end }
-      [Symbol.iterator]() {
-        let current = this.start
-        const end = this.end
-        return {
-          next() {
-            return current <= end
-              ? { value: current++, done: false }
-              : { done: true }
-          }
-        }
-      }
-    }
-    const result = [...new Range(1, 3)]
-    assert(result.join(',') === '1,2,3', 'Symbol.iterator 自定义迭代器')
-  })
-
-  test('内置 Symbol - Symbol.toPrimitive', () => {
-    const obj = {
-      [Symbol.toPrimitive](hint) {
-        if (hint === 'number') return 42
-        if (hint === 'string') return 'forty-two'
-        return true
-      }
-    }
-    assert(+obj === 42, 'Symbol.toPrimitive number')
-    assert(`${obj}` === 'forty-two', 'Symbol.toPrimitive string')
-  })
-
-  test('Symbol.hasInstance', () => {
-    class EvenNumber {
-      static [Symbol.hasInstance](num) {
-        return Number.isInteger(num) && num % 2 === 0
-      }
-    }
-    assert(2 instanceof EvenNumber, '2 应为 EvenNumber 实例')
-    assert(!(3 instanceof EvenNumber), '3 不应为 EvenNumber 实例')
-  })
 
   return getResults()
 }

package/src/features/es2015/09-iterators-generators.js

@@ -29,76 +29,5 @@ export function testIteratorsGenerators() {
     assert(result.join(',') === '10,20,30', 'for...of 迭代数组')
   })
 
-  test('字符串是可迭代的', () => {
-    const chars = [...'hello']
-    assert(chars.length === 5 && chars[0] === 'h', '字符串可用 for...of 迭代')
-  })
-
-  test('基本生成器函数', () => {
-    function* gen() {
-      yield 1
-      yield 2
-      yield 3
-    }
-    const g = gen()
-    assert(g.next().value === 1, '生成器第一个 yield')
-    assert(g.next().value === 2, '生成器第二个 yield')
-    assert(g.next().value === 3, '生成器第三个 yield')
-    assert(g.next().done === true, '生成器结束')
-  })
-
-  test('生成器可作为可迭代对象', () => {
-    function* range(start, end) {
-      for (let i = start; i <= end; i++) yield i
-    }
-    const result = [...range(1, 5)]
-    assert(result.join(',') === '1,2,3,4,5', '生成器展开为数组')
-  })
-
-  test('生成器 yield* 委托', () => {
-    function* inner() { yield 'a'; yield 'b' }
-    function* outer() { yield 1; yield* inner(); yield 2 }
-    const result = [...outer()]
-    assert(result.join(',') === '1,a,b,2', 'yield* 委托生成器')
-  })
-
-  test('生成器双向通信', () => {
-    function* adder() {
-      let total = 0
-      while (true) {
-        const n = yield total
-        if (n === null) break
-        total += n
-      }
-    }
-    const g = adder()
-    g.next()       // 启动
-    g.next(5)      // total = 5
-    g.next(3)      // total = 8
-    const { value } = g.next(2)  // total = 10
-    assert(value === 10, '生成器双向通信')
-  })
-
-  test('无限序列生成器', () => {
-    function* fibonacci() {
-      let [a, b] = [0, 1]
-      while (true) {
-        yield a;
-        [a, b] = [b, a + b]
-      }
-    }
-    const fib = fibonacci()
-    const first8 = Array.from({ length: 8 }, () => fib.next().value)
-    assert(first8.join(',') === '0,1,1,2,3,5,8,13', '斐波那契生成器')
-  })
-
-  test('生成器 return 方法提前结束', () => {
-    function* gen() { yield 1; yield 2; yield 3 }
-    const g = gen()
-    assert(g.next().value === 1, '第一个值')
-    assert(g.return('done').value === 'done', 'return 方法')
-    assert(g.next().done === true, '提前结束后 done 为 true')
-  })
-
   return getResults()
 }

package/src/features/es2015/10-map-set.js

@@ -15,92 +15,7 @@ export function testMapSet() {
     assert(m.size === 1, '删除后 size 应为 1')
   })
 
-  test('Map 支持任意类型键', () => {
-    const m = new Map()
-    const obj = {}
-    const fn = () => {}
-    m.set(obj, 'object-value')
-    m.set(fn, 'function-value')
-    m.set(42, 'number-value')
-    assert(m.get(obj) === 'object-value', '对象作为键')
-    assert(m.get(fn) === 'function-value', '函数作为键')
-    assert(m.get(42) === 'number-value', '数字作为键')
-  })
-
-  test('Map 从数组初始化', () => {
-    const m = new Map([['x', 10], ['y', 20]])
-    assert(m.get('x') === 10 && m.get('y') === 20, 'Map 从数组初始化')
-  })
-
-  test('Map 迭代', () => {
-    const m = new Map([['a', 1], ['b', 2], ['c', 3]])
-    const keys = [...m.keys()]
-    const values = [...m.values()]
-    const entries = [...m.entries()]
-    assert(keys.join(',') === 'a,b,c', 'Map.keys 迭代')
-    assert(values.join(',') === '1,2,3', 'Map.values 迭代')
-    assert(entries.length === 3, 'Map.entries 迭代')
-  })
-
-  test('Map forEach', () => {
-    const m = new Map([['a', 1], ['b', 2]])
-    let result = ''
-    m.forEach((v, k) => { result += `${k}=${v} ` })
-    assert(result.trim() === 'a=1 b=2', 'Map.forEach 遍历')
-  })
-
-  // Set
-  test('Set 基本操作', () => {
-    const s = new Set([1, 2, 3, 2, 1])
-    assert(s.size === 3, 'Set 自动去重，size 应为 3')
-    assert(s.has(2) === true, 'Set.has 检查元素')
-    s.delete(2)
-    assert(s.has(2) === false, 'Set.delete 删除元素')
-  })
-
-  test('Set 数组去重', () => {
-    const arr = [1, 2, 2, 3, 3, 4]
-    const unique = [...new Set(arr)]
-    assert(unique.join(',') === '1,2,3,4', 'Set 用于数组去重')
-  })
-
-  test('Set 迭代', () => {
-    const s = new Set(['a', 'b', 'c'])
-    const result = []
-    for (const val of s) result.push(val)
-    assert(result.join(',') === 'a,b,c', 'Set for...of 迭代')
-  })
-
-  test('Set 集合运算', () => {
-    const a = new Set([1, 2, 3, 4])
-    const b = new Set([3, 4, 5, 6])
-    const union = new Set([...a, ...b])
-    const intersection = new Set([...a].filter(x => b.has(x)))
-    const difference = new Set([...a].filter(x => !b.has(x)))
-    assert([...union].join(',') === '1,2,3,4,5,6', 'Set 并集')
-    assert([...intersection].join(',') === '3,4', 'Set 交集')
-    assert([...difference].join(',') === '1,2', 'Set 差集')
-  })
-
-  // WeakMap & WeakSet
-  test('WeakMap 基本操作', () => {
-    const wm = new WeakMap()
-    const key = {}
-    wm.set(key, 'value')
-    assert(wm.has(key) === true, 'WeakMap.has 应返回 true')
-    assert(wm.get(key) === 'value', 'WeakMap.get 应返回正确值')
-    wm.delete(key)
-    assert(wm.has(key) === false, 'WeakMap.delete 删除成功')
-  })
-
-  test('WeakSet 基本操作', () => {
-    const ws = new WeakSet()
-    const obj = {}
-    ws.add(obj)
-    assert(ws.has(obj) === true, 'WeakSet.has 应返回 true')
-    ws.delete(obj)
-    assert(ws.has(obj) === false, 'WeakSet.delete 删除成功')
-  })
+  
 
   return getResults()
 }

package/src/features/es2015/11-proxy-reflect.js

@@ -33,90 +33,7 @@ export function testProxyReflect() {
     }
   })
 
-  test('Proxy has 拦截', () => {
-    const range = { min: 1, max: 10 }
-    const proxy = new Proxy(range, {
-      has(target, key) {
-        const num = Number(key)
-        return num >= target.min && num <= target.max
-      }
-    })
-    assert(5 in proxy, '5 在范围内')
-    assert(!(11 in proxy), '11 不在范围内')
-  })
-
-  test('Proxy deleteProperty 拦截', () => {
-    const proxy = new Proxy({ a: 1, b: 2 }, {
-      deleteProperty(target, key) {
-        if (key === 'b') throw new Error('b 不可删除')
-        delete target[key]
-        return true
-      }
-    })
-    delete proxy.a
-    assert(!('a' in proxy), 'a 已删除')
-    try {
-      delete proxy.b
-      assert(false, '应抛出错误')
-    } catch (e) {
-      assert(e.message === 'b 不可删除', 'b 删除被拦截')
-    }
-  })
-
-  test('Proxy apply 拦截函数调用', () => {
-    function sum(a, b) { return a + b }
-    const proxy = new Proxy(sum, {
-      apply(target, thisArg, args) {
-        return target(...args) * 2
-      }
-    })
-    assert(proxy(3, 4) === 14, 'Proxy apply 拦截函数调用')
-  })
-
-  test('Proxy construct 拦截 new', () => {
-    class Animal {
-      constructor(name) { this.name = name }
-    }
-    const proxy = new Proxy(Animal, {
-      construct(target, args) {
-        const instance = new target(...args)
-        instance.created = true
-        return instance
-      }
-    })
-    const a = new proxy('Cat')
-    assert(a.name === 'Cat' && a.created === true, 'Proxy construct 拦截')
-  })
-
-  // Reflect
-  test('Reflect.get', () => {
-    const obj = { x: 42 }
-    assert(Reflect.get(obj, 'x') === 42, 'Reflect.get 获取属性')
-  })
-
-  test('Reflect.set', () => {
-    const obj = {}
-    Reflect.set(obj, 'y', 100)
-    assert(obj.y === 100, 'Reflect.set 设置属性')
-  })
-
-  test('Reflect.has', () => {
-    const obj = { a: 1 }
-    assert(Reflect.has(obj, 'a') === true, 'Reflect.has 检查属性')
-    assert(Reflect.has(obj, 'z') === false, 'Reflect.has 不存在属性')
-  })
-
-  test('Reflect.ownKeys', () => {
-    const sym = Symbol('s')
-    const obj = { a: 1, [sym]: 2 }
-    const keys = Reflect.ownKeys(obj)
-    assert(keys.includes('a') && keys.includes(sym), 'Reflect.ownKeys 返回所有键含 Symbol')
-  })
-
-  test('Reflect.apply', () => {
-    const result = Reflect.apply(Math.max, null, [1, 2, 3])
-    assert(result === 3, 'Reflect.apply 调用函数')
-  })
+  
 
   return getResults()
 }