ts-run-test 1.0.5

package/_test_/iterator.ts

@@ -0,0 +1,112 @@
+interface MyIterator {
+  data: number[];
+  
+  [Symbol.iterator](): Iterator<number>;
+}
+
+const myIterator: MyIterator = {
+  data: [ 1, 2, 3, 4, 5, 6, 7, 8, 9 ],
+  [Symbol.iterator]() {
+    let idx = 0
+    const data = this.data
+    return {
+      next() {
+        if (idx < data.length) {
+          return { done: false, value: data[idx++] }
+        } else {
+          return { done: true, value: undefined }
+        }
+      },
+    }
+  },
+}
+
+for (const input of myIterator) {
+  console.log(input)
+}
+
+// ------------------------------------------
+
+function* myGenerator(): Generator<number> {
+  yield 1
+  yield 2
+  yield 3
+  yield 4
+}
+
+const gen: Generator<number> = myGenerator()
+for (const number of gen) {
+  console.log(number)
+}
+
+// ------------------------------------------
+
+type IteratorMode = 'entries' | 'keys' | 'values'
+
+type ElementType<T, M extends IteratorMode> = M extends 'entries'
+  ? [ keyof T, T[keyof T] ]
+  : M extends 'keys'
+    ? keyof T
+    : T[keyof T];
+
+type IterableReturn<T, M extends IteratorMode> = T & Iterable<ElementType<T, M>>;
+
+const makeIterable = <T extends object, M extends IteratorMode>(obj: T, mode: M): IterableReturn<T, M> => {
+  const iterable: Iterable<ElementType<T, M>> =
+    mode === 'entries'
+      ? Object.entries(obj)
+      : mode === 'keys'
+        ? Object.keys(obj)
+        : Object.values(obj)
+  
+  function* iteratorFactory(): Generator<ElementType<T, M>> {
+    for (const item of iterable) {
+      yield item
+    }
+  }
+  
+  return Object.assign(obj, {
+    [Symbol.iterator]: iteratorFactory,
+  })
+}
+
+const makeIterable1 = <T extends object, M extends IteratorMode>(obj: T, mode: M): IterableReturn<T, M> => {
+  let temp: ElementType<T, M>[]
+  switch (mode) {
+    case 'entries':
+      temp = Object.entries(obj) as ElementType<T, M>[]
+      break
+    case 'keys':
+      temp = Object.keys(obj) as ElementType<T, M>[]
+      break
+    case 'values':
+    default:
+      temp = Object.values(obj) as ElementType<T, M>[]
+      break
+  }
+  
+  const iteratorFactory = (): Iterator<ElementType<T, M>> => {
+    let index = 0
+    return {
+      next(): IteratorResult<ElementType<T, M>> {
+        if (index < temp.length) {
+          return { done: false, value: temp[index++] }
+        } else {
+          return { done: true, value: undefined }
+        }
+      },
+    }
+  }
+  
+  return Object.assign(obj, {
+    [Symbol.iterator]: iteratorFactory,
+  })
+}
+
+const make: IterableReturn<{ a: number; b: number; }, 'entries'> = makeIterable({ a: 1, b: 2 }, 'entries')
+
+for (const [ key, val ] of make) {
+  console.log(key, val)
+}
+
+// ------------------------------------------

package/_test_/link.ts

@@ -0,0 +1,10 @@
+export const pathToLink = (path: string, rootDir = '.', srcDir = '.'): string => path
+  .replace(new RegExp(`(^(\/?)${ rootDir }\/)+`, 'g'), '/')
+  .replace(new RegExp(`(^(\/?)${ srcDir }\/)+`, 'g'), '/')
+  .replace(/\.md$/i, '')
+  .replace(/\/index$/g, '/')
+  .replace(/\/+/g, '/')
+
+
+console.log(pathToLink('docs/src/guide/index.md', 'docs', 'src'))
+

package/_test_/my/instanceof.ts

