@stacksjs/stx 0.2.95 → 0.2.96

package/dist/builtins/tooltip.js

@@ -1,2 +1,106 @@
-// @bun
-import{az as a}from"../chunk-n9dhs1dw.js";import"../chunk-xv34zbp4.js";export{a as getTooltipRuntime};
+export function getTooltipRuntime() {
+  return `
+(function(){
+var tip=null,hideTimer=null,currentEl=null;
+
+function createTip(){
+  tip=document.createElement("div");
+  tip.id="stx-tooltip";
+  tip.style.cssText="position:absolute;background:#1f2937;color:#fff;font-size:12px;line-height:1.4;padding:6px 10px;border-radius:6px;max-width:250px;z-index:999999;pointer-events:none;opacity:0;transition:opacity .15s ease;white-space:pre-wrap;word-wrap:break-word;box-shadow:0 2px 8px rgba(0,0,0,.25)";
+  var arrow=document.createElement("div");
+  arrow.className="stx-tip-arrow";
+  arrow.style.cssText="position:absolute;width:0;height:0;border:5px solid transparent";
+  tip.appendChild(arrow);
+  var text=document.createElement("span");
+  text.className="stx-tip-text";
+  tip.appendChild(text);
+  document.body.appendChild(tip);
+}
+
+function position(el){
+  var pos=el.getAttribute("x-tooltip-position")||"top";
+  var r=el.getBoundingClientRect();
+  var sy=window.scrollY,sx=window.scrollX;
+  tip.style.display="block";
+  tip.style.opacity="0";
+  // Force layout so we can measure
+  var tw=tip.offsetWidth,th=tip.offsetHeight;
+  var arrow=tip.querySelector(".stx-tip-arrow");
+  var left,top;
+
+  if(pos==="top"){
+    left=r.left+r.width/2-tw/2+sx;
+    top=r.top-th-8+sy;
+    if(top-sy<0){pos="bottom";}
+  }
+  if(pos==="bottom"){
+    left=r.left+r.width/2-tw/2+sx;
+    top=r.bottom+8+sy;
+    arrow.style.cssText="position:absolute;width:0;height:0;border:5px solid transparent;border-bottom-color:#1f2937;top:-10px;left:50%;transform:translateX(-50%)";
+  }
+  if(pos==="left"){
+    left=r.left-tw-8+sx;
+    top=r.top+r.height/2-th/2+sy;
+    if(left-sx<0){pos="right";}
+  }
+  if(pos==="right"){
+    left=r.right+8+sx;
+    top=r.top+r.height/2-th/2+sy;
+    arrow.style.cssText="position:absolute;width:0;height:0;border:5px solid transparent;border-right-color:#1f2937;left:-10px;top:50%;transform:translateY(-50%)";
+  }
+
+  // Set arrow for top/left after potential flips
+  if(pos==="top"){
+    arrow.style.cssText="position:absolute;width:0;height:0;border:5px solid transparent;border-top-color:#1f2937;bottom:-10px;left:50%;transform:translateX(-50%)";
+  }
+  if(pos==="left"){
+    arrow.style.cssText="position:absolute;width:0;height:0;border:5px solid transparent;border-left-color:#1f2937;right:-10px;top:50%;transform:translateY(-50%)";
+  }
+
+  // Clamp horizontal
+  if(left<sx+4) left=sx+4;
+  if(left+tw>sx+window.innerWidth-4) left=sx+window.innerWidth-tw-4;
+
+  tip.style.left=left+"px";
+  tip.style.top=top+"px";
+  tip.style.opacity="1";
+}
+
+function showTip(el){
+  if(hideTimer){clearTimeout(hideTimer);hideTimer=null;}
+  if(!tip) createTip();
+  var text=el.getAttribute("x-tooltip");
+  if(!text) return;
+  tip.querySelector(".stx-tip-text").textContent=text;
+  currentEl=el;
+  position(el);
+}
+
+function hideTip(){
+  if(!tip) return;
+  tip.style.opacity="0";
+  hideTimer=setTimeout(function(){
+    if(tip) tip.style.display="none";
+    currentEl=null;
+  },150);
+}
+
+document.addEventListener("mouseover",function(e){
+  var el=e.target.closest("[x-tooltip]");
+  if(el) showTip(el);
+});
+document.addEventListener("mouseout",function(e){
+  var el=e.target.closest("[x-tooltip]");
+  if(el&&el===currentEl) hideTip();
+});
+document.addEventListener("focusin",function(e){
+  var el=e.target.closest("[x-tooltip]");
+  if(el) showTip(el);
+});
+document.addEventListener("focusout",function(e){
+  var el=e.target.closest("[x-tooltip]");
+  if(el) hideTip();
+});
+})();
+`;
+}

