@ohos-ports/stacksjs-stx 0.2.287-beta.0

package/dist/bun-shim.js

@@ -0,0 +1,496 @@
+// bun-shim.js — Node.js shim for Bun runtime APIs used by @stacksjs/stx dist output.
+// Maps Bun APIs to Node.js equivalents so the package can load without the Bun runtime.
+import fs from "node:fs"
+import fsp from "node:fs/promises"
+import path from "node:path"
+import http from "node:http"
+import { spawn, spawnSync } from "node:child_process"
+import { Readable } from "node:stream"
+import { webcrypto, createHash } from "node:crypto"
+import { createRequire } from "node:module"
+
+const EXISTS_OK = { __marker: true }
+
+class BunFile {
+  constructor(p, options) {
+    this.path = path.resolve(String(p))
+    this.options = options
+    try {
+      this.size = fs.statSync(this.path).size
+    }
+    catch {
+      this.size = 0
+    }
+    this.lastModified = 0
+    this.type = ''
+    this.name = path.basename(this.path)
+  }
+
+  async exists() {
+    try {
+      await fsp.access(this.path)
+      return true
+    }
+    catch {
+      return false
+    }
+  }
+
+  async text() {
+    return fsp.readFile(this.path, 'utf8')
+  }
+
+  async json() {
+    return JSON.parse(await fsp.readFile(this.path, 'utf8'))
+  }
+
+  async arrayBuffer() {
+    const buf = await fsp.readFile(this.path)
+    return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength)
+  }
+
+  async bytes() {
+    return fsp.readFile(this.path)
+  }
+
+  stream() {
+    return Readable.toWeb(fs.createReadStream(this.path))
+  }
+
+  slice() {
+    return new BunFile(this.path)
+  }
+}
+
+export function file(p, options) {
+  return new BunFile(p, options)
+}
+
+function toBuffer(data) {
+  if (typeof data === 'string')
+    return Buffer.from(data)
+  if (Buffer.isBuffer(data))
+    return data
+  if (data instanceof Uint8Array)
+    return Buffer.from(data)
+  if (data instanceof ArrayBuffer)
+    return Buffer.from(new Uint8Array(data))
+  if (data && typeof data.arrayBuffer === 'function')
+    return data.arrayBuffer().then(ab => Buffer.from(new Uint8Array(ab)))
+  if (data && typeof data === 'object' && 'text' in data && typeof data.text === 'function')
+    return data.text().then(t => Buffer.from(t))
+  return Buffer.from(String(data ?? ''))
+}
+
+export async function write(dest, data, options) {
+  const buf = await toBuffer(data)
+  await fsp.mkdir(path.dirname(path.resolve(String(dest))), { recursive: true })
+  await fsp.writeFile(String(dest), buf, options)
+  return buf.length
+}
+
+export function cp(src, dest) {
+  return fsp.cp(src, dest, { recursive: true })
+}
+
+export function unlink(p) {
+  return fsp.rm(p, { force: true })
+}
+
+// Bun.serve -> node:http server with a fetch-compatible bridge
+export function serve(options = {}) {
+  const fetchHandler = typeof options.fetch === 'function' ? options.fetch : null
+  const port = options.port ?? 3000
+  const hostname = options.hostname ?? '0.0.0.0'
+
+  const nodeServer = http.createServer(async (req, res) => {
+    if (!fetchHandler) {
+      res.statusCode = 404
+      res.end('Not Found')
+      return
+    }
+    try {
+      const url = `http://${req.headers.host || `${hostname}:${port}`}${req.url || '/'}`
+      const init = {
+        method: req.method,
+        headers: req.headers,
+      }
+      if (req.method !== 'GET' && req.method !== 'HEAD')
+        init.body = Readable.toWeb(req)
+      // @ts-expect-error Request is available globally in Node 18+
+      const request = new Request(url, init)
+      const response = await fetchHandler(request, { pendingRequests: 0 })
+      if (!response) {
+        res.destroy()
+        return
+      }
+      res.statusCode = response.status
+      response.headers.forEach((value, key) => {
+        if (key.toLowerCase() !== 'content-encoding')
+          res.setHeader(key, value)
+      })
+      if (response.body)
+        Readable.fromWeb(response.body).pipe(res)
+      else
+        res.end()
+    }
+    catch (error) {
+      res.statusCode = 500
+      res.end(`Internal Server Error: ${error?.message ?? error}`)
+    }
+  })
+
+  nodeServer.listen(port, hostname)
+
+  return {
+    port,
+    hostname,
+    stopped: false,
+    pendingRequests: 0,
+    stop(closeActiveConnections) {
+      this.stopped = true
+      nodeServer.close(() => {})
+      if (closeActiveConnections)
+        nodeServer.closeAllConnections?.()
+    },
+    reload(options) {
+      if (options?.fetch)
+        options.fetch = options.fetch
+    },
+    upgrade() {
+      return false
+    },
+    publish() {
+      return 0
+    },
+    requestIP() {
+      return null
+    },
+  }
+}
+
+// Bun.spawn -> node:child_process.spawn with Bun-compatible surface
+export function bunSpawn(cmd, options = {}) {
+  const [bin, ...args] = Array.isArray(cmd) ? cmd : [cmd]
+  const child = spawn(bin, args, {
+    cwd: options.cwd,
+    env: options.env,
+    stdio: options.stdio ?? ['ignore', 'pipe', 'pipe'],
+    shell: options.shell,
+  })
+  const stdoutChunks = []
+  const stderrChunks = []
+  const promise = new Promise((resolve) => {
+    child.stdout?.on('data', c => stdoutChunks.push(c))
+    child.stderr?.on('data', c => stderrChunks.push(c))
+    child.on('close', (exitCode) => {
+      resolve({
+        exitCode: exitCode ?? 0,
+        success: (exitCode ?? 0) === 0,
+        signalCode: null,
+        killed: child.killed,
+        pid: child.pid,
+        stdout: () => Buffer.concat(stdoutChunks).toString(),
+        stderr: () => Buffer.concat(stderrChunks).toString(),
+      })
+    })
+    child.on('error', (error) => {
+      resolve({
+        exitCode: 1,
+        success: false,
+        signalCode: null,
+        killed: true,
+        pid: child.pid,
+        stdout: () => Buffer.concat(stdoutChunks).toString(),
+        stderr: () => String(error?.message ?? error),
+      })
+    })
+  })
+  return {
+    pid: child.pid,
+    stdin: child.stdin,
+    stdout: child.stdout,
+    stderr: child.stderr,
+    killed: false,
+    exitCode: null,
+    kill() {
+      child.kill()
+      this.killed = true
+    },
+    exited: promise,
+  }
+}
+
+export function bunSpawnSync(cmd, options = {}) {
+  const [bin, ...args] = Array.isArray(cmd) ? cmd : [cmd]
+  const result = spawnSync(bin, args, {
+    cwd: options.cwd,
+    env: options.env,
+    input: options.stdin,
+    encoding: 'utf8',
+  })
+  return {
+    exitCode: result.status ?? 1,
+    success: result.status === 0,
+    stdout: result.stdout ?? '',
+    stderr: result.stderr ?? '',
+  }
+}
+
+export function which(bin) {
+  const dirs = (process.env.PATH || '').split(path.delimiter)
+  for (const dir of dirs) {
+    if (!dir)
+      continue
+    const full = path.join(dir, bin)
+    try {
+      fs.accessSync(full, fs.constants.X_OK)
+      return full
+    }
+    catch {}
+  }
+  return null
+}
+
+export function hash(input, algorithm = 'wyhash') {
+  const data = Buffer.isBuffer(input) ? input : Buffer.from(String(input))
+  let h = 5381
+  for (const byte of data)
+    h = ((h * 33) ^ byte) >>> 0
+  return h
+}
+
+export async function sha256(input, encoding = 'hex') {
+  const { createHash } = await import('node:crypto')
+  const data = Buffer.isBuffer(input) ? input : Buffer.from(String(input))
+  return createHash('sha256').update(data).digest(encoding)
+}
+
+export function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms))
+}
+
+export function nanoseconds() {
+  return Number(process.hrtime.bigint())
+}
+
+export function randomUUIDv7() {
+  return webcrypto.randomUUID()
+}
+
+export function stringWidth(str) {
+  return [...String(str)].length
+}
+
+export function deepEquals(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b)
+}
+
+export function fileURLToPath(url) {
+  return new URL(url).pathname
+}
+
+export function pathToFileURL(p) {
+  return new URL(`file://${path.resolve(String(p))}`)
+}
+
+export function resolveSync(mod, from) {
+  const req = createRequire(path.resolve(String(from)))
+  return req.resolve(mod)
+}
+
+// Bun.Glob -> minimal glob over fs
+export class Glob {
+  constructor(pattern) {
+    this.pattern = pattern
+    this._regex = globToRegExp(pattern)
+  }
+
+  match(candidate) {
+    return this._regex.test(candidate)
+  }
+
+  scanSync(opts = {}) {
+    const root = opts.cwd ?? '.'
+    const results = []
+    const walk = (dir) => {
+      let entries
+      try {
+        entries = fs.readdirSync(dir, { withFileTypes: true })
+      }
+      catch {
+        return
+      }
+      for (const entry of entries) {
+        const full = path.join(dir, entry.name)
+        if (entry.isDirectory() && opts.onlyFiles !== true)
+          walk(full)
+        else if (entry.isFile() && this._regex.test(path.relative(root, full)))
+          results.push(path.relative(root, full))
+        if (opts.throwErrorOnOutOfRange && results.length > 1e6)
+          throw new Error('Glob scan out of range')
+      }
+    }
+    walk(root)
+    return results[Symbol.iterator]()
+  }
+
+  async *scan(opts = {}) {
+    yield* this.scanSync(opts)
+  }
+}
+
+function globToRegExp(pattern) {
+  let re = ''
+  for (let i = 0; i < pattern.length; i++) {
+    const ch = pattern[i]
+    if (ch === '*') {
+      if (pattern[i + 1] === '*') {
+        re += '.*'
+        i++
+        if (pattern[i + 1] === '/')
+          i++
+      }
+      else {
+        re += '[^/]*'
+      }
+    }
+    else if (ch === '?') {
+      re += '[^/]'
+    }
+    else if ('\\^$.|+()[]{}'.includes(ch)) {
+      re += `\\${ch}`
+    }
+    else {
+      re += ch
+    }
+  }
+  return new RegExp(`^${re}$`)
+}
+
+// Bun.build has no direct Node.js equivalent (bundler API). Throw an explicit
+// error only if actually invoked at runtime; import-time is unaffected.
+export function build() {
+  throw new Error('Bun.build is not available in Node.js: no equivalent bundler API in bun-shim. Use esbuild/rollup for bundling.')
+}
+
+// Bun.Transpiler -> passthrough shim (Node has no direct TS transpiler builtin)
+export class Transpiler {
+  constructor(_options) {}
+  transformSync(code) {
+    return code
+  }
+  async transform(code) {
+    return code
+  }
+  scan() {
+    return { imports: [], exports: [] }
+  }
+}
+
+// Bun.CryptoHasher — streaming hash class backed by node:crypto createHash.
+// Supports the algorithms used across the stx dist output (md5/sha1/sha256/sha512);
+// Bun-specific algorithms without a Node.js equivalent (blake2b256) map to sha256.
+const CRYPTO_HASHER_ALGORITHMS = {
+  md5: 'md5',
+  sha1: 'sha1',
+  sha256: 'sha256',
+  sha384: 'sha384',
+  sha512: 'sha512',
+  blake2b256: 'sha256',
+}
+
+class CryptoHasher {
+  constructor(algorithm = 'sha256', data) {
+    const algo = CRYPTO_HASHER_ALGORITHMS[String(algorithm).toLowerCase()]
+    if (!algo)
+      throw new Error(`Bun.CryptoHasher: unsupported algorithm "${algorithm}"`)
+    this.algorithm = algorithm
+    this._hash = createHash(algo)
+    if (data !== undefined && data !== null)
+      this.update(data)
+  }
+
+  update(data, encoding = 'utf8') {
+    if (data === null || data === undefined)
+      return this
+    if (typeof data === 'string')
+      this._hash.update(data, encoding)
+    else if (ArrayBuffer.isView(data))
+      this._hash.update(Buffer.from(data.buffer, data.byteOffset, data.byteLength))
+    else
+      this._hash.update(data)
+    return this
+  }
+
+  digest(encoding) {
+    if (encoding === undefined || encoding === null)
+      return this._hash.digest('hex')
+    if (encoding === 'buffer')
+      return this._hash.digest()
+    return this._hash.digest(encoding)
+  }
+
+  copy() {
+    const clone = new CryptoHasher(this.algorithm)
+    clone._hash = this._hash.copy()
+    return clone
+  }
+}
+
+const Bun = {
+  file,
+  write,
+  cp,
+  unlink,
+  serve,
+  spawn: bunSpawn,
+  spawnSync: bunSpawnSync,
+  which,
+  hash,
+  CryptoHasher,
+  sha256,
+  sleep,
+  nanoseconds,
+  randomUUIDv7,
+  stringWidth,
+  deepEquals,
+  fileURLToPath,
+  pathToFileURL,
+  resolveSync,
+  Glob,
+  build,
+  Transpiler,
+  env: process.env,
+  argv: process.argv,
+  version: '1.0.0-node-shim',
+  revision: 'node-shim',
+  cwd: () => process.cwd(),
+  main: process.argv[1],
+  inspect(value) {
+    return JSON.stringify(value, null, 2)
+  },
+  gc(force) {
+    if (force && globalThis.gc)
+      globalThis.gc()
+  },
+  plugin() {},
+}
+
+export { Bun as default, Bun }
+
+// Bun.WebView — native window view (desktop/GUI only). No Node.js equivalent;
+// exists so modules importing it can load. Construction requires a GUI runtime.
+export class WebView {
+  constructor(options = {}) {
+    this.url = options.url ?? ''
+    this.width = options.width ?? 800
+    this.height = options.height ?? 600
+    this.title = options.title ?? ''
+    throw new Error('Bun.WebView requires a GUI window runtime, which is unavailable in Node.js. Screenshot/WebView features cannot run here.')
+  }
+}
+
+// Expose as a global so minified bundles destructuring `globalThis.Bun` work
+if (typeof globalThis !== "undefined" && !globalThis.Bun)
+  globalThis.Bun = Bun