@@ -0,0 +1,35 @@
+// const instanceOf = <I, C extends object>(inst: I, Constructor: C) => {
+//   let proto = Object.getPrototypeOf(inst)
+//
+//   while (proto) {
+//     if (proto === Constructor.prototype) {
+//       return true
+//     }
+//     proto = Object.getPrototypeOf(proto)
+//   }
+//
+//   return false
+// }
+
+const instanceOf = <T extends object>(
+  inst: unknown,
+  Constructor: new (...args: any[]) => T,
+): inst is T => {
+  let proto = Object.getPrototypeOf(inst)
+  
+  while (proto) {
+    if (proto === Constructor.prototype) {
+      return true
+    }
+    proto = Object.getPrototypeOf(proto)
+  }
+  
+  return false
+}
+
+
+console.log(instanceOf({}, Object))
+
+console.log(instanceOf([], Object))
+
+console.log(instanceOf({}, String))

package/_test_/my/new.ts

@@ -0,0 +1,22 @@
+function myNew<C extends new (...args: any[]) => any>(
+  constructor: C,
+  ...args: ConstructorParameters<C>
+): InstanceType<C> {
+  const obj = Object.create(constructor.prototype)
+  
+  const result = constructor.apply(obj, args)
+  
+  return (typeof result === 'object' && result !== null) ? result : obj
+}
+
+
+function myNew1(Func: Function, ...args: any[]) {
+  // 1. 创建一个空对象
+  const obj = Object.create(null)
+  // 2. 将构造函数原型对象指向新对象原型
+  obj.__proto__ = Func.prototype
+  // 3. 将构造函数的 this 指向新对象
+  const result = Func.apply(obj, args)
+  // 4. 根据返回值判断
+  return result instanceof Object ? result : obj
+}

package/_test_/new.ts

@@ -0,0 +1,6 @@
+function myNew(Fun: Function, ...args: any[]) {
+  const obj = Object.create(null)
+  obj._proto_ = Fun.prototype
+  const res = Fun.apply(obj, args)
+  return res instanceof Object ? res : obj
+}

package/_test_/object.ts

@@ -0,0 +1,2 @@
+Object.entries({a: 1, b: 2, c: 3})
+

package/_test_/observer.html

@@ -0,0 +1,40 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>Observer</title>
+  <style>
+    * {
+      margin: 0;
+      padding: 0;
+    }
+  </style>
+</head>
+
+<body>
+<div class="wrapper">
+<div class="container">
+  <h1>Observer</h1>
+  <div>55</div>
+</div>
+<!-- /.container -->
+</div>
+</body>
+
+<script >
+  const observer = new MutationObserver((mutations) => {
+    console.log(mutations)
+  })
+  observer.observe(document.body, {
+    childList: true
+  })
+  
+  
+  const resize = new ResizeObserver((entries) => {
+    console.log(entries)
+  })
+  resize.observe(document.body, {
+    box: 'border-box'
+  })
+</script>
+</html>

package/_test_/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "electron-app",
+  "productName": "electron-app",
+  "version": "0.0.0",
+  "description": "",
+  "license": "MIT",
+  "main": ".vite/build/main.js",
+  "scripts": {
+    "dev": "electron-forge start",
+    "build": "electron-forge make"
+  },
+  "devDependencies": {
+    "@electron-forge/cli": "^7.10.2",
+    "@electron-forge/maker-deb": "^7.10.2",
+    "@electron-forge/maker-dmg": "^7.10.2",
+    "@electron-forge/maker-msix": "^7.10.2",
+    "@electron-forge/maker-rpm": "^7.10.2",
+    "@electron-forge/maker-squirrel": "^7.10.2",
+    "@electron-forge/maker-zip": "^7.10.2",
+    "@electron-forge/plugin-auto-unpack-natives": "^7.10.2",
+    "@electron-forge/plugin-electronegativity": "^7.10.2",
+    "@electron-forge/plugin-fuses": "^7.10.2",
+    "@electron-forge/plugin-vite": "^7.10.2",
+    "@electron-forge/publisher-github": "^7.10.2",
+    "@electron-forge/shared-types": "^7.10.2",
+    "@electron/fuses": "^2.0.0",
+    "electron": "^39.2.4",
+    "typescript": "^5.9.3",
+    "vite": "7.2.6",
+    "vite-plugin-html": "^3.2.2"
+  },
+  "dependencies": {
+    "@peiyanlu/electron-ipc": "^1.0.10",
+    "@peiyanlu/ts-utils": "^0.0.1"
+  },
+  "author": {
+    "name": "",
+    "email": ""
+  },
+  "os": [
+    "win32",
+    "darwin",
+    "linux"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ]
+}

