@stacksjs/stx 0.2.95 → 0.2.97

package/dist/pwa/icons.js

@@ -1,2 +1,109 @@
-// @bun
-import{Be as a,Ce as b,De as c,Ee as d,Fe as e,Ge as f}from"../chunk-8a5bxece.js";import"../chunk-xv34zbp4.js";export{f as isSharpAvailable,e as getExpectedIconPaths,d as generatePwaIcons,c as FAVICON_SIZES,a as DEFAULT_ICON_SIZES,b as APPLE_TOUCH_ICON_SIZES};
+import fs from "node:fs";
+import path from "node:path";
+export const DEFAULT_ICON_SIZES = [72, 96, 128, 144, 152, 192, 384, 512], APPLE_TOUCH_ICON_SIZES = [120, 152, 167, 180], FAVICON_SIZES = [16, 32];
+export async function generatePwaIcons(options, outputDir) {
+  const result = {
+    success: !0,
+    generatedFiles: [],
+    errors: [],
+    warnings: []
+  }, iconConfig = options.pwa?.icons;
+  if (!iconConfig?.src) {
+    result.errors.push("No source icon specified in pwa.icons.src");
+    result.success = !1;
+    return result;
+  }
+  const sourcePath = path.isAbsolute(iconConfig.src) ? iconConfig.src : path.resolve(process.cwd(), iconConfig.src);
+  if (!await Bun.file(sourcePath).exists()) {
+    result.errors.push(`Source icon not found: ${sourcePath}`);
+    result.success = !1;
+    return result;
+  }
+  const iconsOutputDir = path.resolve(outputDir, iconConfig.outputDir || "pwa-icons");
+  try {
+    fs.mkdirSync(iconsOutputDir, { recursive: !0 });
+  } catch {
+    result.errors.push(`Failed to create output directory: ${iconsOutputDir}`);
+    result.success = !1;
+    return result;
+  }
+  const sizes = iconConfig.sizes || DEFAULT_ICON_SIZES, generateWebP = iconConfig.generateWebP ?? !0, generateAppleIcons = iconConfig.generateAppleIcons ?? !0;
+  try {
+    let sharp;
+    try {
+      sharp = await import("sharp");
+    } catch {
+      result.errors.push(`sharp is not installed. Install it with: bun add sharp
+Icon generation requires the sharp package for image processing.`);
+      result.success = !1;
+      return result;
+    }
+    const metadata = await sharp.default(sourcePath).metadata();
+    if (metadata.width && metadata.width < 512)
+      result.warnings.push(`Source icon is ${metadata.width}x${metadata.height}. Recommend using at least 512x512 for best quality.`);
+    for (const size of sizes) {
+      const pngPath = path.join(iconsOutputDir, `icon-${size}x${size}.png`);
+      await sharp.default(sourcePath).resize(size, size, { fit: "contain", background: { r: 0, g: 0, b: 0, alpha: 0 } }).png().toFile(pngPath);
+      result.generatedFiles.push(pngPath);
+      if (generateWebP) {
+        const webpPath = path.join(iconsOutputDir, `icon-${size}x${size}.webp`);
+        await sharp.default(sourcePath).resize(size, size, { fit: "contain", background: { r: 0, g: 0, b: 0, alpha: 0 } }).webp({ quality: 90 }).toFile(webpPath);
+        result.generatedFiles.push(webpPath);
+      }
+    }
+    if (generateAppleIcons) {
+      for (const size of APPLE_TOUCH_ICON_SIZES) {
+        const applePath = path.join(iconsOutputDir, `apple-touch-icon-${size}x${size}.png`);
+        await sharp.default(sourcePath).resize(size, size, { fit: "contain", background: { r: 255, g: 255, b: 255, alpha: 1 } }).png().toFile(applePath);
+        result.generatedFiles.push(applePath);
+      }
+      const defaultApplePath = path.join(iconsOutputDir, "apple-touch-icon.png");
+      await sharp.default(sourcePath).resize(180, 180, { fit: "contain", background: { r: 255, g: 255, b: 255, alpha: 1 } }).png().toFile(defaultApplePath);
+      result.generatedFiles.push(defaultApplePath);
+    }
+    for (const size of FAVICON_SIZES) {
+      const faviconPath = path.join(iconsOutputDir, `favicon-${size}x${size}.png`);
+      await sharp.default(sourcePath).resize(size, size, { fit: "contain", background: { r: 0, g: 0, b: 0, alpha: 0 } }).png().toFile(faviconPath);
+      result.generatedFiles.push(faviconPath);
+    }
+    const maskableSize = 512, maskablePath = path.join(iconsOutputDir, `icon-maskable-${maskableSize}x${maskableSize}.png`), padding = Math.floor(maskableSize * 0.1), innerSize = maskableSize - padding * 2;
+    await sharp.default(sourcePath).resize(innerSize, innerSize, { fit: "contain", background: { r: 0, g: 0, b: 0, alpha: 0 } }).extend({
+      top: padding,
+      bottom: padding,
+      left: padding,
+      right: padding,
+      background: { r: 255, g: 255, b: 255, alpha: 1 }
+    }).png().toFile(maskablePath);
+    result.generatedFiles.push(maskablePath);
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    result.errors.push(`Icon generation failed: ${errorMessage}`);
+    result.success = !1;
+  }
+  return result;
+}
+export function getExpectedIconPaths(config) {
+  const sizes = config.sizes || DEFAULT_ICON_SIZES, outputDir = config.outputDir ? `/${config.outputDir}` : "/pwa-icons", generateWebP = config.generateWebP ?? !0, generateAppleIcons = config.generateAppleIcons ?? !0, paths = [];
+  for (const size of sizes) {
+    paths.push(`${outputDir}/icon-${size}x${size}.png`);
+    if (generateWebP)
+      paths.push(`${outputDir}/icon-${size}x${size}.webp`);
+  }
+  if (generateAppleIcons) {
+    paths.push(`${outputDir}/apple-touch-icon.png`);
+    for (const size of APPLE_TOUCH_ICON_SIZES)
+      paths.push(`${outputDir}/apple-touch-icon-${size}x${size}.png`);
+  }
+  for (const size of FAVICON_SIZES)
+    paths.push(`${outputDir}/favicon-${size}x${size}.png`);
+  paths.push(`${outputDir}/icon-maskable-512x512.png`);
+  return paths;
+}
+export async function isSharpAvailable() {
+  try {
+    await import("sharp");
+    return !0;
+  } catch {
+    return !1;
+  }
+}

