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

package/dist/deploy/index.js

@@ -0,0 +1,203 @@
+import fs from "node:fs";
+import path from "node:path";
+import {
+  createNetlifyClient,
+  collectDeployFiles,
+  createFileManifest,
+  filterRequiredFiles,
+  formatSize,
+  getTotalSize
+} from "./netlify.js";
+import {
+  detectProjectConfig,
+  createDefaultNetlifyConfig,
+  generateNetlifyToml,
+  writeNetlifyConfig,
+  hasNetlifyConfig
+} from "./config-generators.js";
+export async function deploy(config = {}) {
+  const startTime = Date.now(), logs = [], cwd = config.cwd || process.cwd(), log = (msg) => {
+    logs.push(msg);
+  }, progress = (status) => {
+    if (config.onProgress)
+      config.onProgress(status);
+  }, directory = path.resolve(cwd, config.directory || "dist"), token = config.token || process.env.NETLIFY_AUTH_TOKEN, siteId = config.siteId || process.env.NETLIFY_SITE_ID;
+  if (!token)
+    throw new DeployError(`No Netlify auth token found.
+
+To deploy to Netlify:
+1. Create account at https://app.netlify.com
+2. Get token at https://app.netlify.com/user/applications#personal-access-tokens
+3. Set NETLIFY_AUTH_TOKEN environment variable
+
+   export NETLIFY_AUTH_TOKEN=your_token_here`, "NO_TOKEN");
+  if (!siteId)
+    throw new DeployError(`No Netlify site ID found.
+
+Either:
+1. Set NETLIFY_SITE_ID environment variable
+2. Pass --site-id option
+3. Run \`stx deploy --init\` to set up
+
+Find your site ID at: https://app.netlify.com/sites/YOUR_SITE/settings/general`, "NO_SITE_ID");
+  if (!fs.existsSync(directory))
+    throw new DeployError(`Build directory not found: ${directory}
+
+Run \`stx build\` first or specify a different directory with --directory`, "NO_BUILD_DIR");
+  if (!(fs.readdirSync(directory).length > 0))
+    throw new DeployError(`Build directory is empty: ${directory}
+
+Run \`stx build\` to generate files`, "EMPTY_BUILD_DIR");
+  if (config.dryRun) {
+    progress({ stage: "collect", message: "Collecting files..." });
+    const files = await collectDeployFiles(directory), totalSize = getTotalSize(files);
+    log(`Would deploy ${files.length} files (${formatSize(totalSize)})`);
+    log(`From: ${directory}`);
+    log(`To: Site ${siteId}`);
+    log(`Mode: ${config.production ? "production" : "draft"}`);
+    return {
+      success: !0,
+      url: `https://${siteId}.netlify.app (dry-run)`,
+      deployId: "dry-run",
+      logs,
+      duration: Date.now() - startTime,
+      filesUploaded: files.length,
+      totalSize
+    };
+  }
+  const client = createNetlifyClient({ token });
+  progress({ stage: "collect", message: "Verifying site..." });
+  try {
+    const site = await client.getSite(siteId);
+    log(`Deploying to: ${site.name} (${site.url})`);
+  } catch (error) {
+    if (error.status === 404)
+      throw new DeployError(`Site not found: ${siteId}
+
+Check your site ID or create a new site at https://app.netlify.com`, "SITE_NOT_FOUND");
+    throw error;
+  }
+  progress({ stage: "collect", message: "Collecting files..." });
+  const files = await collectDeployFiles(directory), totalSize = getTotalSize(files);
+  log(`Found ${files.length} files (${formatSize(totalSize)})`);
+  if (files.length === 0)
+    throw new DeployError(`No files found in ${directory}`, "NO_FILES");
+  const manifest = createFileManifest(files);
+  progress({ stage: "upload", message: "Creating deploy...", percent: 0 });
+  const deployResponse = await client.createDeploy(siteId, {
+    title: config.message || "Deploy from stx CLI",
+    draft: !config.production,
+    files: manifest
+  });
+  log(`Created deploy: ${deployResponse.id}`);
+  const requiredFiles = filterRequiredFiles(files, deployResponse.required || []);
+  log(`Uploading ${requiredFiles.length} files...`);
+  if (requiredFiles.length > 0) {
+    let uploaded = 0;
+    const uploadSize = getTotalSize(requiredFiles);
+    for (const file of requiredFiles) {
+      await client.uploadFile(deployResponse.id, file.path, file.content);
+      uploaded++;
+      const percent = Math.round(uploaded / requiredFiles.length * 100);
+      progress({
+        stage: "upload",
+        message: `Uploading: ${file.path}`,
+        percent,
+        details: { uploaded, total: requiredFiles.length }
+      });
+    }
+    log(`Uploaded ${formatSize(uploadSize)}`);
+  } else
+    log("All files already on CDN (no upload needed)");
+  progress({ stage: "process", message: "Processing deploy..." });
+  const finalDeploy = await client.waitForDeploy(deployResponse.id, {
+    onProgress: (deploy) => {
+      progress({
+        stage: "process",
+        message: `Status: ${deploy.state}`,
+        details: deploy
+      });
+    }
+  }), duration = Date.now() - startTime;
+  progress({ stage: "done", message: "Deploy complete!" });
+  log(`Deploy complete in ${(duration / 1000).toFixed(1)}s`);
+  log(`URL: ${finalDeploy.deploy_ssl_url}`);
+  if (config.production)
+    log(`Site: ${finalDeploy.ssl_url}`);
+  if (config.open) {
+    const url = config.production ? finalDeploy.ssl_url : finalDeploy.deploy_ssl_url;
+    openUrl(url);
+  }
+  return {
+    success: !0,
+    url: finalDeploy.deploy_ssl_url,
+    siteUrl: config.production ? finalDeploy.ssl_url : void 0,
+    deployId: finalDeploy.id,
+    logs,
+    duration,
+    filesUploaded: requiredFiles.length,
+    totalSize: getTotalSize(requiredFiles)
+  };
+}
+export async function initNetlify(config = {}) {
+  const directory = config.directory || process.cwd();
+  let configPath;
+  if (hasNetlifyConfig(directory))
+    configPath = path.join(directory, "netlify.toml");
+  else {
+    const projectConfig = await detectProjectConfig(directory);
+    configPath = await writeNetlifyConfig(directory, createDefaultNetlifyConfig(projectConfig));
+  }
+  if (config.siteId) {
+    const envPath = path.join(directory, ".env.local");
+    let envContent = "";
+    if (await Bun.file(envPath).exists()) {
+      envContent = await Bun.file(envPath).text();
+      envContent = envContent.split(`
+`).filter((line) => !line.startsWith("NETLIFY_SITE_ID=")).join(`
+`);
+      if (envContent && !envContent.endsWith(`
+`))
+        envContent += `
+`;
+    }
+    envContent += `NETLIFY_SITE_ID=${config.siteId}
+`;
+    await Bun.write(envPath, envContent);
+  }
+  return {
+    configPath,
+    siteId: config.siteId
+  };
+}
+
+export class DeployError extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.name = "DeployError";
+    this.code = code;
+  }
+}
+function openUrl(url) {
+  const platform = process.platform, command = platform === "darwin" ? "open" : platform === "win32" ? "start" : "xdg-open";
+  Bun.spawn([command, url], {
+    stdio: ["ignore", "ignore", "ignore"]
+  });
+}
+export {
+  createNetlifyClient,
+  collectDeployFiles,
+  createFileManifest,
+  filterRequiredFiles,
+  formatSize,
+  getTotalSize,
+  calculateSha1
+} from "./netlify.js";
+export {
+  generateNetlifyToml,
+  detectProjectConfig,
+  createDefaultNetlifyConfig,
+  writeNetlifyConfig,
+  hasNetlifyConfig
+} from "./config-generators.js";