package/dist/builtins/transition-group.js

@@ -1,2 +1,22 @@
-// @bun
-import{bz as a}from"../chunk-rwrv9wbf.js";import"../chunk-xv34zbp4.js";export{a as TransitionGroupBuiltin};
+function resolveProp(props, ...keys) {
+  for (const key of keys) {
+    if (props.serverDynamic[key] !== void 0)
+      return String(props.serverDynamic[key]);
+    const val = props.static[key];
+    if (typeof val === "string")
+      return val;
+  }
+  return;
+}
+export const TransitionGroupBuiltin = {
+  name: "TransitionGroup",
+  aliases: ["transition-group"],
+  render(props, slotContent, _ctx) {
+    const name = (resolveProp(props, "name") || "v").replace(/["'<>]/g, ""), tag = (resolveProp(props, "tag") || "div").replace(/[^a-z0-9-]/gi, "") || "div", cls = resolveProp(props, "class"), id = resolveProp(props, "id"), attrs = [
+      `data-stx-transition-group="${name}"`,
+      cls ? `class="${cls}"` : "",
+      id ? `id="${id}"` : ""
+    ].filter(Boolean).join(" ");
+    return `<${tag} ${attrs}>${slotContent}</${tag}>`;
+  }
+};

package/dist/bundle-analyzer/collector.js

@@ -1,2 +1,233 @@
-// @bun
-import{Cp as a,Dp as b,Ep as c,Fp as d}from"../chunk-55nwdnsd.js";import"../chunk-xv34zbp4.js";export{d as percentage,c as parseSize,b as formatBytes,a as collectBundleStats};
+import fs from "node:fs";
+import path from "node:path";
+import { gzipSync } from "node:zlib";
+import { createHash } from "node:crypto";
+const FILE_TYPE_MAP = {
+  ".js": "js",
+  ".mjs": "js",
+  ".cjs": "js",
+  ".ts": "js",
+  ".jsx": "js",
+  ".tsx": "js",
+  ".css": "css",
+  ".scss": "css",
+  ".sass": "css",
+  ".less": "css",
+  ".html": "html",
+  ".htm": "html",
+  ".png": "image",
+  ".jpg": "image",
+  ".jpeg": "image",
+  ".gif": "image",
+  ".svg": "image",
+  ".webp": "image",
+  ".avif": "image",
+  ".ico": "image",
+  ".woff": "font",
+  ".woff2": "font",
+  ".ttf": "font",
+  ".eot": "font",
+  ".otf": "font"
+}, VENDOR_PATTERNS = [
+  /node_modules/,
+  /vendor/,
+  /bower_components/,
+  /\.min\./
+], ENTRY_PATTERNS = [
+  /index\.(js|ts|html)$/,
+  /main\.(js|ts)$/,
+  /app\.(js|ts)$/,
+  /entry\.(js|ts)$/
+];
+export async function collectBundleStats(buildDir, options = {}) {
+  const {
+    includeSourceMaps = !1,
+    parseImports = !0,
+    detectDuplicates = !0,
+    topModulesCount = 20
+  } = options;
+  if (!fs.existsSync(buildDir))
+    throw Error(`Build directory not found: ${buildDir}`);
+  if (!fs.statSync(buildDir).isDirectory())
+    throw Error(`Not a directory: ${buildDir}`);
+  const files = await collectFiles(buildDir, includeSourceMaps), modules = [], warnings = [];
+  for (const filePath of files)
+    try {
+      const module = await processFile(filePath, buildDir, parseImports);
+      modules.push(module);
+    } catch (error) {
+      warnings.push(`Failed to process ${filePath}: ${error}`);
+    }
+  const chunks = groupIntoChunks(modules, buildDir), totalSize = modules.reduce((sum, m) => sum + m.size, 0), totalGzipSize = modules.reduce((sum, m) => sum + m.gzipSize, 0), byType = groupByType(modules), duplicates = detectDuplicates ? findDuplicates(modules) : [], largestModules = [...modules].sort((a, b) => b.size - a.size).slice(0, topModulesCount);
+  return {
+    timestamp: Date.now(),
+    buildDir: path.resolve(buildDir),
+    chunks,
+    totalSize,
+    totalGzipSize,
+    moduleCount: modules.length,
+    duplicates,
+    byType,
+    largestModules,
+    warnings
+  };
+}
+async function collectFiles(dir, includeSourceMaps) {
+  const files = [];
+  async function walk(currentDir) {
+    const entries = await fs.promises.readdir(currentDir, { withFileTypes: !0 });
+    for (const entry of entries) {
+      const fullPath = path.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        if (!entry.name.startsWith(".") && entry.name !== "node_modules")
+          await walk(fullPath);
+      } else if (entry.isFile()) {
+        if (!includeSourceMaps && entry.name.endsWith(".map"))
+          continue;
+        files.push(fullPath);
+      }
+    }
+  }
+  await walk(dir);
+  return files;
+}
+async function processFile(filePath, buildDir, parseImports) {
+  const content = await fs.promises.readFile(filePath), relativePath = path.relative(buildDir, filePath), ext = path.extname(filePath).toLowerCase(), size = content.length, gzipSize = calculateGzipSize(content), parsedSize = estimateParsedSize(content, ext), hash = createHash("md5").update(content).digest("hex").slice(0, 8), type = FILE_TYPE_MAP[ext] || "other", imports = [];
+  if (parseImports && type === "js")
+    imports.push(...parseJsImports(content.toString("utf-8")));
+  return {
+    id: relativePath,
+    path: relativePath,
+    size,
+    gzipSize,
+    parsedSize,
+    extension: ext,
+    type,
+    imports,
+    importedBy: [],
+    hash
+  };
+}
+function calculateGzipSize(content) {
+  try {
+    const gzipLength = gzipSync(content, { level: 9 }).length;
+    return Math.min(gzipLength, content.length);
+  } catch {
+    return content.length;
+  }
+}
+function estimateParsedSize(content, ext) {
+  if (ext.includes(".min.") || content.length < 1000)
+    return content.length;
+  const type = FILE_TYPE_MAP[ext];
+  if (type === "js")
+    return Math.round(content.length * 0.6);
+  if (type === "css")
+    return Math.round(content.length * 0.7);
+  return content.length;
+}
+function parseJsImports(content) {
+  const imports = [], esImportRegex = /import\s+(?:[\w*{}\s,]+\s+from\s+)?['"]([^'"]+)['"]/g;
+  let match;
+  while ((match = esImportRegex.exec(content)) !== null)
+    imports.push(match[1]);
+  const dynamicImportRegex = /import\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+  while ((match = dynamicImportRegex.exec(content)) !== null)
+    imports.push(match[1]);
+  const requireRegex = /require\s*\(\s*['"]([^'"]+)['"]\s*\)/g;
+  while ((match = requireRegex.exec(content)) !== null)
+    imports.push(match[1]);
+  return [...new Set(imports)];
+}
+function groupIntoChunks(modules, buildDir) {
+  const chunkMap = new Map;
+  for (const module of modules) {
+    const parts = module.path.split(path.sep);
+    let chunkName;
+    if (parts.length === 1)
+      chunkName = path.basename(module.path, module.extension);
+    else
+      chunkName = parts[0];
+    const existing = chunkMap.get(chunkName) || [];
+    existing.push(module);
+    chunkMap.set(chunkName, existing);
+  }
+  const chunks = [];
+  for (const [name, chunkModules] of chunkMap) {
+    const size = chunkModules.reduce((sum, m) => sum + m.size, 0), gzipSize = chunkModules.reduce((sum, m) => sum + m.gzipSize, 0), isEntry = chunkModules.some((m) => ENTRY_PATTERNS.some((p) => p.test(m.path))), isVendor = chunkModules.some((m) => VENDOR_PATTERNS.some((p) => p.test(m.path)));
+    chunks.push({
+      name,
+      files: chunkModules.map((m) => m.path),
+      modules: chunkModules,
+      size,
+      gzipSize,
+      isEntry,
+      isVendor
+    });
+  }
+  return chunks.sort((a, b) => b.size - a.size);
+}
+function groupByType(modules) {
+  const byType = {
+    js: { count: 0, size: 0, gzipSize: 0 },
+    css: { count: 0, size: 0, gzipSize: 0 },
+    html: { count: 0, size: 0, gzipSize: 0 },
+    image: { count: 0, size: 0, gzipSize: 0 },
+    font: { count: 0, size: 0, gzipSize: 0 },
+    other: { count: 0, size: 0, gzipSize: 0 }
+  };
+  for (const module of modules) {
+    byType[module.type].count++;
+    byType[module.type].size += module.size;
+    byType[module.type].gzipSize += module.gzipSize;
+  }
+  return byType;
+}
+function findDuplicates(modules) {
+  const hashMap = new Map;
+  for (const module of modules) {
+    const existing = hashMap.get(module.hash) || [];
+    existing.push(module);
+    hashMap.set(module.hash, existing);
+  }
+  const duplicates = [];
+  for (const [, sameHash] of hashMap)
+    if (sameHash.length > 1) {
+      const first = sameHash[0];
+      duplicates.push({
+        path: first.path,
+        count: sameHash.length,
+        wastedBytes: first.size * (sameHash.length - 1),
+        locations: sameHash.map((m) => m.path)
+      });
+    }
+  return duplicates.sort((a, b) => b.wastedBytes - a.wastedBytes);
+}
+export function formatBytes(bytes) {
+  if (bytes < 1024)
+    return `${bytes} B`;
+  if (bytes < 1048576)
+    return `${(bytes / 1024).toFixed(2)} KB`;
+  return `${(bytes / 1048576).toFixed(2)} MB`;
+}
+export function parseSize(size) {
+  const match = size.match(/^([\d.]+)\s*(B|KB|MB|GB)?$/i);
+  if (!match)
+    return 0;
+  const value = Number.parseFloat(match[1]);
+  switch ((match[2] || "B").toUpperCase()) {
+    case "KB":
+      return value * 1024;
+    case "MB":
+      return value * 1024 * 1024;
+    case "GB":
+      return value * 1024 * 1024 * 1024;
+    default:
+      return value;
+  }
+}
+export function percentage(part, total) {
+  if (total === 0)
+    return "0%";
+  return `${(part / total * 100).toFixed(1)}%`;
+}