package/dist/pwa/index.js

@@ -1,2 +1,47 @@
-// @bun
-import"../chunk-xv34zbp4.js";export{m as runPwaAudit,u as pwaDirectives,J as mapStrategyToWorkbox,C as isWorkboxEnabled,h as injectPwaTags,K as getWorkboxStrategyName,H as getServiceWorkerGenerator,B as getServiceWorkerFileName,F as generateWorkboxServiceWorker,E as generateWorkboxConfig,j as generateSwRegistrationScript,A as generateServiceWorkerAuto,z as generateServiceWorker,L as generateRuntimeCachingCode,O as generateRuntimeCaching,V as generatePwaIcons,Y as generatePrecacheManifestJs,X as generatePrecacheManifest,M as generatePatternMatcher,$ as generateOfflinePage,T as generateManifest,Z as formatSize,P as createExpirationPlugin,Q as createCacheableResponsePlugin,R as createBackgroundSyncPlugin,N as convertRouteToWorkbox,G as checkWorkboxEnabled};
+export {
+  generateServiceWorker,
+  generateServiceWorkerAuto,
+  getServiceWorkerFileName,
+  isWorkboxEnabled
+} from "./service-worker.js";
+export {
+  generateWorkboxConfig,
+  generateWorkboxServiceWorker,
+  isWorkboxEnabled as checkWorkboxEnabled,
+  getServiceWorkerGenerator
+} from "./workbox.js";
+export {
+  mapStrategyToWorkbox,
+  getWorkboxStrategyName,
+  generateRuntimeCachingCode,
+  generatePatternMatcher,
+  convertRouteToWorkbox,
+  generateRuntimeCaching,
+  createExpirationPlugin,
+  createCacheableResponsePlugin,
+  createBackgroundSyncPlugin
+} from "./workbox-strategies.js";
+export {
+  generateManifest
+} from "./manifest.js";
+export {
+  generatePwaIcons
+} from "./icons.js";
+export {
+  generatePrecacheManifest,
+  generatePrecacheManifestJs,
+  formatSize
+} from "./precache.js";
+export {
+  generateOfflinePage
+} from "./offline.js";
+export {
+  injectPwaTags,
+  generateSwRegistrationScript
+} from "./inject.js";
+export {
+  runPwaAudit
+} from "./audit.js";
+export {
+  pwaDirectives
+} from "./directives.js";

package/dist/pwa/inject.js

