@stacksjs/stx 0.2.95 → 0.2.96

package/dist/dev-server/crosswind.js

@@ -1,2 +1,379 @@
-// @bun
-import{Iw as a,Jw as b,Kw as c,Lw as d,Mw as e,Nw as f,Ow as g,Pw as h,Qw as i,Rw as j}from"../chunk-shv88d2d.js";import"../chunk-0dx4q6yq.js";import"../chunk-xv34zbp4.js";export{b as resetCssCache,c as resetCrosswindCache,f as rebuildCrosswindCSS,d as loadCrosswindConfig,a as loadCrosswind,j as injectCrosswindCSS,g as getCachedCSS,i as generateCrosswindCSS,h as extractClassNames,e as buildCrosswindCSS};
+import fs from "node:fs";
+import path from "node:path";
+import { colors } from "./terminal-colors.js";
+let crosswindModule = null, crosswindLoadAttempted = !1, cachedConfig = null, cachedCSS = "", isBuilding = !1;
+const MAX_CACHE = 256, cssByClassSet = new Map;
+let diskCacheRoot = null, configFingerprint = null;
+function shortHash(input) {
+  return Bun.hash(input).toString(16).padStart(16, "0").slice(0, 16);
+}
+function setLruCache(key, value) {
+  if (cssByClassSet.has(key))
+    cssByClassSet.delete(key);
+  else if (cssByClassSet.size >= MAX_CACHE)
+    cssByClassSet.delete(cssByClassSet.keys().next().value);
+  cssByClassSet.set(key, value);
+}
+async function readDiskCache(key) {
+  if (!diskCacheRoot)
+    return null;
+  try {
+    const file = Bun.file(path.join(diskCacheRoot, `cw-${shortHash(key)}.css`));
+    if (!await file.exists())
+      return null;
+    return await file.text();
+  } catch {
+    return null;
+  }
+}
+async function writeDiskCache(key, css) {
+  if (!diskCacheRoot)
+    return;
+  try {
+    if (!fs.existsSync(diskCacheRoot))
+      fs.mkdirSync(diskCacheRoot, { recursive: !0 });
+    await Bun.write(path.join(diskCacheRoot, `cw-${shortHash(key)}.css`), css);
+  } catch {}
+}
+async function tryImportCrosswind(importPath) {
+  try {
+    const pkg = await import(importPath);
+    if (pkg && pkg.CSSGenerator)
+      return {
+        CSSGenerator: pkg.CSSGenerator,
+        config: pkg.config,
+        build: pkg.build,
+        defaultConfig: pkg.defaultConfig
+      };
+  } catch {}
+  return null;
+}
+function findCrosswindPaths() {
+  const paths = [], homeDir = process.env.HOME || process.env.USERPROFILE || "";
+  let currentDir = process.cwd();
+  while (currentDir !== path.dirname(currentDir)) {
+    paths.push(path.join(currentDir, "node_modules", "@cwcss", "crosswind", "dist", "index.js"));
+    paths.push(path.join(currentDir, "node_modules", "@cwcss", "crosswind", "src", "index.ts"));
+    paths.push(path.join(currentDir, "pantry", "@cwcss", "crosswind", "dist", "index.js"));
+    paths.push(path.join(currentDir, "pantry", "@cwcss", "crosswind", "src", "index.ts"));
+    paths.push(path.join(currentDir, "node_modules", "@stacksjs", "crosswind", "dist", "index.js"));
+    paths.push(path.join(currentDir, "pantry", "@stacksjs", "crosswind", "dist", "index.js"));
+    currentDir = path.dirname(currentDir);
+  }
+  if (homeDir) {
+    const devPaths = [
+      path.join(homeDir, "Code", "Tools", "crosswind", "packages", "crosswind", "dist", "index.js"),
+      path.join(homeDir, "Code", "Tools", "crosswind", "packages", "crosswind", "src", "index.ts"),
+      path.join(homeDir, "repos", "stacks-org", "crosswind", "packages", "crosswind", "dist", "index.js"),
+      path.join(homeDir, "repos", "stacks-org", "crosswind", "packages", "crosswind", "src", "index.ts"),
+      path.join(homeDir, "Code", "Tools", "stx", "packages", "stx", "node_modules", "@cwcss", "crosswind", "dist", "index.js"),
+      path.join(homeDir, "Code", "Tools", "stx", "packages", "stx", "node_modules", "@stacksjs", "crosswind", "dist", "index.js")
+    ];
+    paths.push(...devPaths);
+  }
+  paths.push(path.join(process.cwd(), "..", "crosswind", "packages", "crosswind", "dist", "index.js"));
+  paths.push(path.join(process.cwd(), "..", "crosswind", "packages", "crosswind", "src", "index.ts"));
+  return paths;
+}
+export async function loadCrosswind() {
+  if (crosswindLoadAttempted)
+    return crosswindModule;
+  crosswindLoadAttempted = !0;
+  try {
+    const importPaths = [
+      "@cwcss/crosswind",
+      "@cwcss/crosswind/dist/index.js",
+      "@stacksjs/crosswind",
+      "@stacksjs/crosswind/dist/index.js"
+    ];
+    for (const importPath of importPaths) {
+      const result = await tryImportCrosswind(importPath);
+      if (result) {
+        crosswindModule = result;
+        if (!process.env.STACKS_DEV_QUIET)
+          console.log(`${colors.green}[Crosswind]${colors.reset} CSS engine loaded`);
+        return crosswindModule;
+      }
+    }
+    const localPaths = findCrosswindPaths();
+    for (const localPath of localPaths)
+      if (await Bun.file(localPath).exists()) {
+        const result = await tryImportCrosswind(localPath);
+        if (result) {
+          crosswindModule = result;
+          if (!process.env.STACKS_DEV_QUIET)
+            console.log(`${colors.green}[Crosswind]${colors.reset} CSS engine loaded from ${path.dirname(path.dirname(localPath))}`);
+          return crosswindModule;
+        }
+      }
+    throw Error("Crosswind CSSGenerator not found in any location");
+  } catch {
+    console.warn(`${colors.yellow}[Crosswind] CSS engine not available, Tailwind styles will not be generated${colors.reset}`);
+    console.warn(`${colors.yellow}Run 'bun add @stacksjs/crosswind' to enable CSS generation${colors.reset}`);
+    return null;
+  }
+}
+export function resetCssCache() {
+  cssByClassSet.clear();
+}
+export function resetCrosswindCache() {
+  crosswindModule = null;
+  crosswindLoadAttempted = !1;
+  cachedConfig = null;
+  cachedCSS = "";
+  cssByClassSet.clear();
+  configFingerprint = null;
+}
+export async function loadCrosswindConfig(cwd) {
+  try {
+    const configDirectories = ["", "config", ".config"], configNames = ["crosswind.config", "crosswind", ".crosswind.config", ".crosswind"], configExtensions = [".ts", ".js", ".mjs", ".cjs", ".json"];
+    if (!configDirectories.flatMap((directory) => configNames.flatMap((name) => configExtensions.map((extension) => path.join(directory, `${name}${extension}`)))).some((candidate) => fs.existsSync(path.join(cwd, candidate))))
+      return null;
+    const { loadConfigWithResult } = await import("bunfig"), result = await loadConfigWithResult({
+      name: "crosswind",
+      cwd,
+      defaultConfig: {},
+      checkEnv: !1,
+      verbose: !1
+    });
+    if (!result?.path || !result.config || Object.keys(result.config).length === 0)
+      return null;
+    const rel = path.relative(cwd, result.path);
+    if (!process.env.STACKS_DEV_QUIET)
+      console.log(`${colors.green}[Crosswind]${colors.reset} Loaded config from ${rel || result.path}`);
+    return result.config;
+  } catch (error) {
+    if (error instanceof Error && error.name === "ConfigNotFoundError")
+      return null;
+    console.warn(`${colors.yellow}[Crosswind]${colors.reset} Failed to load crosswind config:`, error instanceof Error ? error.message : error);
+    return null;
+  }
+}
+export async function buildCrosswindCSS(cwd) {
+  if (isBuilding)
+    return cachedCSS;
+  isBuilding = !0;
+  try {
+    const hw = await loadCrosswind();
+    if (!hw || !hw.build) {
+      isBuilding = !1;
+      return "";
+    }
+    if (!cachedConfig)
+      cachedConfig = await loadCrosswindConfig(cwd);
+    if (!cachedConfig) {
+      isBuilding = !1;
+      return "";
+    }
+    const defaultTheme = hw.defaultConfig?.theme || {}, userTheme = cachedConfig.theme || {}, config = {
+      ...hw.defaultConfig,
+      ...cachedConfig,
+      theme: {
+        ...defaultTheme,
+        ...userTheme,
+        extend: {
+          ...defaultTheme.extend || {},
+          ...userTheme.extend || {}
+        }
+      }
+    }, start = performance.now(), result = await hw.build(config), duration = performance.now() - start;
+    cachedCSS = result.css;
+    console.log(`${colors.cyan}[Crosswind]${colors.reset} Built ${result.classes.size} classes in ${duration.toFixed(1)}ms`);
+    if (config.output) {
+      const outputPath = path.isAbsolute(config.output) ? config.output : path.join(cwd, config.output), outputDir = path.dirname(outputPath);
+      if (!fs.existsSync(outputDir))
+        fs.mkdirSync(outputDir, { recursive: !0 });
+      await Bun.write(outputPath, result.css);
+    }
+    isBuilding = !1;
+    return result.css;
+  } catch (error) {
+    console.error(`${colors.red}[Crosswind]${colors.reset} Build error:`, error);
+    isBuilding = !1;
+    return cachedCSS;
+  }
+}
+export async function rebuildCrosswindCSS(cwd) {
+  cachedConfig = null;
+  await buildCrosswindCSS(cwd);
+}
+export function getCachedCSS() {
+  return cachedCSS;
+}
+export function extractClassNames(htmlContent) {
+  const classes = new Set, classRegex = /class\s*=\s*["']([^"']+)["']/gi;
+  let match = classRegex.exec(htmlContent);
+  while (match !== null) {
+    for (const cls of match[1].split(/\s+/))
+      if (cls.trim())
+        classes.add(cls.trim());
+    match = classRegex.exec(htmlContent);
+  }
+  const dynRegex = /(?:x-class|:class)\s*=\s*"([^"]+)"/gi;
+  let dynMatch = dynRegex.exec(htmlContent);
+  while (dynMatch !== null) {
+    const strLiterals = dynMatch[1].match(/'([^']+)'/g);
+    if (strLiterals) {
+      for (const lit of strLiterals)
+        for (const cls of lit.slice(1, -1).split(/\s+/))
+          if (cls.trim())
+            classes.add(cls.trim());
+    }
+    dynMatch = dynRegex.exec(htmlContent);
+  }
+  return classes;
+}
+export async function generateCrosswindCSS(htmlContent, appDir) {
+  try {
+    const hw = await loadCrosswind();
+    if (!hw)
+      return "";
+    const classes = extractClassNames(htmlContent);
+    if (classes.size === 0)
+      return "";
+    const resolveRoot = appDir ? path.resolve(appDir) : process.cwd();
+    if (!diskCacheRoot)
+      diskCacheRoot = path.join(resolveRoot, ".stx/cache");
+    const classSetKey = [...classes].sort().join(" "), cacheKey = `${configFingerprint || "default"}::${classSetKey}`, cached = cssByClassSet.get(cacheKey);
+    if (cached !== void 0) {
+      setLruCache(cacheKey, cached);
+      return cached;
+    }
+    const onDisk = await readDiskCache(cacheKey);
+    if (onDisk !== null) {
+      setLruCache(cacheKey, onDisk);
+      return onDisk;
+    }
+    if (!cachedConfig) {
+      let stxCssConfig = null;
+      try {
+        const { loadStxConfig } = await import("../config.js"), stxConfig = await loadStxConfig(resolveRoot);
+        if (stxConfig.css)
+          if (typeof stxConfig.css === "string") {
+            const configPath = path.isAbsolute(stxConfig.css) ? stxConfig.css : path.resolve(resolveRoot, stxConfig.css);
+            if (await Bun.file(configPath).exists()) {
+              const mod = await import(configPath);
+              stxCssConfig = mod.default || mod;
+              console.log(`${colors.green}[Crosswind]${colors.reset} Loaded config from stx.config.ts \u2192 ${stxConfig.css}`);
+            }
+          } else {
+            stxCssConfig = {
+              ...stxConfig.css,
+              content: stxConfig.css.content || [],
+              preflight: stxConfig.css.preflight ?? !0,
+              minify: stxConfig.css.minify ?? !1
+            };
+            if (stxConfig.css.config) {
+              const configPath = path.isAbsolute(stxConfig.css.config) ? stxConfig.css.config : path.resolve(resolveRoot, stxConfig.css.config);
+              if (await Bun.file(configPath).exists()) {
+                const mod = await import(configPath);
+                stxCssConfig = { ...mod.default || mod, ...stxCssConfig };
+              }
+            }
+            console.log(`${colors.green}[Crosswind]${colors.reset} Using inline CSS config from stx.config.ts`);
+          }
+      } catch {}
+      cachedConfig = stxCssConfig || await loadCrosswindConfig(resolveRoot);
+      try {
+        configFingerprint = shortHash(JSON.stringify(cachedConfig ?? {}));
+      } catch {
+        configFingerprint = "unhashable";
+      }
+    }
+    const baseConfig = hw.defaultConfig || hw.config, userConfig = cachedConfig || {}, baseTheme = baseConfig.theme || {}, userExtend = (userConfig.theme || {}).extend || {}, theme = { ...baseTheme };
+    if (Object.keys(userExtend).length > 0)
+      theme.extend = userExtend;
+    const safelist = [
+      ...baseConfig.safelist || [],
+      ...userConfig.safelist || []
+    ], crosswindConfig = {
+      ...baseConfig,
+      ...userConfig,
+      content: [],
+      output: "",
+      preflight: !0,
+      minify: !1,
+      theme,
+      safelist
+    }, generator = new hw.CSSGenerator(crosswindConfig);
+    for (const cls of safelist)
+      generator.generate(cls);
+    for (const className of classes)
+      generator.generate(className);
+    let css = generator.toCSS(!0, !1);
+    const shortcuts = crosswindConfig.shortcuts || userConfig.shortcuts || {};
+    for (const [name, classStr] of Object.entries(shortcuts)) {
+      if (!classes.has(name) && !safelist.includes(name))
+        continue;
+      const parts = classStr.split(/\s+/).filter(Boolean);
+      for (const p of parts)
+        generator.generate(p);
+    }
+    css = generator.toCSS(!0, !1);
+    const cssLines = css.split(`
+`);
+    for (const [name, classStr] of Object.entries(shortcuts)) {
+      if (!classes.has(name) && !safelist.includes(name))
+        continue;
+      const parts = classStr.split(/\s+/).filter(Boolean), decls = [], darkDecls = [];
+      for (const cls of parts) {
+        const isDark = cls.startsWith("dark:"), selectorTarget = `.${(isDark ? cls.slice(5) : cls).replace(/\//g, "\\/").replace(/:/g, "\\:").replace(/\./g, "\\.").replace(/\[/g, "\\[").replace(/\]/g, "\\]").replace(/%/g, "\\%")}`;
+        for (let i = 0;i < cssLines.length; i++) {
+          const line = cssLines[i].trim();
+          if (line === `${selectorTarget} {` || line.startsWith(`${selectorTarget} {`)) {
+            let j = i, ruleContent = "";
+            while (j < cssLines.length) {
+              ruleContent += cssLines[j];
+              if (cssLines[j].includes("}"))
+                break;
+              j++;
+            }
+            const declMatch = ruleContent.match(/\{([^}]+)\}/);
+            if (declMatch)
+              if (isDark)
+                darkDecls.push(declMatch[1].trim());
+              else
+                decls.push(declMatch[1].trim());
+            break;
+          }
+        }
+      }
+      if (decls.length)
+        css += `
+.${name} { ${decls.join(" ")} }`;
+      if (darkDecls.length)
+        css += `
+@media (prefers-color-scheme: dark) { .dark .${name} { ${darkDecls.join(" ")} } }`;
+    }
+    setLruCache(cacheKey, css);
+    writeDiskCache(cacheKey, css);
+    return css;
+  } catch (error) {
+    console.warn("Failed to generate Crosswind CSS:", error);
+    return "";
+  }
+}
+export async function injectCrosswindCSS(htmlContent, appDir) {
+  const css = await generateCrosswindCSS(htmlContent, appDir);
+  if (!css)
+    return htmlContent;
+  const styleTag = `<style data-crosswind="generated">
+${css}
+</style>`, existing = /<style data-crosswind="generated">[\s\S]*?<\/style>/g;
+  if (existing.test(htmlContent)) {
+    let placed = !1;
+    return htmlContent.replace(existing, () => {
+      if (placed)
+        return "";
+      placed = !0;
+      return styleTag;
+    });
+  }
+  if (htmlContent.includes("</head>"))
+    return htmlContent.replace("</head>", `${styleTag}
+</head>`);
+  if (htmlContent.includes("<body"))
+    return htmlContent.replace(/<body([^>]*)>/, `<body$1>
+${styleTag}`);
+  return styleTag + htmlContent;
+}