package/_test_/prototype.ts

@@ -0,0 +1,27 @@
+class Person {
+  protected age: number = 18
+  
+  constructor() {
+    
+  }
+  
+  clone() {
+    return cloneInstance(this)
+  }
+}
+
+export const cloneInstance = <T extends {}>(source: T): T => {
+  return Object.assign<T, T>(Object.create(Object.getPrototypeOf(source)), source)
+}
+
+
+const person = new Person()
+
+
+console.log(cloneInstance(person), 'constructor')
+console.log(person.clone(), 'constructor')
+
+const obj: Record<string, number> = { a: 1, b: 2 }
+const clone = cloneInstance(obj)
+clone.c = 122
+console.log(obj, clone, 'object')

package/_test_/proxy.ts

@@ -0,0 +1,6 @@
+const proxy = new Proxy({}, {
+  set(target, key, value, receiver) {
+    console.log(`set ${ key }=${ value }`);
+    return Reflect.set(target, key, value, receiver);
+  }
+});

package/_test_/random.ts

@@ -0,0 +1,29 @@
+// [min, max]
+const random = (min: number, max: number) => {
+  return Math.floor(Math.random() * (max - min + 1)) + min
+}
+
+// [min, max)
+const random1 = (min: number, max: number) => {
+  return Math.floor(Math.random() * (max - min)) + min
+}
+
+// (min, max)
+const random2 = (min: number, max: number) => {
+  return Math.ceil(Math.random() * (max - min - 1)) + min
+}
+
+// (min, max]
+const random3 = (min: number, max: number) => {
+  return Math.ceil(Math.random() * (max - min)) + min
+}
+
+
+for (let i = 0; i < 1000; i++) {
+  const r = random2(1, 5)
+  // console.log(r)
+  
+  if ([ 1, 5 ].includes(r)) {
+    console.log(r)
+  }
+}

package/_test_/reg.ts

@@ -0,0 +1 @@
+/src\/index.ts$/.test('')

package/_test_/register.ts

@@ -0,0 +1,61 @@
+import { spawn } from 'node:child_process'
+import { existsSync } from 'node:fs'
+import { resolve } from 'node:path'
+import { pathToFileURL } from 'node:url'
+
+
+export function isTSFile(file: string) {
+  return /\.(ts|mts|cts)$/.test(file)
+}
+
+
+export async function loadConfig<T = unknown>(file: string): Promise<T> {
+  const url = pathToFileURL(file).href
+  console.log(url)
+  const mod = await import(url)
+  // 兼容 export default / module.exports
+  return mod.default ?? mod
+}
+
+
+export function findConfigFile(cwd = process.cwd()) {
+  const files = [
+    'release.config.ts',
+    'release.config.mts',
+    'release.config.cts',
+    'release.config.js',
+    'release.config.mjs',
+    'release.config.cjs',
+  ]
+  
+  for (const file of files) {
+    const absPath = resolve(cwd, file)
+    if (existsSync(absPath)) {
+      return absPath
+    }
+  }
+  
+  return
+}
+
+export async function resolveConfig<T = unknown>(cwd?: string): Promise<T | null> {
+  const configFile = findConfigFile(cwd)
+  
+  if (!configFile) return null
+  
+  return await loadConfig<T>(configFile)
+}
+
+resolveConfig().then(res => {
+  console.log(res)
+})
+
+
+const spawnAsync = (...args: Parameters<typeof spawn>) => {
+  return new Promise((resolve) => {
+    spawn(...args).on('close', code => {
+      return 1 === code ? resolve(true) : resolve(false)
+    })
+  })
+}
+

package/_test_/release.config.cts

