@ohos-ports/stacksjs-stx 0.2.287-beta.0

package/dist/pwa/inject.js

@@ -0,0 +1,102 @@
+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.d.ts

@@ -0,0 +1,104 @@
+import type { PwaManifestConfig, StxOptions } from '../types';
+/**
+ * Generate a Web App Manifest object from configuration
+ */
+export declare function generateManifest(options: StxOptions): WebAppManifest | null;
+/**
+ * Generate manifest.json file content as a string
+ */
+export declare function generateManifestJson(options: StxOptions): string;
+/**
+ * Merge user manifest config with defaults
+ */
+export declare function mergeManifestConfig(userConfig: Partial<PwaManifestConfig>, defaultConfig: PwaManifestConfig): PwaManifestConfig;
+/**
+ * Validate manifest configuration
+ * Returns an array of validation errors
+ */
+export declare function validateManifest(options: StxOptions): string[];
+/**
+ * Manifest icon entry structure
+ */
+export declare interface ManifestIcon {
+  src: string
+  sizes: string
+  type: string
+  purpose?: string
+}
+/**
+ * Share target entry structure
+ */
+export declare interface ManifestShareTarget {
+  action: string
+  method?: 'GET' | 'POST'
+  enctype?: string
+  params: {
+    title?: string
+    text?: string
+    url?: string
+    files?: Array<{
+      name: string
+      accept: string[]
+    }>
+  }
+}
+/**
+ * File handler entry structure
+ */
+export declare interface ManifestFileHandler {
+  action: string
+  accept: Record<string, string[]>
+  icons?: ManifestIcon[]
+  launch_type?: 'single-client' | 'multiple-clients'
+}
+/**
+ * Protocol handler entry structure
+ */
+export declare interface ManifestProtocolHandler {
+  protocol: string
+  url: string
+}
+/**
+ * Complete Web App Manifest structure
+ */
+export declare interface WebAppManifest {
+  name: string
+  short_name?: string
+  description?: string
+  start_url: string
+  display: string
+  display_override?: string[]
+  orientation?: string
+  theme_color?: string
+  background_color?: string
+  scope?: string
+  lang?: string
+  dir?: string
+  id?: string
+  categories?: string[]
+  icons: ManifestIcon[]
+  shortcuts?: Array<{
+    name: string
+    short_name?: string
+    description?: string
+    url: string
+    icons?: ManifestIcon[]
+  }>
+  screenshots?: Array<{
+    src: string
+    sizes: string
+    type?: string
+    label?: string
+    form_factor?: 'wide' | 'narrow'
+  }>
+  share_target?: ManifestShareTarget
+  file_handlers?: ManifestFileHandler[]
+  protocol_handlers?: ManifestProtocolHandler[]
+  launch_handler?: {
+    client_mode: 'auto' | 'focus-existing' | 'navigate-new' | 'navigate-existing'
+  }
+  handle_links?: 'auto' | 'preferred' | 'not-preferred'
+  edge_side_panel?: {
+    preferred_width?: number
+  }
+}

package/dist/pwa/manifest.js

@@ -0,0 +1,186 @@
+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;
+}

package/dist/pwa/offline.d.ts

@@ -0,0 +1,8 @@
+import type { StxOptions } from '../types';
+/**
+ * Generate offline fallback page HTML
+ *
+ * If a custom offline page is specified in config, it will be processed.
+ * Otherwise, a default styled offline page is generated.
+ */
+export declare function generateOfflinePage(options: StxOptions): Promise<string>;

package/dist/pwa/offline.js