package/dist/bundle-analyzer/index.js

@@ -1,2 +1,82 @@
-// @bun
-import{xp as N,yp as w,zp as O}from"../chunk-x5g9w4hh.js";import{Ap as Q,Bp as U}from"../chunk-p52yzjq6.js";import{Cp as F,Dp as E,Ep as L,Fp as v}from"../chunk-55nwdnsd.js";import"../chunk-xv34zbp4.js";import Z from"fs";import K from"path";async function g(G={}){let{directory:j="dist",output:H,format:V="html",open:_=!0,gzip:W=!0,threshold:C,recommendations:$=!0,topModules:X=20,parseImports:b=!0}=G,D=await F(j,{parseImports:b,detectDuplicates:!0,topModulesCount:X}),J=C?typeof C==="string"?L(C):C:void 0,k=J?D.totalSize>J:!1,A,q;if(V==="html"){let Y={title:`Bundle Analysis - ${K.basename(K.resolve(j))}`,gzip:W};if(A=Q(D,Y),q=H||K.join(j,"bundle-report.html"),await Z.promises.writeFile(q,A),_)U(q)}else if(A=N(D,{format:V,threshold:J,recommendations:$,topModules:X,showGzip:W}),H)q=H,await Z.promises.writeFile(q,A);return{stats:D,report:A,outputPath:q,exceedsThreshold:k}}async function P(G){let j=await F(G,{parseImports:!1,detectDuplicates:!1,topModulesCount:0});return{totalSize:j.totalSize,totalSizeFormatted:E(j.totalSize),gzipSize:j.totalGzipSize,gzipSizeFormatted:E(j.totalGzipSize),moduleCount:j.moduleCount,chunkCount:j.chunks.length}}export{v as percentage,L as parseSize,U as openInBrowser,O as getModuleRecommendation,P as getBundleSummary,Q as generateTreemap,N as generateReport,E as formatBytes,F as collectBundleStats,w as analyzeBundle,g as analyze};
+export {
+  collectBundleStats,
+  formatBytes,
+  parseSize,
+  percentage
+} from "./collector.js";
+export {
+  generateReport,
+  analyzeBundle,
+  getModuleRecommendation
+} from "./report.js";
+export {
+  generateTreemap,
+  openInBrowser
+} from "./treemap.js";
+import fs from "node:fs";
+import path from "node:path";
+import { collectBundleStats, formatBytes, parseSize } from "./collector.js";
+import { generateReport, analyzeBundle } from "./report.js";
+import { generateTreemap, openInBrowser } from "./treemap.js";
+export async function analyze(options = {}) {
+  const {
+    directory = "dist",
+    output,
+    format = "html",
+    open = !0,
+    gzip = !0,
+    threshold,
+    recommendations = !0,
+    topModules = 20,
+    parseImports = !0
+  } = options, stats = await collectBundleStats(directory, {
+    parseImports,
+    detectDuplicates: !0,
+    topModulesCount: topModules
+  }), thresholdBytes = threshold ? typeof threshold === "string" ? parseSize(threshold) : threshold : void 0, exceedsThreshold = thresholdBytes ? stats.totalSize > thresholdBytes : !1;
+  let report, outputPath;
+  if (format === "html") {
+    const treemapOptions = {
+      title: `Bundle Analysis - ${path.basename(path.resolve(directory))}`,
+      gzip
+    };
+    report = generateTreemap(stats, treemapOptions);
+    outputPath = output || path.join(directory, "bundle-report.html");
+    await fs.promises.writeFile(outputPath, report);
+    if (open)
+      openInBrowser(outputPath);
+  } else {
+    report = generateReport(stats, {
+      format,
+      threshold: thresholdBytes,
+      recommendations,
+      topModules,
+      showGzip: gzip
+    });
+    if (output) {
+      outputPath = output;
+      await fs.promises.writeFile(outputPath, report);
+    }
+  }
+  return {
+    stats,
+    report,
+    outputPath,
+    exceedsThreshold
+  };
+}
+export async function getBundleSummary(directory) {
+  const stats = await collectBundleStats(directory, {
+    parseImports: !1,
+    detectDuplicates: !1,
+    topModulesCount: 0
+  });
+  return {
+    totalSize: stats.totalSize,
+    totalSizeFormatted: formatBytes(stats.totalSize),
+    gzipSize: stats.totalGzipSize,
+    gzipSizeFormatted: formatBytes(stats.totalGzipSize),
+    moduleCount: stats.moduleCount,
+    chunkCount: stats.chunks.length
+  };
+}