@@ -0,0 +1,11 @@
+function defineConfig(config) {
+  return config
+}
+
+
+export default defineConfig({
+  aaa: 123,
+  bbb: 123,
+  ccc: 123,
+  ddd: 123,
+})

package/_test_/result.ts

@@ -0,0 +1,37 @@
+console.log([] == ![]) // true
+
+console.log(![]) // fase
+
+
+console.log(1 + 2 + '3')
+console.log(1 + '2' + 3)
+
+queueMicrotask(() => {
+  console.log('queueMicrotask')
+})
+
+setTimeout(()=>{
+  console.log('setTimeout')
+})
+
+console.log(8888)
+
+
+console.log(Object.create(null))
+
+console.log(({}) + [])
+
+
+let a = { n: 1 };
+let b = a;
+a.x = a = { n: 2 }
+
+console.log(a)
+console.log(b)
+
+
+console.log([ , , , ].length)
+
+
+console.log(0 in [ undefined ])
+console.log(0 in [ , ])

package/_test_/task.ts

@@ -0,0 +1,196 @@
+// ✅ 高级任务池 TaskPool，支持：
+// - 并发控制
+// - 优先级调度
+// - 任务取消（AbortController）
+// - DAG（依赖图）调度
+// - UMD 支持（适配浏览器和 Node）
+
+// ------- 类型定义 --------
+type TaskFn<T> = (signal?: AbortSignal) => Promise<T>
+
+type TaskState = 'pending' | 'running' | 'completed' | 'failed' | 'canceled'
+
+interface TaskNode<T> {
+  id: string
+  run: TaskFn<T>
+  priority: number
+  dependencies: string[]
+  controller: AbortController
+  state: TaskState
+  retries: number
+}
+
+interface TaskPoolOptions {
+  concurrency?: number
+  maxRetries?: number
+  onProgress?: (done: number, total: number) => void
+  onError?: (id: string, error: any) => void
+  onComplete?: () => void
+  onStart?: (id: string) => void
+  onSuccess?: (id: string) => void
+}
+
+// ------- TaskPool 实现 --------
+export class TaskPool<T = any> {
+  private tasks: Map<string, TaskNode<T>> = new Map()
+  private running = 0
+  private done = 0
+  private readonly concurrency: number
+  private readonly maxRetries: number
+  private options: TaskPoolOptions
+  
+  constructor(options: TaskPoolOptions = {}) {
+    this.concurrency = options.concurrency ?? 2
+    this.maxRetries = options.maxRetries ?? 0
+    this.options = options
+  }
+  
+  addTask(
+    id: string,
+    taskFn: TaskFn<T>,
+    priority = 0,
+    dependencies: string[] = [],
+  ) {
+    const controller = new AbortController()
+    const task: TaskNode<T> = {
+      id,
+      run: taskFn,
+      priority,
+      dependencies,
+      controller,
+      state: 'pending',
+      retries: 0,
+    }
+    this.tasks.set(id, task)
+    this.schedule()
+  }
+  
+  cancelTask(id: string) {
+    const task = this.tasks.get(id)
+    if (task && task.state === 'pending') {
+      task.controller.abort()
+      task.state = 'canceled'
+    }
+  }
+  
+  cancelAll() {
+    for (const task of this.tasks.values()) {
+      if (task.state === 'pending') {
+        task.controller.abort()
+        task.state = 'canceled'
+      }
+    }
+  }
+  
+  private getRunnableTasks(): TaskNode<T>[] {
+    return [ ...this.tasks.values() ]
+      .filter(t =>
+        t.state === 'pending' &&
+        t.dependencies.every(dep => this.tasks.get(dep)?.state === 'completed'),
+      )
+      .sort((a, b) => b.priority - a.priority)
+  }
+  
+  private schedule() {
+    while (this.running < this.concurrency) {
+      const task = this.getRunnableTasks()[0]
+      if (!task) break
+      this.runTask(task).finally()
+    }
+  }
+  
+  private async runTask(task: TaskNode<T>) {
+    task.state = 'running'
+    this.running++
+    this.options.onStart?.(task.id)
+    try {
+      await task.run(task.controller.signal)
+      task.state = 'completed'
+      this.options.onSuccess?.(task.id)
+    } catch (e) {
+      if (task.controller.signal.aborted) {
+        task.state = 'canceled'
+      } else if (task.retries < this.maxRetries) {
+        task.retries++
+        task.state = 'pending'
+        this.running--
+        return this.schedule()
+      } else {
+        task.state = 'failed'
+        this.options.onError?.(task.id, e)
+      }
+    } finally {
+      this.running--
+      
+      if ([ 'completed', 'failed', 'canceled' ].includes(task.state)) {
+        this.done++
+        this.options.onProgress?.(this.done, this.tasks.size)
+        if (this.done === this.tasks.size) {
+          this.options.onComplete?.()
+        }
+      }
+      this.schedule()
+    }
+  }
+}
+
+// ------- 浏览器/Node 兼容（UMD 支持） --------
+// 可用 Rollup/Webpack 打包为 UMD 模块，或如下方式直接挂载：
+
+// @ts-ignore
+if (typeof window !== 'undefined') {
+  // @ts-ignore
+  window.TaskPool = TaskPool
+}
+// @ts-ignore
+if (typeof global !== 'undefined') {
+  // @ts-ignore
+  global.TaskPool = TaskPool
+}
+
+
+const sleep = (ms: number, label: string, fail = false) => () =>
+  new Promise<string>((resolve, reject) => {
+    setTimeout(() => {
+      if (fail && Math.random() < 0.5) return reject(new Error(label + ' fail'))
+      resolve(label)
+    }, ms)
+  })
+
+const delay = (ms: number) => new Promise(resolve => setTimeout(resolve, ms))
+
+const pool = new TaskPool({
+  concurrency: 2,
+  maxRetries: 1,
+  onStart: id => console.log(`[START] ${ id }`),
+  onSuccess: id => console.log(`[SUCCESS] ${ id }`),
+  onError: (id, err) => console.warn(`[ERROR] ${ id }:`, err),
+  onProgress: (done, total) => console.log(`[PROGRESS] ${ done }/${ total }`),
+  onComplete: () => console.log(`[COMPLETE] all tasks finished`),
+})
+
+pool.addTask('A', async () => {
+  await delay(1000)
+  console.log('Task A finished')
+}, 1)
+
+pool.addTask('B', async () => {
+  await delay(500)
+  console.log('Task B finished')
+}, 2)
+
+pool.addTask('C', async () => {
+  await delay(300)
+  console.log('Task C finished')
+}, 1, [ 'A', 'B' ])
+
+pool.addTask('D', async signal => {
+  await delay(400)
+  if (signal?.aborted) throw new Error('Task D was aborted')
+  console.log('Task D finished')
+}, 3)
+
+// 模拟取消 D
+setTimeout(() => {
+  // pool.cancelTask('D')
+}, 100)