package/dist/bundle-analyzer/collector.d.ts

@@ -0,0 +1,66 @@
+import path from 'node:path';
+/**
+ * Collect bundle statistics from a build directory
+ */
+export declare function collectBundleStats(buildDir: string, options?: CollectorOptions): Promise<BundleStats>;
+/**
+ * Format bytes to human readable string
+ */
+export declare function formatBytes(bytes: number): string;
+/**
+ * Parse size string to bytes
+ */
+export declare function parseSize(size: string): number;
+/**
+ * Calculate percentage
+ */
+export declare function percentage(part: number, total: number): string;
+// ============================================================================
+// Types
+// ============================================================================
+export declare interface ModuleInfo {
+  id: string
+  path: string
+  size: number
+  gzipSize: number
+  parsedSize: number
+  extension: string
+  type: ModuleType
+  imports: string[]
+  importedBy: string[]
+  hash: string
+}
+export declare interface ChunkInfo {
+  name: string
+  files: string[]
+  modules: ModuleInfo[]
+  size: number
+  gzipSize: number
+  isEntry: boolean
+  isVendor: boolean
+}
+export declare interface DuplicateModule {
+  path: string
+  count: number
+  wastedBytes: number
+  locations: string[]
+}
+export declare interface BundleStats {
+  timestamp: number
+  buildDir: string
+  chunks: ChunkInfo[]
+  totalSize: number
+  totalGzipSize: number
+  moduleCount: number
+  duplicates: DuplicateModule[]
+  byType: Record<ModuleType, { count: number; size: number; gzipSize: number }>
+  largestModules: ModuleInfo[]
+  warnings: string[]
+}
+export declare interface CollectorOptions {
+  includeSourceMaps?: boolean
+  parseImports?: boolean
+  detectDuplicates?: boolean
+  topModulesCount?: number
+}
+export type ModuleType = 'js' | 'css' | 'html' | 'image' | 'font' | 'other';