@@ -0,0 +1,259 @@
+import path from "node:path";
+export async function generateOfflinePage(options) {
+  const offlineConfig = options.pwa?.offline;
+  if (!offlineConfig?.enabled)
+    return "";
+  if (offlineConfig.page) {
+    const offlinePath = path.isAbsolute(offlineConfig.page) ? offlineConfig.page : path.resolve(process.cwd(), offlineConfig.page);
+    if (await Bun.file(offlinePath).exists())
+      try {
+        const { processDirectives } = await import("../process.js"), content = await Bun.file(offlinePath).text();
+        return await processDirectives(content, {}, offlinePath, options, new Set);
+      } catch (error) {
+        console.warn(`[PWA] Failed to process custom offline page: ${error}`);
+      }
+    else
+      console.warn(`[PWA] Custom offline page not found: ${offlinePath}`);
+  }
+  return generateDefaultOfflinePage(options);
+}
+function generateDefaultOfflinePage(options) {
+  const offlineConfig = options.pwa?.offline, manifest = options.pwa?.manifest, title = offlineConfig?.fallbackTitle || "You are offline", message = offlineConfig?.fallbackMessage || "Please check your internet connection and try again.", themeColor = manifest?.themeColor || "#4f46e5", appName = manifest?.shortName || manifest?.name || "App";
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <meta name="theme-color" content="${themeColor}">
+  <title>${escapeHtml(title)} - ${escapeHtml(appName)}</title>
+  <style>
+    :root {
+      --theme-color: ${themeColor};
+      --text-primary: #1a1a2e;
+      --text-secondary: #666;
+      --bg-gradient-start: #f5f7fa;
+      --bg-gradient-end: #c3cfe2;
+    }
+
+    @media (prefers-color-scheme: dark) {
+      :root {
+        --text-primary: #f0f0f0;
+        --text-secondary: #a0a0a0;
+        --bg-gradient-start: #1a1a2e;
+        --bg-gradient-end: #16213e;
+      }
+    }
+
+    * {
+      margin: 0;
+      padding: 0;
+      box-sizing: border-box;
+    }
+
+    body {
+      font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, Cantarell, sans-serif;
+      min-height: 100vh;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      background: linear-gradient(135deg, var(--bg-gradient-start) 0%, var(--bg-gradient-end) 100%);
+      padding: 20px;
+    }
+
+    .offline-container {
+      text-align: center;
+      max-width: 400px;
+      padding: 48px 40px;
+      background: white;
+      border-radius: 20px;
+      box-shadow: 0 20px 60px rgba(0, 0, 0, 0.15);
+    }
+
+    @media (prefers-color-scheme: dark) {
+      .offline-container {
+        background: #242438;
+        box-shadow: 0 20px 60px rgba(0, 0, 0, 0.4);
+      }
+    }
+
+    .offline-icon {
+      width: 96px;
+      height: 96px;
+      margin-bottom: 28px;
+      color: var(--theme-color);
+      animation: float 3s ease-in-out infinite;
+    }
+
+    @keyframes float {
+      0%, 100% { transform: translateY(0); }
+      50% { transform: translateY(-10px); }
+    }
+
+    h1 {
+      font-size: 28px;
+      font-weight: 700;
+      color: var(--text-primary);
+      margin-bottom: 16px;
+      letter-spacing: -0.5px;
+    }
+
+    p {
+      color: var(--text-secondary);
+      line-height: 1.7;
+      margin-bottom: 32px;
+      font-size: 16px;
+    }
+
+    .retry-btn {
+      display: inline-flex;
+      align-items: center;
+      gap: 8px;
+      padding: 14px 36px;
+      background: var(--theme-color);
+      color: white;
+      border: none;
+      border-radius: 12px;
+      font-size: 16px;
+      font-weight: 600;
+      cursor: pointer;
+      transition: transform 0.2s, box-shadow 0.2s, background 0.2s;
+    }
+
+    .retry-btn:hover {
+      transform: translateY(-2px);
+      box-shadow: 0 8px 20px rgba(79, 70, 229, 0.35);
+    }
+
+    .retry-btn:active {
+      transform: translateY(0);
+    }
+
+    .retry-btn svg {
+      width: 18px;
+      height: 18px;
+    }
+
+    .status-indicator {
+      margin-top: 24px;
+      padding: 10px 16px;
+      background: rgba(255, 193, 7, 0.1);
+      border-radius: 8px;
+      font-size: 14px;
+      color: #b8860b;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      gap: 8px;
+    }
+
+    @media (prefers-color-scheme: dark) {
+      .status-indicator {
+        background: rgba(255, 193, 7, 0.15);
+        color: #ffc107;
+      }
+    }
+
+    .status-dot {
+      width: 8px;
+      height: 8px;
+      background: #ffc107;
+      border-radius: 50%;
+      animation: pulse 2s infinite;
+    }
+
+    @keyframes pulse {
+      0%, 100% { opacity: 1; }
+      50% { opacity: 0.5; }
+    }
+
+    .online .status-indicator {
+      background: rgba(40, 167, 69, 0.1);
+      color: #28a745;
+    }
+
+    @media (prefers-color-scheme: dark) {
+      .online .status-indicator {
+        background: rgba(40, 167, 69, 0.15);
+      }
+    }
+
+    .online .status-dot {
+      background: #28a745;
+      animation: none;
+    }
+  </style>
+</head>
+<body>
+  <div class="offline-container" id="container">
+    <svg class="offline-icon" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round">
+      <path d="M1 1l22 22"/>
+      <path d="M16.72 11.06A10.94 10.94 0 0 1 19 12.55"/>
+      <path d="M5 12.55a10.94 10.94 0 0 1 5.17-2.39"/>
+      <path d="M10.71 5.05A16 16 0 0 1 22.58 9"/>
+      <path d="M1.42 9a15.91 15.91 0 0 1 4.7-2.88"/>
+      <path d="M8.53 16.11a6 6 0 0 1 6.95 0"/>
+      <circle cx="12" cy="20" r="1"/>
+    </svg>
+
+    <h1>${escapeHtml(title)}</h1>
+    <p>${escapeHtml(message)}</p>
+
+    <button class="retry-btn" onclick="window.location.reload()">
+      <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+        <polyline points="23 4 23 10 17 10"></polyline>
+        <path d="M20.49 15a9 9 0 1 1-2.12-9.36L23 10"></path>
+      </svg>
+      Try Again
+    </button>
+
+    <div class="status-indicator">
+      <span class="status-dot"></span>
+      <span id="status-text">Waiting for connection...</span>
+    </div>
+  </div>
+
+  <script>
+    // Update status and auto-reload when online
+    var reloadTimeout = null;
+    var checkInterval = null;
+
+    function updateStatus() {
+      var container = document.getElementById('container');
+      var statusText = document.getElementById('status-text');
+
+      if (navigator.onLine) {
+        container.classList.add('online');
+        statusText.textContent = 'Back online! Reloading...';
+        if (!reloadTimeout) {
+          if (checkInterval) { clearInterval(checkInterval); checkInterval = null; }
+          reloadTimeout = setTimeout(function() { window.location.reload(); }, 1000);
+        }
+      }
+      else {
+        container.classList.remove('online');
+        statusText.textContent = 'Waiting for connection...';
+        if (reloadTimeout) { clearTimeout(reloadTimeout); reloadTimeout = null; }
+      }
+    }
+
+    window.addEventListener('online', updateStatus);
+    window.addEventListener('offline', updateStatus);
+
+    // Initial check
+    updateStatus();
+
+    // Periodic check every 5 seconds
+    checkInterval = setInterval(function() {
+      if (!navigator.onLine) {
+        fetch('/', { method: 'HEAD', cache: 'no-store' })
+          .then(function() { updateStatus(); })
+          .catch(function() { /* Still offline */ });
+      }
+    }, 5000);
+  </script>
+</body>
+</html>`;
+}
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}

package/dist/pwa/precache.d.ts

@@ -0,0 +1,35 @@
+/**
+ * PWA Auto-Precaching
+ *
+ * Automatically discovers and precaches build output files.
+ * Scans the output directory and generates a precache manifest.
+ */
+import type { StxOptions } from '../types';
+/**
+ * Precache manifest entry
+ */
+export interface PrecacheEntry {
+    url: string;
+    revision: string;
+    size: number;
+}
+/**
+ * Precache manifest result
+ */
+export interface PrecacheManifest {
+    entries: PrecacheEntry[];
+    totalSize: number;
+    fileCount: number;
+}
+/**
+ * Generate precache manifest from build output directory
+ */
+export declare function generatePrecacheManifest(outputDir: string, options: StxOptions): PrecacheManifest;
+/**
+ * Generate precache manifest as JavaScript array for service worker
+ */
+export declare function generatePrecacheManifestJs(manifest: PrecacheManifest): string;
+/**
+ * Get human-readable size
+ */
+export declare function formatSize(bytes: number): string;