package/_test_/temp.md

@@ -0,0 +1,8 @@
+BFC （块级格式化上下文）是 CSS 渲染过程中的一个独立渲染环境，它规定了内部块级子元素的排列方式，并且隔离外部布局影响
+
+1、独立渲染环境：BFC 内部的元素布局不受外部影响
+2、布局规则
+    1、内部会计子元素在垂直方向依次排列
+    2、相邻元素的垂直外边距会发生重叠
+    3、子元素的外边距与包含块的左边框相邻
+3、隔离性：内部子元素的排列方式不会影响外部布局

package/_test_/tesp.ts

@@ -0,0 +1,23 @@
+import { readFileSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import { format } from 'node:util'
+import semver from 'semver'
+import minimist from 'minimist'
+
+
+// const { name, type } = minimist(process.argv.slice(2))
+//
+// const templatePath = join('templates', name, 'template.json')
+//
+// const tpl = JSON.parse(readFileSync(templatePath, 'utf8'))
+// tpl.version = semver.inc(tpl.version, type)!
+//
+// writeFileSync(templatePath, JSON.stringify(tpl, null, 2) + '\n')
+//
+// console.log(`✔ ${ name } bumped to ${ tpl.version }`)
+
+
+const context = Object.assign({}, { version: '*' });
+const match = format('${version}', context);
+
+console.log(match)