package/dist/dev-server/index.js

@@ -1,2 +1,7 @@
-// @bun
-import"../chunk-4aj7ftqb.js";import{bo as K,co as L,do as M}from"../chunk-km25cwz6.js";import{eo as B,fo as C,go as D,ho as E}from"../chunk-x3r64r0c.js";import{io as x,jo as y,ko as z,lo as A}from"../chunk-1sr54zp8.js";import{mo as r,no as s,oo as t,po as u,qo as v,ro as w}from"../chunk-9t14se2t.js";import{so as F,to as G,uo as H,vo as I,wo as J}from"../chunk-nm15ccsg.js";import{Iw as h,Jw as i,Kw as j,Lw as k,Mw as l,Nw as m,Ow as n,Pw as o,Qw as p,Rw as q}from"../chunk-shv88d2d.js";import{Sw as a,Tw as b,Uw as c,Vw as d,Ww as e,Xw as f,Yw as g}from"../chunk-0dx4q6yq.js";import"../chunk-xv34zbp4.js";export{d as warning,c as success,I as setupKeyboardShortcuts,i as resetCssCache,j as resetCrosswindCache,m as rebuildCrosswindCSS,F as printShortcutsHelp,G as printServerStatus,C as openNativeWindow,H as openInBrowser,k as loadCrosswindConfig,h as loadCrosswind,x as isPortAvailable,D as isNativeWindowSupported,w as isDarkTheme,q as injectCrosswindCSS,f as info,r as getThemeSelectorStyles,t as getThemeSelectorScript,s as getThemeSelectorHtml,L as getMimeType,u as getFrontmatterHtml,n as getCachedCSS,p as generateCrosswindCSS,A as findAvailablePortInRange,y as findAvailablePort,E as extractSidebarConfig,o as extractClassNames,e as error,g as dim,a as colors,b as colorize,J as cleanupKeyboardShortcuts,l as buildCrosswindCSS,K as MIME_TYPES,z as DEFAULT_PORT,B as DEFAULT_NATIVE_WINDOW_CONFIG,M as DEFAULT_DEV_OPTIONS,v as DARK_THEME_KEYWORDS};
+export * from "./terminal-colors.js";
+export * from "./crosswind.js";
+export * from "./theme-selector.js";
+export * from "./port-utils.js";
+export * from "./native-window.js";
+export * from "./keyboard-shortcuts.js";
+export * from "./types.js";