@@ -1,2 +1,102 @@
-// @bun
-import{He as a,Ie as b,Je as c,Ke as d,Le as e}from"../chunk-azkegjd8.js";import"../chunk-psc3wfcf.js";import"../chunk-yj4x5ehw.js";import"../chunk-nd9rmddh.js";import"../chunk-xv34zbp4.js";export{b as injectPwaTags,e as generateThemeColorMeta,c as generateSwRegistrationScript,a as generatePwaTags,d as generateManifestLink};
+import { getServiceWorkerFileName } from "./service-worker.js";
+export function generatePwaTags(options) {
+  const pwa = options.pwa;
+  if (!pwa?.enabled)
+    return "";
+  const manifest = pwa.manifest, iconsDir = pwa.icons?.outputDir ? `/${pwa.icons.outputDir}` : "/pwa-icons", swFileName = getServiceWorkerFileName(options);
+  let tags = `
+<!-- stx PWA Meta Tags -->
+<link rel="manifest" href="/manifest.json">
+<meta name="theme-color" content="${escapeHtml(manifest?.themeColor || "#000000")}">
+<meta name="mobile-web-app-capable" content="yes">
+<meta name="apple-mobile-web-app-capable" content="yes">
+<meta name="apple-mobile-web-app-status-bar-style" content="default">
+<meta name="apple-mobile-web-app-title" content="${escapeHtml(manifest?.shortName || manifest?.name || "App")}">`;
+  if (pwa.icons?.generateAppleIcons !== !1)
+    tags += `
+<link rel="apple-touch-icon" href="${iconsDir}/apple-touch-icon.png">
+<link rel="apple-touch-icon" sizes="120x120" href="${iconsDir}/apple-touch-icon-120x120.png">
+<link rel="apple-touch-icon" sizes="152x152" href="${iconsDir}/apple-touch-icon-152x152.png">
+<link rel="apple-touch-icon" sizes="167x167" href="${iconsDir}/apple-touch-icon-167x167.png">
+<link rel="apple-touch-icon" sizes="180x180" href="${iconsDir}/apple-touch-icon-180x180.png">`;
+  tags += `
+<link rel="icon" type="image/png" sizes="32x32" href="${iconsDir}/favicon-32x32.png">
+<link rel="icon" type="image/png" sizes="16x16" href="${iconsDir}/favicon-16x16.png">
+<link rel="icon" type="image/png" sizes="192x192" href="${iconsDir}/icon-192x192.png">`;
+  tags += `
+<!-- stx Service Worker Registration -->
+<script>
+if ('serviceWorker' in navigator) {
+  window.addEventListener('load', function() {
+    navigator.serviceWorker.register('/${swFileName}')
+      .then(function(registration) {
+        console.log('[PWA] Service Worker registered:', registration.scope);
+
+        // Check for updates
+        registration.addEventListener('updatefound', function() {
+          const newWorker = registration.installing;
+          if (newWorker) {
+            newWorker.addEventListener('statechange', function() {
+              if (newWorker.state === 'installed' && navigator.serviceWorker.controller) {
+                console.log('[PWA] New content available, refresh to update');
+                // Optionally dispatch a custom event for UI notification
+                window.dispatchEvent(new CustomEvent('pwa-update-available'));
+              }
+            });
+          }
+        });
+      })
+      .catch(function(error) {
+        console.error('[PWA] Service Worker registration failed:', error);
+      });
+  });
+}
+</script>
+<!-- End stx PWA -->`;
+  return tags;
+}
+export function injectPwaTags(html, options) {
+  const pwa = options.pwa;
+  if (!pwa?.enabled || pwa.autoInject === !1)
+    return html;
+  if (html.includes("<!-- stx PWA Meta Tags -->"))
+    return html;
+  if (!html.includes("</head>")) {
+    const pwaBodyIdx = html.lastIndexOf("</body>");
+    if (pwaBodyIdx !== -1) {
+      const pwaTags = generatePwaTags(options);
+      return html.slice(0, pwaBodyIdx) + pwaTags + `
+` + html.slice(pwaBodyIdx);
+    }
+    return html + generatePwaTags(options);
+  }
+  const pwaTags = generatePwaTags(options);
+  return html.replace("</head>", `${pwaTags}
+</head>`);
+}
+export function generateSwRegistrationScript(options) {
+  if (!options.pwa?.enabled)
+    return "";
+  return `<script>
+if ('serviceWorker' in navigator) {
+  window.addEventListener('load', function() {
+    navigator.serviceWorker.register('/${getServiceWorkerFileName(options)}')
+      .then(function(registration) {
+        console.log('[PWA] Service Worker registered:', registration.scope);
+      })
+      .catch(function(error) {
+        console.error('[PWA] Service Worker registration failed:', error);
+      });
+  });
+}
+</script>`;
+}
+export function generateManifestLink() {
+  return '<link rel="manifest" href="/manifest.json">';
+}
+export function generateThemeColorMeta(color) {
+  return `<meta name="theme-color" content="${escapeHtml(color)}">`;
+}
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}