package/dist/deploy/netlify.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Create a Netlify API client
+ */
+export declare function createNetlifyClient(config: NetlifyClientConfig): NetlifyClient;
+/**
+ * Calculate SHA1 hash of file content
+ */
+export declare function calculateSha1(content: ArrayBuffer | Uint8Array): Promise<string>;
+/**
+ * Collect files from a directory for deployment
+ */
+export declare function collectDeployFiles(directory: string, options?: { ignore?: string[] }): Promise<DeployFile[]>;
+/**
+ * Create file manifest (path -> sha1 hash mapping)
+ */
+export declare function createFileManifest(files: DeployFile[]): Record<string, string>;
+/**
+ * Filter files that need uploading (not already on Netlify)
+ */
+export declare function filterRequiredFiles(files: DeployFile[], required: string[]): DeployFile[];
+/**
+ * Format file size for display
+ */
+export declare function formatSize(bytes: number): string;
+/**
+ * Get total size of files
+ */
+export declare function getTotalSize(files: DeployFile[]): number;
+// ============================================================================
+// Types
+// ============================================================================
+export declare interface NetlifySite {
+  id: string
+  name: string
+  url: string
+  ssl_url: string
+  admin_url: string
+  created_at: string
+  updated_at: string
+  custom_domain?: string
+  default_domain: string
+  deploy_url: string
+  published_deploy?: NetlifyDeploy
+}
+export declare interface NetlifyDeploy {
+  id: string
+  site_id: string
+  state: 'new' | 'pending_review' | 'uploading' | 'uploaded' | 'preparing' | 'prepared' | 'processing' | 'ready' | 'error' | 'retrying'
+  name: string
+  url: string
+  ssl_url: string
+  admin_url: string
+  deploy_url: string
+  deploy_ssl_url: string
+  created_at: string
+  updated_at: string
+  published_at?: string
+  title?: string
+  context: string
+  branch?: string
+  commit_ref?: string
+  commit_url?: string
+  review_url?: string
+  error_message?: string
+  required: string[]
+  required_functions?: string[]
+}
+export declare interface CreateDeployOptions {
+  title?: string
+  branch?: string
+  draft?: boolean
+  files: Record<string, string>
+  functions?: Record<string, string>
+  async?: boolean
+}
+export declare interface DeployFile {
+  path: string
+  content: ArrayBuffer | Uint8Array
+  sha1: string
+}
+export declare interface NetlifyClientConfig {
+  token: string
+  baseUrl?: string
+}
+export declare interface NetlifyError extends Error {
+  status: number
+  code?: string
+  details?: unknown
+}
+// ============================================================================
+// Netlify Client
+// ============================================================================
+export declare interface NetlifyClient {
+  getSite(siteId: string): Promise<NetlifySite>
+  listSites(): Promise<NetlifySite[]>
+  createSite(name?: string): Promise<NetlifySite>
+  createDeploy(siteId: string, options: CreateDeployOptions): Promise<NetlifyDeploy>
+  uploadFile(deployId: string, path: string, content: ArrayBuffer | Uint8Array): Promise<void>
+  uploadFiles(deployId: string, files: DeployFile[]): Promise<void>
+  getDeploy(deployId: string): Promise<NetlifyDeploy>
+  waitForDeploy(deployId: string, options?: WaitOptions): Promise<NetlifyDeploy>
+  lockDeploy(deployId: string): Promise<NetlifyDeploy>
+  unlockDeploy(deployId: string): Promise<NetlifyDeploy>
+}
+export declare interface WaitOptions {
+  timeout?: number
+  pollInterval?: number
+  onProgress?: (deploy: NetlifyDeploy) => void
+}