package/dist/dev-server/keyboard-shortcuts.js

@@ -1,2 +1,81 @@
-// @bun
-import{so as a,to as b,uo as c,vo as d,wo as e}from"../chunk-nm15ccsg.js";import"../chunk-0dx4q6yq.js";import"../chunk-xv34zbp4.js";export{d as setupKeyboardShortcuts,a as printShortcutsHelp,b as printServerStatus,c as openInBrowser,e as cleanupKeyboardShortcuts};
+import { colors } from "./terminal-colors.js";
+export function printShortcutsHelp() {
+  console.log(`
+Keyboard shortcuts:`);
+  console.log(`  ${colors.cyan}o${colors.reset} + Enter - Open in browser`);
+  console.log(`  ${colors.cyan}c${colors.reset} + Enter - Clear console`);
+  console.log(`  ${colors.cyan}q${colors.reset} + Enter (or ${colors.cyan}Ctrl+C${colors.reset}) - Quit server`);
+  console.log(`  ${colors.cyan}h${colors.reset} + Enter - Show this help`);
+}
+export function printServerStatus(serverUrl) {
+  console.log(`${colors.green}Server running at ${colors.cyan}${serverUrl}${colors.reset}`);
+  console.log(`Press ${colors.cyan}Ctrl+C${colors.reset} to stop the server`);
+  printShortcutsHelp();
+}
+export function openInBrowser(url) {
+  console.log(`${colors.dim}Opening ${colors.cyan}${url}${colors.dim} in your browser...${colors.reset}`);
+  Bun.spawn(["open", url], { stderr: "inherit" });
+}
+export function setupKeyboardShortcuts(serverUrl, stopServer, customHandlers) {
+  if (!process.stdin.isTTY)
+    return;
+  process.stdin.setRawMode(!0);
+  process.stdin.setEncoding("utf8");
+  process.stdin.resume();
+  printShortcutsHelp();
+  let buffer = "";
+  process.stdin.on("data", (key) => {
+    if (key === "\x03") {
+      if (customHandlers?.onQuit)
+        customHandlers.onQuit();
+      stopServer();
+      process.exit(0);
+    }
+    buffer += key;
+    if (buffer.endsWith("\r") || buffer.endsWith(`
+`)) {
+      const cmd = buffer.trim().toLowerCase();
+      buffer = "";
+      handleCommand(cmd, serverUrl, stopServer, customHandlers);
+    }
+  });
+}
+function handleCommand(cmd, serverUrl, stopServer, customHandlers) {
+  switch (cmd) {
+    case "o":
+      if (customHandlers?.onOpen)
+        customHandlers.onOpen();
+      else
+        openInBrowser(serverUrl);
+      break;
+    case "c":
+      if (customHandlers?.onClear)
+        customHandlers.onClear();
+      else {
+        console.clear();
+        printServerStatus(serverUrl);
+      }
+      break;
+    case "q":
+      if (customHandlers?.onQuit)
+        customHandlers.onQuit();
+      console.log(`${colors.yellow}Stopping server...${colors.reset}`);
+      stopServer();
+      process.exit(0);
+      break;
+    case "h":
+      if (customHandlers?.onHelp)
+        customHandlers.onHelp();
+      else
+        printShortcutsHelp();
+      break;
+    default:
+      break;
+  }
+}
+export function cleanupKeyboardShortcuts() {
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(!1);
+    process.stdin.pause();
+  }
+}

