@stacksjs/stx 0.2.94 → 0.2.96

package/dist/production-builder.js

@@ -1,2 +1,132 @@
-// @bun
-import{Bi as a}from"./chunk-y86m1wr4.js";import"./chunk-bjnjpsgn.js";import"./chunk-2w3302dh.js";import"./chunk-cn409b69.js";import"./chunk-y4c744dk.js";import"./chunk-bgec9r1v.js";import"./chunk-5ppkfyn2.js";import"./chunk-ncnfa8ae.js";import"./chunk-6djgb0hr.js";import"./chunk-w01y57f5.js";import"./chunk-x1hjv24z.js";import"./chunk-0g4gece6.js";import"./chunk-nap11ntr.js";import"./chunk-03c26pjz.js";import"./chunk-13yz561y.js";import"./chunk-nanw7yhz.js";import"./chunk-ghrx0hn1.js";import"./chunk-82t27pvd.js";import"./chunk-fhawx87n.js";import"./chunk-gc84b1d2.js";import"./chunk-yr1gdceh.js";import"./chunk-baa7h4yz.js";import"./chunk-kdxa9epn.js";import"./chunk-g2hekckm.js";import"./chunk-x39sfpvm.js";import"./chunk-tr0z0e1g.js";import"./chunk-4j188175.js";import"./chunk-eds0f8f1.js";import"./chunk-dyjnn5k8.js";import"./chunk-8fgwhhb8.js";import"./chunk-tj6zfxeb.js";import"./chunk-7xcfy2fn.js";import"./chunk-9yz5d003.js";import"./chunk-fms20x0n.js";import"./chunk-fe7r1mq1.js";import"./chunk-rb1e4cnb.js";import"./chunk-j4s5qwd7.js";import"./chunk-b0cyc09a.js";import"./chunk-0tatqxj2.js";import"./chunk-bykjk6vj.js";import"./chunk-7b0xdy5h.js";import"./chunk-ywkrxp2h.js";import"./chunk-y25pr13j.js";import"./chunk-q6h6yvzb.js";import"./chunk-qdc3aav1.js";import"./chunk-6wn85hn6.js";import"./chunk-qd5461tt.js";import"./chunk-77tga15w.js";import"./chunk-rv002yn0.js";import"./chunk-hke99a0v.js";import"./chunk-mwbng54r.js";import"./chunk-wxvyj65q.js";import"./chunk-yw2fzq86.js";import"./chunk-mrehzhxv.js";import"./chunk-1zgsgk4b.js";import"./chunk-48cw2nde.js";import"./chunk-jjvp4t5w.js";import"./chunk-94g3cahw.js";import"./chunk-ht4j68cs.js";import"./chunk-fch9tk1k.js";import"./chunk-cz25azze.js";import"./chunk-q60knhjf.js";import"./chunk-hrampcrj.js";import"./chunk-t37dp99j.js";import"./chunk-5kt3ay7x.js";import"./chunk-95w08s8v.js";import"./chunk-ceg2c2q2.js";import"./chunk-04mvcmcr.js";import"./chunk-n46a5g1g.js";import"./chunk-vv9wfz1c.js";import"./chunk-dzw95th7.js";import"./chunk-46mkpbkk.js";import"./chunk-3rh7va1z.js";import"./chunk-2xen423s.js";import"./chunk-cp3kwv17.js";import"./chunk-hpqr9e3x.js";import"./chunk-adqh2m9z.js";import"./chunk-8qbax8xn.js";import"./chunk-x64kb787.js";import"./chunk-gcf5v18y.js";import"./chunk-pc31m5x5.js";import"./chunk-3jm3snz8.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{Ki as a}from"./chunk-174z0cd0.js";import"./chunk-qfwzdffx.js";import"./chunk-cn409b69.js";import"./chunk-ncnfa8ae.js";import"./chunk-6djgb0hr.js";import"./chunk-w01y57f5.js";import"./chunk-x1hjv24z.js";import"./chunk-0g4gece6.js";import"./chunk-nap11ntr.js";import"./chunk-03c26pjz.js";import"./chunk-13yz561y.js";import"./chunk-nanw7yhz.js";import"./chunk-ghrx0hn1.js";import"./chunk-82t27pvd.js";import"./chunk-fhawx87n.js";import"./chunk-gc84b1d2.js";import"./chunk-yr1gdceh.js";import"./chunk-baa7h4yz.js";import"./chunk-kdxa9epn.js";import"./chunk-g2hekckm.js";import"./chunk-x39sfpvm.js";import"./chunk-tr0z0e1g.js";import"./chunk-4j188175.js";import"./chunk-eds0f8f1.js";import"./chunk-dyjnn5k8.js";import"./chunk-8fgwhhb8.js";import"./chunk-tj6zfxeb.js";import"./chunk-7xcfy2fn.js";import"./chunk-9yz5d003.js";import"./chunk-fms20x0n.js";import"./chunk-fe7r1mq1.js";import"./chunk-rb1e4cnb.js";import"./chunk-j4s5qwd7.js";import"./chunk-b0cyc09a.js";import"./chunk-0tatqxj2.js";import"./chunk-bykjk6vj.js";import"./chunk-7b0xdy5h.js";import"./chunk-ywkrxp2h.js";import"./chunk-y25pr13j.js";import"./chunk-q6h6yvzb.js";import"./chunk-qdc3aav1.js";import"./chunk-6wn85hn6.js";import"./chunk-qd5461tt.js";import"./chunk-77tga15w.js";import"./chunk-rv002yn0.js";import"./chunk-hke99a0v.js";import"./chunk-mwbng54r.js";import"./chunk-wxvyj65q.js";import"./chunk-yw2fzq86.js";import"./chunk-mrehzhxv.js";import"./chunk-1zgsgk4b.js";import"./chunk-48cw2nde.js";import"./chunk-jjvp4t5w.js";import"./chunk-94g3cahw.js";import"./chunk-ht4j68cs.js";import"./chunk-fch9tk1k.js";import"./chunk-cz25azze.js";import"./chunk-q60knhjf.js";import"./chunk-hrampcrj.js";import"./chunk-t37dp99j.js";import"./chunk-5kt3ay7x.js";import"./chunk-95w08s8v.js";import"./chunk-ceg2c2q2.js";import"./chunk-04mvcmcr.js";import"./chunk-n46a5g1g.js";import"./chunk-vv9wfz1c.js";import"./chunk-dzw95th7.js";import"./chunk-46mkpbkk.js";import"./chunk-3rh7va1z.js";import"./chunk-2xen423s.js";import"./chunk-cp3kwv17.js";import"./chunk-hpqr9e3x.js";import"./chunk-adqh2m9z.js";import"./chunk-8qbax8xn.js";import"./chunk-x64kb787.js";import"./chunk-gcf5v18y.js";import"./chunk-pc31m5x5.js";import"./chunk-3jm3snz8.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 n,Oi as a,Pi as b,Qi as c,Ri as d,Si as e,Ti as f,Ui as g,Vi as h,Wi as i,Xi as j,Yi as k,Zi as l,_i as m}from"./chunk-z8cjr9n9.js";import"./chunk-3jm3snz8.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{Vy as a,Wy as b}from"./chunk-q60knhjf.js";import"./chunk-3jm3snz8.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;
+}