package/dist/pwa/manifest.js

@@ -1,2 +1,186 @@
-// @bun
-import{ef as a,ff as b,gf as c,hf as d}from"../chunk-c7jg8w13.js";import"../chunk-xv34zbp4.js";export{d as validateManifest,c as mergeManifestConfig,b as generateManifestJson,a as generateManifest};
+function generateManifestIcons(iconSizes, iconsDir, generateWebP, purpose) {
+  const icons = [], purposeStr = purpose.join(" ");
+  for (const size of iconSizes) {
+    icons.push({
+      src: `${iconsDir}/icon-${size}x${size}.png`,
+      sizes: `${size}x${size}`,
+      type: "image/png",
+      purpose: purposeStr
+    });
+    if (generateWebP)
+      icons.push({
+        src: `${iconsDir}/icon-${size}x${size}.webp`,
+        sizes: `${size}x${size}`,
+        type: "image/webp",
+        purpose: purposeStr
+      });
+  }
+  return icons;
+}
+function transformShortcuts(shortcuts) {
+  return shortcuts.map((shortcut) => ({
+    name: shortcut.name,
+    short_name: shortcut.shortName,
+    description: shortcut.description,
+    url: shortcut.url,
+    icons: shortcut.icons?.map((icon) => ({
+      src: icon.src,
+      sizes: icon.sizes,
+      type: icon.type
+    }))
+  }));
+}
+function generateShareTarget(options) {
+  const shareConfig = options.pwa?.shareTarget;
+  if (!shareConfig?.enabled)
+    return;
+  const shareTarget = {
+    action: shareConfig.action || "/share",
+    method: shareConfig.method || "POST",
+    enctype: shareConfig.enctype || "multipart/form-data",
+    params: {
+      title: shareConfig.params?.title || "title",
+      text: shareConfig.params?.text || "text",
+      url: shareConfig.params?.url || "url"
+    }
+  };
+  if (shareConfig.acceptFiles && shareConfig.acceptFiles.length > 0)
+    shareTarget.params.files = shareConfig.acceptFiles.map((accept) => ({
+      name: accept.name,
+      accept: accept.accept
+    }));
+  return shareTarget;
+}
+function generateFileHandlers(options) {
+  const fileConfig = options.pwa?.fileHandlers;
+  if (!fileConfig?.enabled || !fileConfig.accept)
+    return;
+  const fileHandlers = [{
+    action: fileConfig.action || "/",
+    accept: fileConfig.accept,
+    launch_type: fileConfig.launchType || "single-client"
+  }];
+  if (fileConfig.icons)
+    fileHandlers[0].icons = fileConfig.icons.map((icon) => ({
+      src: icon.src,
+      sizes: icon.sizes,
+      type: icon.type
+    }));
+  return fileHandlers;
+}
+function generateProtocolHandlers(options) {
+  const protocols = options.pwa?.protocolHandlers;
+  if (!protocols || protocols.length === 0)
+    return;
+  return protocols.map((handler) => ({
+    protocol: handler.protocol,
+    url: handler.url
+  }));
+}
+export function generateManifest(options) {
+  const pwa = options.pwa;
+  if (!pwa?.enabled || !pwa.manifest)
+    return null;
+  const { manifest, icons: iconConfig } = pwa, iconSizes = iconConfig?.sizes || [72, 96, 128, 144, 152, 192, 384, 512], iconsDir = iconConfig?.outputDir ? `/${iconConfig.outputDir}` : "/pwa-icons", generateWebP = iconConfig?.generateWebP ?? !0, purpose = iconConfig?.purpose || ["any", "maskable"], webAppManifest = {
+    name: manifest.name,
+    short_name: manifest.shortName || manifest.name,
+    description: manifest.description,
+    start_url: manifest.startUrl || "/",
+    display: manifest.display || "standalone",
+    display_override: manifest.displayOverride,
+    orientation: manifest.orientation,
+    theme_color: manifest.themeColor,
+    background_color: manifest.backgroundColor,
+    scope: manifest.scope || "/",
+    lang: manifest.lang,
+    dir: manifest.dir,
+    id: manifest.id,
+    categories: manifest.categories,
+    icons: generateManifestIcons(iconSizes, iconsDir, generateWebP, purpose)
+  };
+  if (manifest.shortcuts && manifest.shortcuts.length > 0)
+    webAppManifest.shortcuts = transformShortcuts(manifest.shortcuts);
+  if (manifest.screenshots && manifest.screenshots.length > 0)
+    webAppManifest.screenshots = manifest.screenshots.map((screenshot) => ({
+      src: screenshot.src,
+      sizes: screenshot.sizes,
+      type: screenshot.type,
+      label: screenshot.label,
+      form_factor: screenshot.platform
+    }));
+  const shareTarget = generateShareTarget(options);
+  if (shareTarget)
+    webAppManifest.share_target = shareTarget;
+  const fileHandlers = generateFileHandlers(options);
+  if (fileHandlers)
+    webAppManifest.file_handlers = fileHandlers;
+  const protocolHandlers = generateProtocolHandlers(options);
+  if (protocolHandlers)
+    webAppManifest.protocol_handlers = protocolHandlers;
+  if (manifest.launchHandler)
+    webAppManifest.launch_handler = {
+      client_mode: manifest.launchHandler
+    };
+  if (manifest.handleLinks)
+    webAppManifest.handle_links = manifest.handleLinks;
+  if (manifest.edgeSidePanel?.enabled)
+    webAppManifest.edge_side_panel = {
+      preferred_width: manifest.edgeSidePanel.preferredWidth
+    };
+  return webAppManifest;
+}
+export function generateManifestJson(options) {
+  const manifest = generateManifest(options);
+  if (!manifest)
+    return "";
+  const cleanManifest = JSON.parse(JSON.stringify(manifest));
+  return JSON.stringify(cleanManifest, null, 2);
+}
+export function mergeManifestConfig(userConfig, defaultConfig) {
+  return {
+    ...defaultConfig,
+    ...userConfig,
+    shortcuts: userConfig.shortcuts || defaultConfig.shortcuts,
+    screenshots: userConfig.screenshots || defaultConfig.screenshots,
+    categories: userConfig.categories || defaultConfig.categories
+  };
+}
+export function validateManifest(options) {
+  const errors = [], pwa = options.pwa;
+  if (!pwa?.enabled)
+    return errors;
+  const manifest = pwa.manifest;
+  if (!manifest) {
+    errors.push("PWA manifest configuration is missing");
+    return errors;
+  }
+  if (!manifest.name)
+    errors.push("Manifest name is required");
+  const validDisplayModes = ["fullscreen", "standalone", "minimal-ui", "browser"];
+  if (manifest.display && !validDisplayModes.includes(manifest.display))
+    errors.push(`Invalid display mode: ${manifest.display}. Must be one of: ${validDisplayModes.join(", ")}`);
+  const validOrientations = ["any", "natural", "landscape", "landscape-primary", "landscape-secondary", "portrait", "portrait-primary", "portrait-secondary"];
+  if (manifest.orientation && !validOrientations.includes(manifest.orientation))
+    errors.push(`Invalid orientation: ${manifest.orientation}`);
+  const hexColorRegex = /^#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$/;
+  if (manifest.themeColor && !hexColorRegex.test(manifest.themeColor))
+    errors.push(`Invalid theme color: ${manifest.themeColor}. Must be a valid hex color.`);
+  if (manifest.backgroundColor && !hexColorRegex.test(manifest.backgroundColor))
+    errors.push(`Invalid background color: ${manifest.backgroundColor}. Must be a valid hex color.`);
+  if (pwa.shareTarget?.enabled) {
+    if (!pwa.shareTarget.action)
+      errors.push("Share target action URL is required");
+  }
+  if (pwa.fileHandlers?.enabled) {
+    if (!pwa.fileHandlers.accept || Object.keys(pwa.fileHandlers.accept).length === 0)
+      errors.push("File handlers must specify accepted MIME types");
+  }
+  if (pwa.protocolHandlers)
+    for (const handler of pwa.protocolHandlers) {
+      if (!handler.protocol)
+        errors.push("Protocol handler missing protocol");
+      if (!handler.url || !handler.url.includes("%s"))
+        errors.push(`Protocol handler URL must contain %s placeholder: ${handler.protocol}`);
+    }
+  return errors;
+}