package/dist/dev-server/native-window.js

@@ -1,2 +1,91 @@
-// @bun
-import{eo as a,fo as b,go as c,ho as d}from"../chunk-x3r64r0c.js";import"../chunk-0dx4q6yq.js";import"../chunk-xv34zbp4.js";export{b as openNativeWindow,c as isNativeWindowSupported,d as extractSidebarConfig,a as DEFAULT_NATIVE_WINDOW_CONFIG};
+import { colors } from "./terminal-colors.js";
+export const DEFAULT_NATIVE_WINDOW_CONFIG = {
+  title: "stx Development",
+  width: 1400,
+  height: 900,
+  darkMode: !0,
+  hotReload: !0,
+  titlebarHidden: !1,
+  nativeSidebar: !1,
+  sidebarWidth: 260,
+  sidebarConfig: void 0
+};
+async function loadDesktop() {
+  try {
+    const mod = await import("@stacksjs/desktop");
+    if (typeof mod.openDevWindow !== "function")
+      return null;
+    return mod;
+  } catch {
+    return null;
+  }
+}
+export async function openNativeWindow(port, config = {}) {
+  const mergedConfig = {
+    ...DEFAULT_NATIVE_WINDOW_CONFIG,
+    ...config
+  }, desktop = await loadDesktop();
+  if (!desktop) {
+    console.log(`${colors.yellow}\u26A0${colors.reset} Native window requested, but @stacksjs/desktop is not available.`);
+    console.log("  Install & build the desktop package to enable --native.");
+    return !1;
+  }
+  try {
+    const success = await desktop.openDevWindow(port, {
+      title: mergedConfig.title,
+      width: mergedConfig.width,
+      height: mergedConfig.height,
+      darkMode: mergedConfig.darkMode,
+      hotReload: mergedConfig.hotReload,
+      titlebarHidden: mergedConfig.titlebarHidden,
+      nativeSidebar: mergedConfig.nativeSidebar,
+      sidebarWidth: mergedConfig.sidebarWidth,
+      sidebarConfig: mergedConfig.sidebarConfig
+    });
+    if (success && mergedConfig.nativeSidebar)
+      console.log(`${colors.green}\u2713${colors.reset} Native sidebar enabled (macOS Tahoe style)`);
+    return success;
+  } catch (error) {
+    console.log(`${colors.red}\u2717${colors.reset} Could not open native window:`, error);
+    return !1;
+  }
+}
+export async function isNativeWindowSupported() {
+  return await loadDesktop() !== null;
+}
+export function extractSidebarConfig(templateContent) {
+  if (templateContent.match(/<Sidebar[\s\S]*?variant=["'](?:tahoe|vibrancy|desktop)["'][\s\S]*?\/>/i)) {
+    const scriptMatch = templateContent.match(/<script\s+server[^>]*>([\s\S]*?)<\/script>/i);
+    if (scriptMatch) {
+      const scriptContent = scriptMatch[1];
+      try {
+        const evalScript = `
+          ${scriptContent}
+          return typeof sidebarConfig !== 'undefined' ? sidebarConfig : null;
+        `, config = Function(evalScript)();
+        if (config)
+          return config;
+      } catch (e) {
+        console.warn("Invalid sidebarConfig:", e);
+      }
+    }
+    return { sections: [] };
+  }
+  const directiveMatch = templateContent.match(/@nativeSidebar\s*\(\s*(\{[\s\S]*?\})\s*\)/m);
+  if (directiveMatch)
+    try {
+      return JSON.parse(directiveMatch[1]);
+    } catch {
+      console.warn("Invalid @nativeSidebar configuration");
+    }
+  const nativeSidebarScriptMatch = templateContent.match(/<script\s+native-sidebar[^>]*>([\s\S]*?)<\/script>/i);
+  if (nativeSidebarScriptMatch)
+    try {
+      const configObjMatch = nativeSidebarScriptMatch[1].match(/(?:export\s+(?:default\s+)?|const\s+\w+\s*=\s*)(\{[\s\S]*\})/m);
+      if (configObjMatch)
+        return Function(`return ${configObjMatch[1]}`)();
+    } catch (e) {
+      console.warn("Invalid native-sidebar script configuration:", e);
+    }
+  return;
+}

package/dist/dev-server/port-utils.js

@@ -1,2 +1,40 @@
-// @bun
-import{io as a,jo as b,ko as c,lo as d}from"../chunk-1sr54zp8.js";import"../chunk-xv34zbp4.js";export{a as isPortAvailable,d as findAvailablePortInRange,b as findAvailablePort,c as DEFAULT_PORT};
+import net from "node:net";
+async function isPortAvailableIPv4(port) {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.once("error", () => resolve(!1));
+    server.once("listening", () => {
+      server.close(() => resolve(!0));
+    });
+    server.listen(port, "0.0.0.0");
+  });
+}
+async function isPortAvailableIPv6(port) {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.once("error", () => resolve(!1));
+    server.once("listening", () => {
+      server.close(() => resolve(!0));
+    });
+    server.listen(port, "::");
+  });
+}
+export async function isPortAvailable(port) {
+  if (!await isPortAvailableIPv4(port))
+    return !1;
+  return await isPortAvailableIPv6(port);
+}
+export async function findAvailablePort(startPort, maxAttempts = 20) {
+  startPort = Number(startPort);
+  for (let i = 0;i < maxAttempts; i++) {
+    const port = startPort + i;
+    if (await isPortAvailable(port))
+      return port;
+  }
+  throw Error(`Could not find an available port between ${startPort} and ${startPort + maxAttempts - 1}`);
+}
+export const DEFAULT_PORT = 3000;
+export async function findAvailablePortInRange(range) {
+  const maxAttempts = range.end - range.start + 1;
+  return findAvailablePort(range.start, maxAttempts);
+}