@stacksjs/stx 0.2.95 → 0.2.97

package/dist/production-builder.js

@@ -1,2 +1,132 @@
-// @bun
-import{Ei as a}from"./chunk-8dhdpa5h.js";import"./chunk-kdfe4t91.js";import"./chunk-t0c9wvpr.js";import"./chunk-80g54ncj.js";import"./chunk-rvptcndz.js";import"./chunk-15nesxgt.js";import"./chunk-q6zhd9yf.js";import"./chunk-d0zjtdw4.js";import"./chunk-mhgk632d.js";import"./chunk-1xz0w746.js";import"./chunk-m8448qby.js";import"./chunk-kx6eb6ma.js";import"./chunk-g1vt329s.js";import"./chunk-7074g241.js";import"./chunk-9cf97f9p.js";import"./chunk-6djzdes9.js";import"./chunk-v7f8jj15.js";import"./chunk-keawsbpn.js";import"./chunk-8b3z0zd5.js";import"./chunk-hbgxbgam.js";import"./chunk-ejh8fyak.js";import"./chunk-krqn0ddk.js";import"./chunk-y1k17c8b.js";import"./chunk-2j21d3ka.js";import"./chunk-frg705zq.js";import"./chunk-hjm2xab3.js";import"./chunk-07y6m5xx.js";import"./chunk-wazkqv7n.js";import"./chunk-x05nxhyv.js";import"./chunk-31dr4bys.js";import"./chunk-mgj88zeq.js";import"./chunk-m167kjhv.js";import"./chunk-3a4qsygv.js";import"./chunk-dqn9gyhb.js";import"./chunk-988dw6q3.js";import"./chunk-8qc1bsym.js";import"./chunk-xyg1r5w0.js";import"./chunk-7gd339hd.js";import"./chunk-4deg33rw.js";import"./chunk-pa9zb7ty.js";import"./chunk-a2g2qb2y.js";import"./chunk-h5jxydqq.js";import"./chunk-nhv099jv.js";import"./chunk-shv88d2d.js";import"./chunk-0dx4q6yq.js";import"./chunk-ek2w6zvy.js";import"./chunk-9wmq2272.js";import"./chunk-7dkz6z2s.js";import"./chunk-9ecv8aqj.js";import"./chunk-bdk6g1vj.js";import"./chunk-xqq1vxb6.js";import"./chunk-amaa1bev.js";import"./chunk-r5m9xtm7.js";import"./chunk-bs3gmfxz.js";import"./chunk-1zgsgk4b.js";import"./chunk-2jxbwnkz.js";import"./chunk-zen6ax1y.js";import"./chunk-yb1t2h8h.js";import"./chunk-fjk3x41y.js";import"./chunk-5shey2e4.js";import"./chunk-27zsyhrd.js";import"./chunk-7ed3tean.js";import"./chunk-8vtm0m84.js";import"./chunk-tzwtg722.js";import"./chunk-ah88wzbg.js";import"./chunk-v8j49spx.js";import"./chunk-tg2f1mzq.js";import"./chunk-n9dhs1dw.js";import"./chunk-rwrv9wbf.js";import"./chunk-wg9k6h8w.js";import"./chunk-9jtj77jx.js";import"./chunk-qygvvygy.js";import"./chunk-gz5fmp3q.js";import"./chunk-vjbefncc.js";import"./chunk-8xj7c3mf.js";import"./chunk-qvrbjpdc.js";import"./chunk-w3b6m427.js";import"./chunk-rz2ec6g7.js";import"./chunk-35faj94w.js";import"./chunk-djddhmcc.js";import"./chunk-knm8a8yx.js";import"./chunk-xv34zbp4.js";export{a as buildForProduction};
+import fs from "node:fs";
+import path from "node:path";
+import { createRouter } from "./router.js";
+import { buildRuntimeAsset, buildRouterAsset } from "./build-assets.js";
+import { compileTemplate } from "./template-compiler.js";
+import { generateManifest, writeManifest } from "./manifest.js";
+import { ensureDocumentShell } from "./document-shell.js";
+import { extractContainerContent } from "./app-shell.js";
+import { injectCrosswindCSS } from "./dev-server/crosswind.js";
+import { loadStxConfig } from "./config.js";
+const PUBLIC_ASSET_BLOCKLIST = new Set([
+  ".DS_Store",
+  "Thumbs.db",
+  "desktop.ini",
+  ".gitkeep",
+  ".gitignore"
+]);
+function copyPublicAssets(srcDir, destDir) {
+  let copied = 0, bytes = 0;
+  if (!fs.existsSync(srcDir))
+    return { copied, bytes };
+  function walk(currentSrc, currentDest) {
+    const entries = fs.readdirSync(currentSrc, { withFileTypes: !0 });
+    for (const entry of entries) {
+      if (PUBLIC_ASSET_BLOCKLIST.has(entry.name))
+        continue;
+      const srcPath = path.join(currentSrc, entry.name), destPath = path.join(currentDest, entry.name);
+      if (entry.isDirectory()) {
+        fs.mkdirSync(destPath, { recursive: !0 });
+        walk(srcPath, destPath);
+      } else if (entry.isFile()) {
+        if (fs.existsSync(destPath))
+          continue;
+        fs.copyFileSync(srcPath, destPath);
+        copied++;
+        bytes += fs.statSync(destPath).size;
+      }
+    }
+  }
+  walk(srcDir, destDir);
+  return { copied, bytes };
+}
+export async function buildForProduction(options = {}) {
+  const startTime = Date.now(), root = path.resolve(options.root || process.cwd()), outputDir = path.resolve(root, options.outputDir || ".output");
+  console.log("[stx build] Starting production build...");
+  let projectConfig = {};
+  try {
+    projectConfig = await loadStxConfig();
+  } catch {}
+  const componentsDir = options.componentsDir ?? projectConfig.componentsDir ?? "components", partialsDir = options.partialsDir ?? projectConfig.partialsDir ?? "partials", layoutsDir = options.layoutsDir ?? projectConfig.layoutsDir ?? "layouts", publicDir = options.publicDir ?? projectConfig.publicDir ?? "public", headConfigDefault = projectConfig.app?.head || {}, routerContainer = projectConfig.router?.container || "main";
+  if (fs.existsSync(outputDir))
+    fs.rmSync(outputDir, { recursive: !0 });
+  const dirs = [
+    path.join(outputDir, "public", "__stx"),
+    path.join(outputDir, "public", "assets"),
+    path.join(outputDir, "server", "pages"),
+    path.join(outputDir, "server", "fragments")
+  ];
+  for (const dir of dirs)
+    fs.mkdirSync(dir, { recursive: !0 });
+  console.log("[stx build] Discovering routes...");
+  const allRoutes = createRouter(root), excludeDirs = ["components", "layouts", "partials"], routes = allRoutes.filter((r) => {
+    return !excludeDirs.some((dir) => r.pattern.startsWith(`/${dir}/`) || r.pattern === `/${dir}`);
+  });
+  console.log(`[stx build] Found ${routes.length} page routes (${allRoutes.length - routes.length} non-page files excluded)`);
+  console.log("[stx build] Generating shared assets...");
+  const runtimeAsset = buildRuntimeAsset(options.debug), routerAsset = buildRouterAsset();
+  await Bun.write(path.join(outputDir, "public", "__stx", runtimeAsset.filename), runtimeAsset.content);
+  await Bun.write(path.join(outputDir, "public", "__stx", routerAsset.filename), routerAsset.content);
+  console.log(`[stx build] Runtime: ${runtimeAsset.filename} (${(runtimeAsset.content.length / 1024).toFixed(1)}KB)`);
+  console.log(`[stx build] Router: ${routerAsset.filename} (${(routerAsset.content.length / 1024).toFixed(1)}KB)`);
+  console.log("[stx build] Compiling templates...");
+  const compiledPages = [], manifestRoutes = [];
+  for (const route of routes)
+    try {
+      const compiled = await compileTemplate(route.filePath, route.pattern, {
+        componentsDir,
+        partialsDir,
+        layoutsDir,
+        debug: options.debug
+      });
+      compiledPages.push(compiled);
+      compiled.html = compiled.html.replace(/runtime\.__STX_HASH__\.js/g, runtimeAsset.filename).replace(/router\.__STX_HASH__\.js/g, routerAsset.filename);
+      compiled.html = ensureDocumentShell(compiled.html, headConfigDefault, {
+        bodyScripts: [`<script src="/__stx/${routerAsset.filename}"></script>`]
+      });
+      if (!/<body[^>]*\bdata-stx=/.test(compiled.html)) {
+        const dataStxMatch = compiled.html.match(/<(?!body\b)[a-zA-Z][a-zA-Z0-9-]*\b[^>]*?\s(data-stx="[^"]+")[^>]*>/);
+        if (dataStxMatch && dataStxMatch[1]) {
+          const dataStxAttr = dataStxMatch[1];
+          compiled.html = compiled.html.replace(" " + dataStxAttr, "");
+          compiled.html = compiled.html.replace(/<body([^>]*)>/, `<body$1 ${dataStxAttr}>`);
+        }
+      }
+      compiled.html = compiled.html.replace(/<style data-crosswind="generated">[\s\S]*?<\/style>\s*/g, "");
+      compiled.html = await injectCrosswindCSS(compiled.html);
+      compiled.fragment = extractContainerContent(compiled.html, routerContainer);
+      const safeRouteName = route.pattern === "/" ? "index" : route.pattern.slice(1).replace(/\//g, "-").replace(/[[\]]/g, "_"), compiledPath = path.join("server", "pages", `${safeRouteName}.compiled.json`), fragmentPath = path.join("server", "fragments", `${safeRouteName}.html`);
+      await Bun.write(path.join(outputDir, compiledPath), JSON.stringify(compiled, null, 2));
+      await Bun.write(path.join(outputDir, fragmentPath), compiled.fragment);
+      manifestRoutes.push({
+        pattern: route.pattern,
+        compiledPath,
+        fragmentPath,
+        isDynamic: compiled.hasServerScripts,
+        hasParams: route.pattern.includes(":") || route.pattern.includes("[")
+      });
+      console.log(`[stx build]   \u2713 ${route.pattern}`);
+    } catch (error) {
+      console.error(`[stx build]   \u2717 ${route.pattern}:`, error instanceof Error ? error.message : error);
+    }
+  const userPublicSrc = path.resolve(root, publicDir);
+  if (fs.existsSync(userPublicSrc)) {
+    const { copied, bytes } = copyPublicAssets(userPublicSrc, path.join(outputDir, "public"));
+    if (copied > 0)
+      console.log(`[stx build] Copied ${copied} public asset${copied === 1 ? "" : "s"} (${(bytes / 1024).toFixed(1)}KB) from ${publicDir}/`);
+  }
+  const assets = {
+    runtime: runtimeAsset.filename,
+    router: routerAsset.filename
+  }, manifest = generateManifest(manifestRoutes, assets, outputDir);
+  writeManifest(manifest, outputDir);
+  const duration = Date.now() - startTime;
+  console.log(`
+[stx build] Done in ${duration}ms \u2014 ${compiledPages.length} pages compiled`);
+  return {
+    pageCount: compiledPages.length,
+    assets,
+    outputDir,
+    duration
+  };
+}

package/dist/production-server.js

@@ -1,2 +1,188 @@
-// @bun
-import{Ni as a}from"./chunk-rpx5fa65.js";import"./chunk-d1qh1x2g.js";import"./chunk-80g54ncj.js";import"./chunk-d0zjtdw4.js";import"./chunk-mhgk632d.js";import"./chunk-1xz0w746.js";import"./chunk-m8448qby.js";import"./chunk-kx6eb6ma.js";import"./chunk-g1vt329s.js";import"./chunk-7074g241.js";import"./chunk-9cf97f9p.js";import"./chunk-6djzdes9.js";import"./chunk-v7f8jj15.js";import"./chunk-keawsbpn.js";import"./chunk-8b3z0zd5.js";import"./chunk-hbgxbgam.js";import"./chunk-ejh8fyak.js";import"./chunk-krqn0ddk.js";import"./chunk-y1k17c8b.js";import"./chunk-2j21d3ka.js";import"./chunk-frg705zq.js";import"./chunk-hjm2xab3.js";import"./chunk-07y6m5xx.js";import"./chunk-wazkqv7n.js";import"./chunk-x05nxhyv.js";import"./chunk-31dr4bys.js";import"./chunk-mgj88zeq.js";import"./chunk-m167kjhv.js";import"./chunk-3a4qsygv.js";import"./chunk-dqn9gyhb.js";import"./chunk-988dw6q3.js";import"./chunk-8qc1bsym.js";import"./chunk-xyg1r5w0.js";import"./chunk-7gd339hd.js";import"./chunk-4deg33rw.js";import"./chunk-pa9zb7ty.js";import"./chunk-a2g2qb2y.js";import"./chunk-h5jxydqq.js";import"./chunk-nhv099jv.js";import"./chunk-shv88d2d.js";import"./chunk-0dx4q6yq.js";import"./chunk-ek2w6zvy.js";import"./chunk-9wmq2272.js";import"./chunk-7dkz6z2s.js";import"./chunk-9ecv8aqj.js";import"./chunk-bdk6g1vj.js";import"./chunk-xqq1vxb6.js";import"./chunk-amaa1bev.js";import"./chunk-r5m9xtm7.js";import"./chunk-bs3gmfxz.js";import"./chunk-1zgsgk4b.js";import"./chunk-2jxbwnkz.js";import"./chunk-zen6ax1y.js";import"./chunk-yb1t2h8h.js";import"./chunk-fjk3x41y.js";import"./chunk-5shey2e4.js";import"./chunk-27zsyhrd.js";import"./chunk-7ed3tean.js";import"./chunk-8vtm0m84.js";import"./chunk-tzwtg722.js";import"./chunk-ah88wzbg.js";import"./chunk-v8j49spx.js";import"./chunk-tg2f1mzq.js";import"./chunk-n9dhs1dw.js";import"./chunk-rwrv9wbf.js";import"./chunk-wg9k6h8w.js";import"./chunk-9jtj77jx.js";import"./chunk-qygvvygy.js";import"./chunk-gz5fmp3q.js";import"./chunk-vjbefncc.js";import"./chunk-8xj7c3mf.js";import"./chunk-qvrbjpdc.js";import"./chunk-w3b6m427.js";import"./chunk-rz2ec6g7.js";import"./chunk-35faj94w.js";import"./chunk-djddhmcc.js";import"./chunk-knm8a8yx.js";import"./chunk-xv34zbp4.js";export{a as startProductionServer};
+import fs from "node:fs";
+import path from "node:path";
+import { serve } from "bun";
+import { loadManifest } from "./manifest.js";
+import { hydrateTemplateStream, hydrateFragment } from "./template-hydrator.js";
+import { extractLayoutMetadata } from "./app-shell.js";
+const MIME_TYPES = {
+  ".js": "application/javascript",
+  ".mjs": "application/javascript",
+  ".css": "text/css",
+  ".json": "application/json",
+  ".html": "text/html",
+  ".txt": "text/plain",
+  ".xml": "application/xml",
+  ".pdf": "application/pdf",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".avif": "image/avif",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  ".bmp": "image/bmp",
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".ogg": "audio/ogg",
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  ".ttf": "font/ttf",
+  ".otf": "font/otf",
+  ".eot": "application/vnd.ms-fontobject"
+};
+export async function startProductionServer(options = {}) {
+  const outputDir = path.resolve(options.outputDir || ".output"), port = options.port || 3000, manifest = loadManifest(outputDir);
+  if (!manifest) {
+    console.error("[stx] No build manifest found. Run `stx build` first.");
+    process.exit(1);
+  }
+  console.log(`[stx] Production server loading ${manifest.routes.length} routes...`);
+  const compiledTemplates = new Map, fragmentCache = new Map, layoutMetadataCache = new Map;
+  for (const route of manifest.routes)
+    try {
+      const compiledPath = path.join(outputDir, route.compiledPath), compiled = JSON.parse(await Bun.file(compiledPath).text());
+      compiledTemplates.set(route.pattern, compiled);
+      layoutMetadataCache.set(route.pattern, extractLayoutMetadata(compiled.html));
+      const fragmentPath = path.join(outputDir, route.fragmentPath);
+      if (await Bun.file(fragmentPath).exists())
+        fragmentCache.set(route.pattern, await Bun.file(fragmentPath).text());
+    } catch (error) {
+      console.warn(`[stx] Failed to load route ${route.pattern}:`, error);
+    }
+  const exactRoutes = new Map, paramRoutes = [];
+  for (const route of manifest.routes)
+    if (route.hasParams) {
+      const paramNames = [], regexStr = route.pattern.replace(/:([^/]+)/g, (_, name) => {
+        paramNames.push(name);
+        return "([^/]+)";
+      });
+      paramRoutes.push({ regex: new RegExp(`^${regexStr}$`), route, paramNames });
+    } else
+      exactRoutes.set(route.pattern, route);
+  const server = serve({
+    port,
+    async fetch(request) {
+      const pathname = new URL(request.url).pathname;
+      if (options.onRequest) {
+        const response = await options.onRequest(request);
+        if (response)
+          return response;
+      }
+      if (options.apiRoutes?.[pathname])
+        return options.apiRoutes[pathname](request);
+      if ((request.method === "GET" || request.method === "HEAD") && pathname !== "/") {
+        const publicRoot = path.resolve(outputDir, "public");
+        let safePathname;
+        try {
+          safePathname = decodeURIComponent(pathname);
+        } catch {
+          safePathname = pathname;
+        }
+        if (!safePathname.includes("\x00")) {
+          const resolvedPath = path.resolve(publicRoot, `.${safePathname}`);
+          if (resolvedPath === publicRoot || resolvedPath.startsWith(`${publicRoot}${path.sep}`))
+            try {
+              if (fs.existsSync(resolvedPath) && fs.statSync(resolvedPath).isFile()) {
+                const ext = path.extname(resolvedPath).toLowerCase(), contentType = MIME_TYPES[ext] || "application/octet-stream", isFingerprinted = pathname.startsWith("/__stx/") || /\.[0-9a-f]{8}\./.test(pathname);
+                return new Response(Bun.file(resolvedPath), {
+                  headers: {
+                    "Content-Type": contentType,
+                    "Cache-Control": isFingerprinted ? "public, max-age=31536000, immutable" : "public, max-age=3600"
+                  }
+                });
+              }
+            } catch {}
+        }
+      }
+      const isSpaNav = request.headers.get("X-STX-Router") === "true";
+      let matchedRoute = null, params = {};
+      matchedRoute = exactRoutes.get(pathname) || null;
+      if (!matchedRoute)
+        for (const { regex, route, paramNames } of paramRoutes) {
+          const match = pathname.match(regex);
+          if (match) {
+            matchedRoute = route;
+            paramNames.forEach((name, i) => {
+              params[name] = match[i + 1];
+            });
+            break;
+          }
+        }
+      if (!matchedRoute) {
+        const errorPage = exactRoutes.get("/404") || null;
+        if (errorPage) {
+          const compiled = compiledTemplates.get(errorPage.pattern);
+          if (compiled)
+            return new Response(compiled.html, {
+              status: 404,
+              headers: { "Content-Type": "text/html" }
+            });
+        }
+        return new Response("Not Found", { status: 404 });
+      }
+      if (isSpaNav) {
+        const fragment = fragmentCache.get(matchedRoute.pattern);
+        if (fragment) {
+          const layoutMetadata = layoutMetadataCache.get(matchedRoute.pattern);
+          return new Response(fragment, {
+            headers: {
+              "Content-Type": "text/html",
+              "X-STX-Fragment": "true",
+              ...layoutMetadata ? {
+                "X-STX-Layout": layoutMetadata.layout,
+                "X-STX-Layout-Group": layoutMetadata.group
+              } : {},
+              "Cache-Control": "no-cache"
+            }
+          });
+        }
+      }
+      const compiled = compiledTemplates.get(matchedRoute.pattern);
+      if (!compiled) {
+        const errorPage = exactRoutes.get("/500") || null;
+        if (errorPage) {
+          const compiledError = compiledTemplates.get(errorPage.pattern);
+          if (compiledError)
+            return new Response(compiledError.html, {
+              status: 500,
+              headers: { "Content-Type": "text/html" }
+            });
+        }
+        return new Response("Internal Server Error", { status: 500 });
+      }
+      if (!compiled.hasServerScripts && Object.keys(compiled.placeholders).length === 0)
+        return new Response(compiled.html, {
+          headers: {
+            "Content-Type": "text/html",
+            "Cache-Control": "public, max-age=60"
+          }
+        });
+      try {
+        const { html, boundaries } = await hydrateTemplateStream(compiled, { params, request });
+        if (boundaries && boundaries.length > 0) {
+          const { renderStreamingPage, streamToResponse } = await import("./streaming.js");
+          return streamToResponse(renderStreamingPage(html, boundaries, { timeoutMs: 30000 }), {
+            headers: { "Cache-Control": "no-cache" }
+          });
+        }
+        return new Response(html, {
+          headers: {
+            "Content-Type": "text/html",
+            "Cache-Control": "no-cache"
+          }
+        });
+      } catch (error) {
+        console.error(`[stx] Hydration error for ${pathname}:`, error);
+        return new Response(compiled.html, {
+          headers: { "Content-Type": "text/html" }
+        });
+      }
+    }
+  });
+  console.log(`[stx] Production server running at http://localhost:${port}`);
+  console.log(`[stx] Serving ${manifest.routes.length} routes (${compiledTemplates.size} pre-loaded)`);
+  return { port, stop: () => server.stop() };
+}

package/dist/props.js

@@ -1,2 +1,224 @@
-// @bun
-import{$i as k,Ri as a,Si as b,Ti as c,Ui as d,Vi as e,Wi as f,Xi as g,Yi as h,Zi as i,_i as j,aj as l,bj as m,cj as n}from"./chunk-zk3d0jjf.js";import"./chunk-xv34zbp4.js";export{c as withDefaults,g as validated,j as shape,e as required,d as prop,k as processComponentProps,f as optional,h as oneOf,n as generatePropsInterface,b as definePropsWithValidation,a as defineProps,m as defineExpose,l as defineEmits,i as arrayOf};
+function getTypeName(type) {
+  if (type === String)
+    return "string";
+  if (type === Number)
+    return "number";
+  if (type === Boolean)
+    return "boolean";
+  if (type === Array)
+    return "array";
+  if (type === Object)
+    return "object";
+  if (type === Function)
+    return "function";
+  if (type === Date)
+    return "date";
+  if (type === Symbol)
+    return "symbol";
+  if (typeof type === "function" && type.name)
+    return type.name;
+  return "unknown";
+}
+function checkType(value, type) {
+  if (value === null || value === void 0)
+    return !0;
+  if (type === String)
+    return typeof value === "string";
+  if (type === Number)
+    return typeof value === "number" && !Number.isNaN(value);
+  if (type === Boolean)
+    return typeof value === "boolean";
+  if (type === Array)
+    return Array.isArray(value);
+  if (type === Object)
+    return typeof value === "object" && !Array.isArray(value);
+  if (type === Function)
+    return typeof value === "function";
+  if (type === Date)
+    return value instanceof Date;
+  if (type === Symbol)
+    return typeof value === "symbol";
+  if (typeof type === "function")
+    return value instanceof type;
+  return !0;
+}
+function validateProp(name, value, options, componentName) {
+  const prefix = componentName ? `[${componentName}]` : "";
+  if (options.required && (value === void 0 || value === null))
+    return {
+      prop: name,
+      message: `${prefix} Missing required prop: "${name}"`,
+      value,
+      expected: options.type ? getTypeName(options.type) : void 0
+    };
+  if (value === void 0 || value === null)
+    return null;
+  if (options.type) {
+    const types = Array.isArray(options.type) ? options.type : [options.type];
+    if (!types.some((t) => checkType(value, t))) {
+      const expectedTypes = types.map((t) => getTypeName(t)).join(" | ");
+      return {
+        prop: name,
+        message: `${prefix} Invalid prop type for "${name}": expected ${expectedTypes}, got ${typeof value}`,
+        value,
+        expected: expectedTypes
+      };
+    }
+  }
+  if (options.validator) {
+    if (!options.validator(value))
+      return {
+        prop: name,
+        message: `${prefix} Custom validation failed for prop "${name}"`,
+        value
+      };
+  }
+  return null;
+}
+export function defineProps(definitions) {
+  const props = globalThis.__STX_CURRENT_PROPS__ || {};
+  if (!definitions)
+    return props;
+  const result = { ...props };
+  for (const [key, def] of Object.entries(definitions)) {
+    const options = typeof def === "function" || Array.isArray(def) ? { type: def } : def || {};
+    if (result[key] === void 0 && options.default !== void 0)
+      result[key] = typeof options.default === "function" ? options.default() : options.default;
+  }
+  return result;
+}
+export function definePropsWithValidation(definitions, options = {}) {
+  const {
+    componentName,
+    throwOnError = !1,
+    logWarnings = !0
+  } = options, rawProps = globalThis.__STX_CURRENT_PROPS__ || {}, result = { ...rawProps }, validation = {
+    valid: !0,
+    errors: [],
+    warnings: []
+  };
+  for (const [key, def] of Object.entries(definitions)) {
+    const propOptions = typeof def === "function" || Array.isArray(def) ? { type: def } : def || {};
+    if (result[key] === void 0 && propOptions.default !== void 0)
+      result[key] = typeof propOptions.default === "function" ? propOptions.default() : propOptions.default;
+    const error = validateProp(key, result[key], propOptions, componentName);
+    if (error) {
+      validation.valid = !1;
+      validation.errors.push(error);
+      if (logWarnings)
+        console.warn(error.message);
+    }
+  }
+  for (const key of Object.keys(rawProps))
+    if (!(key in definitions)) {
+      const warning = `${componentName ? `[${componentName}]` : ""} Unknown prop: "${key}"`;
+      validation.warnings.push(warning);
+      if (logWarnings)
+        console.warn(warning);
+    }
+  if (throwOnError && !validation.valid) {
+    const errorMessages = validation.errors.map((e) => e.message).join(`
+`);
+    throw Error(`Prop validation failed:
+${errorMessages}`);
+  }
+  return {
+    props: result,
+    validation
+  };
+}
+export function withDefaults(props, defaults) {
+  const result = { ...props };
+  for (const [key, defaultValue] of Object.entries(defaults))
+    if (result[key] === void 0)
+      result[key] = typeof defaultValue === "function" ? defaultValue() : defaultValue;
+  return result;
+}
+export function prop(options) {
+  return options;
+}
+export function required(type) {
+  return { type, required: !0 };
+}
+export function optional(defaultValue, type) {
+  return { type, default: defaultValue };
+}
+export function validated(validator, options = {}) {
+  return { ...options, validator };
+}
+export function oneOf(values, options = {}) {
+  return {
+    ...options,
+    validator: (value) => values.includes(value)
+  };
+}
+export function arrayOf(_itemType, options = {}) {
+  return {
+    ...options,
+    type: Array,
+    validator: (value) => {
+      if (!Array.isArray(value))
+        return !1;
+      return !0;
+    }
+  };
+}
+export function shape(_shape, options = {}) {
+  return {
+    ...options,
+    type: Object
+  };
+}
+export function processComponentProps(rawProps, definitions, componentName) {
+  if (!definitions)
+    return rawProps;
+  const result = {};
+  for (const [key, def] of Object.entries(definitions)) {
+    const options = typeof def === "function" || Array.isArray(def) ? { type: def } : def || {};
+    let value = rawProps[key];
+    if (value === void 0 && options.default !== void 0)
+      value = typeof options.default === "function" ? options.default() : options.default;
+    {
+      const error = validateProp(key, value, options, componentName);
+      if (error)
+        console.warn(error.message);
+    }
+    result[key] = value;
+  }
+  for (const [key, value] of Object.entries(rawProps))
+    if (!(key in result))
+      result[key] = value;
+  return result;
+}
+export function defineEmits() {
+  const element = globalThis.__STX_CURRENT_ELEMENT__;
+  return (event, payload) => {
+    if (element) {
+      const customEvent = new CustomEvent(String(event), {
+        detail: payload,
+        bubbles: !0,
+        cancelable: !0
+      });
+      element.dispatchEvent(customEvent);
+    } else
+      console.warn(`Cannot emit event "${String(event)}" - no element context`);
+  };
+}
+export function defineExpose(exposed) {
+  const element = globalThis.__STX_CURRENT_ELEMENT__;
+  if (element) {
+    element.__stx_exposed__ = exposed;
+    element.setAttribute("data-stx-exposed", Object.keys(exposed).join(","));
+  }
+}
+export function generatePropsInterface(componentName, definitions) {
+  const lines = [`interface ${componentName}Props {`];
+  for (const [key, def] of Object.entries(definitions)) {
+    const options = typeof def === "function" || Array.isArray(def) ? { type: def } : def || {}, typeName = options.type ? getTypeName(options.type) : "unknown", optional = options.required ? "" : "?", description = options.description ? `  /** ${options.description} */
+` : "";
+    lines.push(`${description}  ${key}${optional}: ${typeName}`);
+  }
+  lines.push("}");
+  return lines.join(`
+`);
+}

package/dist/public-env.js

@@ -1,2 +1,19 @@
-// @bun
-import{Ty as a,Uy as b}from"./chunk-7ed3tean.js";import"./chunk-xv34zbp4.js";export{a as getPublicEnvDefine,b as getPublicEnv};
+import process from "node:process";
+export function getPublicEnvDefine(envPrefix = "STX_PUBLIC_") {
+  const define = {}, envObject = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (!key.startsWith(envPrefix) || value === void 0)
+      continue;
+    define[`import.meta.env.${key}`] = JSON.stringify(value);
+    envObject[key] = value;
+  }
+  define["import.meta.env"] = JSON.stringify(envObject);
+  return define;
+}
+export function getPublicEnv(envPrefix = "STX_PUBLIC_") {
+  const out = {};
+  for (const [key, value] of Object.entries(process.env))
+    if (key.startsWith(envPrefix) && value !== void 0)
+      out[key] = value;
+  return out;
+}