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

package/dist/defer.js

@@ -0,0 +1,156 @@
+let deferCounter = 0;
+function generateDeferId() {
+  return `stx-defer-${++deferCounter}`;
+}
+function parseDeferTrigger(args) {
+  const onMatch = args.match(/on:\s*['"]?(\w+)(?:\((\d+)\))?['"]?/);
+  if (onMatch)
+    return {
+      trigger: onMatch[1],
+      value: onMatch[2]
+    };
+  return { trigger: "immediate" };
+}
+function parseDeferBlock(fullMatch, args, body) {
+  const { trigger, value } = parseDeferTrigger(args);
+  let content = body, placeholder, loading, error;
+  const placeholderMatch = body.match(/@placeholder\s*([\s\S]*?)(?=@loading|@error|$)/);
+  if (placeholderMatch) {
+    placeholder = placeholderMatch[1].trim();
+    content = content.replace(/@placeholder[\s\S]*?(?=@loading|@error|$)/, "");
+  }
+  const loadingMatch = body.match(/@loading\s*([\s\S]*?)(?=@error|$)/);
+  if (loadingMatch) {
+    loading = loadingMatch[1].trim();
+    content = content.replace(/@loading[\s\S]*?(?=@error|$)/, "");
+  }
+  const errorMatch = body.match(/@error(?:\s*\(\s*(\w+)\s*\))?\s*([\s\S]*)$/);
+  if (errorMatch) {
+    error = errorMatch[2].trim();
+    content = content.replace(/@error(?:\s*\(\s*\w+\s*\))?[\s\S]*$/, "");
+  }
+  content = content.trim();
+  return {
+    trigger,
+    triggerValue: value,
+    content,
+    placeholder,
+    loading,
+    error
+  };
+}
+function generateDeferScript(id, block) {
+  const { trigger, triggerValue } = block;
+  let triggerCode;
+  switch (trigger) {
+    case "visible":
+      triggerCode = `
+        const observer = new IntersectionObserver((entries) => {
+          if (entries[0].isIntersecting) {
+            observer.disconnect();
+            loadContent();
+          }
+        }, { threshold: 0.1 });
+        observer.observe(container);
+      `;
+      break;
+    case "idle":
+      triggerCode = `
+        if ('requestIdleCallback' in window) {
+          requestIdleCallback(() => loadContent(), { timeout: 3000 });
+        }
+else {
+          setTimeout(loadContent, 200);
+        }
+      `;
+      break;
+    case "interaction":
+      triggerCode = `
+        const events = ['click', 'focus', 'touchstart'];
+        const handler = () => {
+          events.forEach(e => container.removeEventListener(e, handler));
+          loadContent();
+        };
+        events.forEach(e => container.addEventListener(e, handler, { once: true, passive: true }));
+      `;
+      break;
+    case "hover":
+      triggerCode = `
+        const handler = () => {
+          container.removeEventListener('mouseenter', handler);
+          container.removeEventListener('focusin', handler);
+          loadContent();
+        };
+        container.addEventListener('mouseenter', handler, { once: true });
+        container.addEventListener('focusin', handler, { once: true });
+      `;
+      break;
+    case "timer":
+      triggerCode = `
+        setTimeout(loadContent, ${triggerValue || "1000"});
+      `;
+      break;
+    case "immediate":
+    default:
+      triggerCode = `
+        Promise.resolve().then(loadContent);
+      `;
+      break;
+  }
+  return `
+    <script>
+    (function() {
+      const container = document.getElementById('${id}');
+      if (!container) return;
+
+      const contentEl = container.querySelector('[data-defer-content]');
+      const placeholderEl = container.querySelector('[data-defer-placeholder]');
+      const loadingEl = container.querySelector('[data-defer-loading]');
+      const errorEl = container.querySelector('[data-defer-error]');
+
+      function showElement(el) {
+        if (el) el.style.display = '';
+      }
+      function hideElement(el) {
+        if (el) el.style.display = 'none';
+      }
+
+      function loadContent() {
+        hideElement(placeholderEl);
+        showElement(loadingEl);
+
+        // Simulate async load (content is already rendered but hidden)
+        Promise.resolve().then(() => {
+          hideElement(loadingEl);
+          showElement(contentEl);
+          container.dispatchEvent(new CustomEvent('defer:loaded'));
+        }).catch((err) => {
+          hideElement(loadingEl);
+          if (errorEl) {
+            showElement(errorEl);
+          }
+          console.error('Defer load error:', err);
+        });
+      }
+
+      ${triggerCode}
+    })();
+    </script>
+  `;
+}
+export function processDeferDirectives(template, _context, _filePath) {
+  deferCounter = 0;
+  const deferRegex = /@defer\s*\(([^)]*)\)\s*([\s\S]*?)@enddefer/g;
+  return template.replace(deferRegex, (fullMatch, args, body) => {
+    const id = generateDeferId(), block = parseDeferBlock(fullMatch, args, body), placeholderHtml = block.placeholder ? `<div data-defer-placeholder>${block.placeholder}</div>` : "", loadingHtml = block.loading ? `<div data-defer-loading style="display: none;">${block.loading}</div>` : '<div data-defer-loading style="display: none;"></div>', errorHtml = block.error ? `<div data-defer-error style="display: none;">${block.error}</div>` : "", contentHtml = `<div data-defer-content style="display: none;">${block.content}</div>`, script = generateDeferScript(id, block);
+    return `
+      <div id="${id}" class="stx-defer" data-defer-trigger="${block.trigger}">
+        ${placeholderHtml}
+        ${loadingHtml}
+        ${contentHtml}
+        ${errorHtml}
+      </div>
+      ${script}
+    `;
+  });
+}

package/dist/deploy/config-generators.d.ts

@@ -0,0 +1,75 @@
+import path from 'node:path';
+/**
+ * Generate netlify.toml content from config
+ */
+export declare function generateNetlifyToml(config: NetlifyConfig): string;
+/**
+ * Detect project configuration from filesystem
+ */
+export declare function detectProjectConfig(directory: string): Promise<ProjectConfig>;
+/**
+ * Generate default Netlify config for an stx project
+ */
+export declare function createDefaultNetlifyConfig(projectConfig?: ProjectConfig): NetlifyConfig;
+/**
+ * Write netlify.toml to a directory
+ */
+export declare function writeNetlifyConfig(directory: string, config?: NetlifyConfig): Promise<string>;
+/**
+ * Check if netlify.toml exists
+ */
+export declare function hasNetlifyConfig(directory: string): boolean;
+/**
+ * Read existing netlify.toml (basic parsing)
+ */
+export declare function readNetlifyConfig(directory: string): Promise<string | null>;
+// ============================================================================
+// Types
+// ============================================================================
+export declare interface NetlifyConfig {
+  build: {
+    command: string
+    publish: string
+    functions?: string
+    edge_functions?: string
+    environment?: Record<string, string>
+  }
+  functions?: {
+    directory?: string
+    node_bundler?: 'esbuild' | 'nft'
+    external_node_modules?: string[]
+  }
+  edge_functions?: Array<{
+    function: string
+    path: string
+  }>
+  redirects?: Array<{
+    from: string
+    to: string
+    status?: number
+    force?: boolean
+    conditions?: Record<string, string>
+  }>
+  headers?: Array<{
+    for: string
+    values: Record<string, string>
+  }>
+  plugins?: Array<{
+    package: string
+    inputs?: Record<string, unknown>
+  }>
+  context?: Record<string, {
+    command?: string
+    publish?: string
+    environment?: Record<string, string>
+  }>
+}
+export declare interface ProjectConfig {
+  framework?: 'stx' | 'static' | 'spa'
+  buildCommand?: string
+  outputDir?: string
+  functionsDir?: string
+  edgeFunctionsDir?: string
+  nodeVersion?: string
+  isSPA?: boolean
+}

package/dist/deploy/config-generators.js

@@ -0,0 +1,214 @@
+import fs from "node:fs";
+import path from "node:path";
+export function generateNetlifyToml(config) {
+  const lines = [];
+  lines.push("[build]");
+  lines.push(`  command = "${escapeTomlString(config.build.command)}"`);
+  lines.push(`  publish = "${escapeTomlString(config.build.publish)}"`);
+  if (config.build.functions)
+    lines.push(`  functions = "${escapeTomlString(config.build.functions)}"`);
+  if (config.build.edge_functions)
+    lines.push(`  edge_functions = "${escapeTomlString(config.build.edge_functions)}"`);
+  if (config.build.environment && Object.keys(config.build.environment).length > 0) {
+    lines.push("");
+    lines.push("[build.environment]");
+    for (const [key, value] of Object.entries(config.build.environment))
+      lines.push(`  ${key} = "${escapeTomlString(value)}"`);
+  }
+  if (config.functions) {
+    lines.push("");
+    lines.push("[functions]");
+    if (config.functions.directory)
+      lines.push(`  directory = "${escapeTomlString(config.functions.directory)}"`);
+    if (config.functions.node_bundler)
+      lines.push(`  node_bundler = "${config.functions.node_bundler}"`);
+    if (config.functions.external_node_modules && config.functions.external_node_modules.length > 0)
+      lines.push(`  external_node_modules = [${config.functions.external_node_modules.map((m) => `"${m}"`).join(", ")}]`);
+  }
+  if (config.edge_functions && config.edge_functions.length > 0) {
+    lines.push("");
+    for (const ef of config.edge_functions) {
+      lines.push("[[edge_functions]]");
+      lines.push(`  function = "${escapeTomlString(ef.function)}"`);
+      lines.push(`  path = "${escapeTomlString(ef.path)}"`);
+    }
+  }
+  if (config.redirects && config.redirects.length > 0) {
+    lines.push("");
+    for (const redirect of config.redirects) {
+      lines.push("[[redirects]]");
+      lines.push(`  from = "${escapeTomlString(redirect.from)}"`);
+      lines.push(`  to = "${escapeTomlString(redirect.to)}"`);
+      if (redirect.status !== void 0)
+        lines.push(`  status = ${redirect.status}`);
+      if (redirect.force !== void 0)
+        lines.push(`  force = ${redirect.force}`);
+      if (redirect.conditions && Object.keys(redirect.conditions).length > 0) {
+        lines.push("  [redirects.conditions]");
+        for (const [key, value] of Object.entries(redirect.conditions))
+          lines.push(`    ${key} = "${escapeTomlString(value)}"`);
+      }
+    }
+  }
+  if (config.headers && config.headers.length > 0) {
+    lines.push("");
+    for (const header of config.headers) {
+      lines.push("[[headers]]");
+      lines.push(`  for = "${escapeTomlString(header.for)}"`);
+      lines.push("  [headers.values]");
+      for (const [key, value] of Object.entries(header.values))
+        lines.push(`    ${key} = "${escapeTomlString(value)}"`);
+    }
+  }
+  if (config.plugins && config.plugins.length > 0) {
+    lines.push("");
+    for (const plugin of config.plugins) {
+      lines.push("[[plugins]]");
+      lines.push(`  package = "${escapeTomlString(plugin.package)}"`);
+      if (plugin.inputs && Object.keys(plugin.inputs).length > 0) {
+        lines.push("  [plugins.inputs]");
+        for (const [key, value] of Object.entries(plugin.inputs))
+          if (typeof value === "string")
+            lines.push(`    ${key} = "${escapeTomlString(value)}"`);
+          else if (typeof value === "boolean" || typeof value === "number")
+            lines.push(`    ${key} = ${value}`);
+      }
+    }
+  }
+  if (config.context && Object.keys(config.context).length > 0)
+    for (const [contextName, contextConfig] of Object.entries(config.context)) {
+      lines.push("");
+      lines.push(`[context.${contextName}]`);
+      if (contextConfig.command)
+        lines.push(`  command = "${escapeTomlString(contextConfig.command)}"`);
+      if (contextConfig.publish)
+        lines.push(`  publish = "${escapeTomlString(contextConfig.publish)}"`);
+      if (contextConfig.environment && Object.keys(contextConfig.environment).length > 0) {
+        lines.push(`  [context.${contextName}.environment]`);
+        for (const [key, value] of Object.entries(contextConfig.environment))
+          lines.push(`    ${key} = "${escapeTomlString(value)}"`);
+      }
+    }
+  return lines.join(`
+`) + `
+`;
+}
+function escapeTomlString(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, "\\\"").replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+}
+export async function detectProjectConfig(directory) {
+  const config = {
+    framework: "stx",
+    buildCommand: "bun run build",
+    outputDir: "dist"
+  }, packageJsonPath = path.join(directory, "package.json");
+  if (await Bun.file(packageJsonPath).exists())
+    try {
+      const packageJson = JSON.parse(await Bun.file(packageJsonPath).text());
+      if (packageJson.scripts?.build)
+        config.buildCommand = "bun run build";
+      const deps = {
+        ...packageJson.dependencies,
+        ...packageJson.devDependencies
+      };
+      if (deps["@stacksjs/stx"] || deps.stx)
+        config.framework = "stx";
+    } catch {}
+  const stxConfigPath = path.join(directory, "stx.config.ts"), stxConfigAltPath = path.join(directory, ".config", "stx.config.ts");
+  if (await Bun.file(stxConfigPath).exists() || await Bun.file(stxConfigAltPath).exists())
+    config.framework = "stx";
+  const possibleOutputDirs = ["dist", "build", "out", "public", ".output"];
+  for (const dir of possibleOutputDirs) {
+    const fullPath = path.join(directory, dir);
+    if (fs.existsSync(fullPath) && fs.statSync(fullPath).isDirectory()) {
+      config.outputDir = dir;
+      break;
+    }
+  }
+  const possibleFunctionsDirs = ["functions", "netlify/functions", "api"];
+  for (const dir of possibleFunctionsDirs) {
+    const fullPath = path.join(directory, dir);
+    if (fs.existsSync(fullPath) && fs.statSync(fullPath).isDirectory()) {
+      config.functionsDir = dir;
+      break;
+    }
+  }
+  const edgeFunctionsDir = path.join(directory, "netlify", "edge-functions");
+  if (fs.existsSync(edgeFunctionsDir))
+    config.edgeFunctionsDir = "netlify/edge-functions";
+  const distPath = path.join(directory, config.outputDir || "dist");
+  if (fs.existsSync(distPath)) {
+    const hasIndexHtml = fs.existsSync(path.join(distPath, "index.html")), htmlFiles = fs.readdirSync(distPath).filter((f) => f.endsWith(".html"));
+    config.isSPA = hasIndexHtml && htmlFiles.length === 1;
+  }
+  return config;
+}
+export function createDefaultNetlifyConfig(projectConfig = {}) {
+  const config = {
+    build: {
+      command: projectConfig.buildCommand || "bun run build",
+      publish: projectConfig.outputDir || "dist"
+    }
+  };
+  if (projectConfig.functionsDir) {
+    config.build.functions = projectConfig.functionsDir;
+    config.functions = {
+      directory: projectConfig.functionsDir,
+      node_bundler: "esbuild"
+    };
+  }
+  if (projectConfig.edgeFunctionsDir)
+    config.build.edge_functions = projectConfig.edgeFunctionsDir;
+  config.headers = [
+    {
+      for: "/*",
+      values: {
+        "X-Frame-Options": "DENY",
+        "X-Content-Type-Options": "nosniff",
+        "X-XSS-Protection": "1; mode=block",
+        "Referrer-Policy": "strict-origin-when-cross-origin"
+      }
+    },
+    {
+      for: "/assets/*",
+      values: {
+        "Cache-Control": "public, max-age=31536000, immutable"
+      }
+    }
+  ];
+  if (projectConfig.isSPA !== !1)
+    config.redirects = [
+      {
+        from: "/*",
+        to: "/index.html",
+        status: 200
+      }
+    ];
+  config.context = {
+    production: {
+      environment: {
+        NODE_ENV: "production"
+      }
+    },
+    "deploy-preview": {
+      environment: {
+        NODE_ENV: "development"
+      }
+    }
+  };
+  return config;
+}
+export async function writeNetlifyConfig(directory, config) {
+  const projectConfig = await detectProjectConfig(directory), netlifyConfig = config || createDefaultNetlifyConfig(projectConfig), content = generateNetlifyToml(netlifyConfig), filePath = path.join(directory, "netlify.toml");
+  await Bun.write(filePath, content);
+  return filePath;
+}
+export function hasNetlifyConfig(directory) {
+  return fs.existsSync(path.join(directory, "netlify.toml"));
+}
+export async function readNetlifyConfig(directory) {
+  const filePath = path.join(directory, "netlify.toml");
+  if (!await Bun.file(filePath).exists())
+    return null;
+  return Bun.file(filePath).text();
+}