package/dist/deploy/netlify.js

@@ -0,0 +1,167 @@
+const NETLIFY_API_BASE = "https://api.netlify.com/api/v1";
+export function createNetlifyClient(config) {
+  const { token, baseUrl = NETLIFY_API_BASE } = config;
+  async function request(method, path, options = {}) {
+    const url = `${baseUrl}${path}`, headers = {
+      Authorization: `Bearer ${token}`,
+      "User-Agent": "stx-deploy/1.0"
+    };
+    let body;
+    if (options.rawBody) {
+      headers["Content-Type"] = options.contentType || "application/octet-stream";
+      body = options.rawBody;
+    } else if (options.body) {
+      headers["Content-Type"] = "application/json";
+      body = JSON.stringify(options.body);
+    }
+    const response = await fetch(url, {
+      method,
+      headers,
+      body
+    });
+    if (!response.ok) {
+      const error = Error(`Netlify API error: ${response.status} ${response.statusText}`);
+      error.status = response.status;
+      try {
+        const data = await response.json();
+        error.message = data.message || error.message;
+        error.code = data.code;
+        error.details = data;
+      } catch {}
+      throw error;
+    }
+    const text = await response.text();
+    if (!text)
+      return {};
+    return JSON.parse(text);
+  }
+  return {
+    async getSite(siteId) {
+      return request("GET", `/sites/${siteId}`);
+    },
+    async listSites() {
+      return request("GET", "/sites");
+    },
+    async createSite(name) {
+      const body = {};
+      if (name)
+        body.name = name;
+      return request("POST", "/sites", { body });
+    },
+    async createDeploy(siteId, options) {
+      const body = {
+        files: options.files,
+        draft: options.draft ?? !0,
+        async: options.async ?? !0
+      };
+      if (options.title)
+        body.title = options.title;
+      if (options.branch)
+        body.branch = options.branch;
+      if (options.functions)
+        body.functions = options.functions;
+      return request("POST", `/sites/${siteId}/deploys`, { body });
+    },
+    async uploadFile(deployId, path, content) {
+      const normalizedPath = path.startsWith("/") ? path.slice(1) : path;
+      await request("PUT", `/deploys/${deployId}/files/${normalizedPath}`, {
+        rawBody: content,
+        contentType: "application/octet-stream"
+      });
+    },
+    async uploadFiles(deployId, files) {
+      const CONCURRENCY = 5, queue = [...files], uploadNext = async () => {
+        while (queue.length > 0) {
+          const file = queue.shift();
+          if (file)
+            await this.uploadFile(deployId, file.path, file.content);
+        }
+      }, workers = Array.from({ length: Math.min(CONCURRENCY, files.length) }, () => uploadNext());
+      await Promise.all(workers);
+    },
+    async getDeploy(deployId) {
+      return request("GET", `/deploys/${deployId}`);
+    },
+    async waitForDeploy(deployId, options = {}) {
+      const {
+        timeout = 300000,
+        pollInterval = 2000,
+        onProgress
+      } = options, startTime = Date.now();
+      while (!0) {
+        const deploy = await this.getDeploy(deployId);
+        if (onProgress)
+          onProgress(deploy);
+        if (deploy.state === "ready")
+          return deploy;
+        if (deploy.state === "error") {
+          const error = Error(`Deploy failed: ${deploy.error_message || "Unknown error"}`);
+          error.status = 500;
+          error.details = deploy;
+          throw error;
+        }
+        if (Date.now() - startTime > timeout) {
+          const error = Error(`Deploy timed out after ${timeout}ms`);
+          error.status = 408;
+          error.details = deploy;
+          throw error;
+        }
+        await new Promise((resolve) => setTimeout(resolve, pollInterval));
+      }
+    },
+    async lockDeploy(deployId) {
+      return request("POST", `/deploys/${deployId}/lock`);
+    },
+    async unlockDeploy(deployId) {
+      return request("POST", `/deploys/${deployId}/unlock`);
+    }
+  };
+}
+export async function calculateSha1(content) {
+  const hashBuffer = await crypto.subtle.digest("SHA-1", content);
+  return Array.from(new Uint8Array(hashBuffer)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+export async function collectDeployFiles(directory, options = {}) {
+  const { ignore = ["node_modules", ".git", ".env*", "*.map"] } = options, files = [], glob = new Bun.Glob("**/*");
+  for await (const relativePath of glob.scan({
+    cwd: directory,
+    onlyFiles: !0,
+    dot: !1
+  })) {
+    if (ignore.some((pattern) => {
+      if (pattern.includes("*"))
+        return new RegExp(`^${pattern.replace(/\*/g, ".*")}$`).test(relativePath);
+      return relativePath.includes(pattern);
+    }))
+      continue;
+    const fullPath = `${directory}/${relativePath}`, content = await Bun.file(fullPath).arrayBuffer(), sha1 = await calculateSha1(content);
+    files.push({
+      path: relativePath,
+      content: new Uint8Array(content),
+      sha1
+    });
+  }
+  return files;
+}
+export function createFileManifest(files) {
+  const manifest = {};
+  for (const file of files)
+    manifest[`/${file.path}`] = file.sha1;
+  return manifest;
+}
+export function filterRequiredFiles(files, required) {
+  const requiredSet = new Set(required.map((p) => p.startsWith("/") ? p.slice(1) : p));
+  return files.filter((f) => requiredSet.has(f.path));
+}
+export function formatSize(bytes) {
+  if (bytes < 1024)
+    return `${bytes} B`;
+  if (bytes < 1048576)
+    return `${(bytes / 1024).toFixed(1)} KB`;
+  if (bytes < 1073741824)
+    return `${(bytes / 1048576).toFixed(1)} MB`;
+  return `${(bytes / 1073741824).toFixed(1)} GB`;
+}
+export function getTotalSize(files) {
+  return files.reduce((sum, f) => sum + f.content.byteLength, 0);
+}

package/dist/desktop.d.ts

@@ -0,0 +1,16 @@
+/// <reference path="./stx.d.ts" />
+/**
+ * Native desktop APIs.
+ *
+ * stx bundles `@stacksjs/desktop` so an app needs one dependency rather than
+ * three. Import windows, system tray, preferences, power management, global
+ * shortcuts and the rest of the native surface from here:
+ *
+ * ```typescript
+ * import { caffeinate, createPreferences, createWindow } from '@stacksjs/stx/desktop'
+ * ```
+ *
+ * For a menu bar app, prefer `@stacksjs/stx/menubar`, which composes these into
+ * a single declarative call.
+ */
+export * from '@stacksjs/desktop';

package/dist/desktop.js

@@ -0,0 +1 @@
+export * from "@stacksjs/desktop";

package/dist/dev-server/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Dev Server Module
+ *
+ * This module provides a development server for STX templates and Markdown files.
+ * It has been split into focused sub-modules:
+ *
+ * - terminal-colors.ts - ANSI color codes for terminal output
+ * - css.ts - Css CSS generation
+ * - theme-selector.ts - Theme selector UI components
+ * - port-utils.ts - Port availability checking
+ * - native-window.ts - Native window handling
+ * - keyboard-shortcuts.ts - Keyboard shortcut handling
+ * - types.ts - Type definitions
+ */
+// Re-export all sub-modules
+export * from './terminal-colors';
+export * from './ts-css';
+export * from './theme-selector';
+export * from './port-utils';
+export * from './native-window';
+export * from './keyboard-shortcuts';
+export * from './types';

package/dist/dev-server/index.js

@@ -0,0 +1,7 @@
+export * from "./terminal-colors.js";
+export * from "./ts-css.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.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Print keyboard shortcuts help
+ */
+export declare function printShortcutsHelp(): void;
+/**
+ * Print server status with URL
+ */
+export declare function printServerStatus(serverUrl: string): void;
+/**
+ * Open URL in the default browser
+ */
+export declare function openInBrowser(url: string): void;
+/**
+ * Setup keyboard shortcuts for the server
+ * Enables raw mode for handling single keystrokes
+ *
+ * @param serverUrl - The URL of the dev server
+ * @param stopServer - Function to call when stopping the server
+ * @param customHandlers - Optional custom command handlers
+ */
+export declare function setupKeyboardShortcuts(serverUrl: string, stopServer: () => void, customHandlers?: KeyboardCommandHandlers): void;
+/**
+ * Cleanup keyboard shortcuts (restore terminal state)
+ */
+export declare function cleanupKeyboardShortcuts(): void;
+/**
+ * Keyboard shortcut command handlers
+ */
+export declare interface KeyboardCommandHandlers {
+  onOpen?: () => void
+  onClear?: () => void
+  onQuit?: () => void
+  onHelp?: () => void
+}

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

@@ -0,0 +1,81 @@
+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();
+  }
+}