package/dist/deploy/index.d.ts

@@ -0,0 +1,88 @@
+import { createNetlifyClient, collectDeployFiles, createFileManifest, filterRequiredFiles, formatSize, getTotalSize, type NetlifyClient, type NetlifyDeploy, type DeployFile } from './netlify';
+import { detectProjectConfig, createDefaultNetlifyConfig, generateNetlifyToml, writeNetlifyConfig, hasNetlifyConfig } from './config-generators';
+export type {
+  NetlifyClient,
+  NetlifySite,
+  NetlifyDeploy,
+  DeployFile,
+} from './netlify';
+export type {
+  NetlifyConfig,
+  ProjectConfig,
+} from './config-generators';
+/**
+ * Deploy to Netlify
+ */
+export declare function deploy(config?: DeployConfig): Promise<DeployResult>;
+/**
+ * Initialize Netlify configuration for a project
+ */
+// eslint-disable-next-line pickier/no-unused-vars
+export declare function initNetlify(config?: InitConfig): Promise<{
+  configPath: string
+  siteId?: string
+}>;
+// ============================================================================
+// Types
+// ============================================================================
+export declare interface DeployConfig {
+  directory?: string
+  siteId?: string
+  token?: string
+  production?: boolean
+  message?: string
+  build?: boolean
+  open?: boolean
+  dryRun?: boolean
+  functions?: string
+  cwd?: string
+  onProgress?: (status: DeployProgress) => void
+}
+export declare interface DeployProgress {
+  stage: 'build' | 'collect' | 'upload' | 'process' | 'done' | 'error'
+  message: string
+  percent?: number
+  details?: unknown
+}
+export declare interface DeployResult {
+  success: boolean
+  url: string
+  siteUrl?: string
+  deployId: string
+  logs: string[]
+  duration: number
+  filesUploaded: number
+  totalSize: number
+}
+export declare interface InitConfig {
+  directory?: string
+  siteId?: string
+  createSite?: boolean
+  siteName?: string
+}
+// ============================================================================
+// Error Handling
+// ============================================================================
+export declare class DeployError extends Error {
+  code: string;
+  constructor(message: string, code: string);
+}
+// ============================================================================
+// Re-exports
+// ============================================================================
+export {
+  createNetlifyClient,
+  collectDeployFiles,
+  createFileManifest,
+  filterRequiredFiles,
+  formatSize,
+  getTotalSize,
+  calculateSha1,
+} from './netlify';
+export {
+  generateNetlifyToml,
+  detectProjectConfig,
+  createDefaultNetlifyConfig,
+  writeNetlifyConfig,
+  hasNetlifyConfig,
+} from './config-generators';