react-native-sherpa-onnx 0.1.0

package/scripts/setup-assets.js

@@ -0,0 +1,323 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const isWindows = process.platform === 'win32';
+
+/**
+ * Setup script that runs after npm/yarn install
+ * Handles:
+ * 1. Copying C++ header files from sherpa-onnx submodule
+ * 2. Downloading iOS framework from GitHub releases
+ */
+
+function log(message, type = 'info') {
+  const colors = {
+    info: '\x1b[36m', // cyan
+    success: '\x1b[32m', // green
+    warning: '\x1b[33m', // yellow
+    error: '\x1b[31m', // red
+    reset: '\x1b[0m',
+  };
+
+  const color = colors[type] || colors.info;
+  console.log(`${color}[setup-assets] ${message}${colors.reset}`);
+}
+
+/**
+ * Run a command and return output
+ */
+function runCommand(cmd, options = {}) {
+  const { silent = false, allowFailure = false } = options;
+
+  try {
+    if (!silent) {
+      log(`Running: ${cmd}`);
+    }
+
+    const output = execSync(cmd, {
+      encoding: 'utf-8',
+      stdio: silent ? 'pipe' : 'inherit',
+    });
+
+    return { ok: true, output: (output || '').trim() };
+  } catch (error) {
+    if (!silent) {
+      log(
+        `${allowFailure ? 'Warning' : 'Failed'}: ${cmd}`,
+        allowFailure ? 'warning' : 'error'
+      );
+    }
+
+    if (!allowFailure) {
+      throw error;
+    }
+
+    return { ok: false, output: '' };
+  }
+}
+
+/**
+ * Verify header files are in the correct locations
+ */
+function verifyHeaders() {
+  log('Verifying header files...', 'info');
+
+  const requiredHeaders = [
+    path.join(
+      __dirname,
+      '..',
+      'ios',
+      'include',
+      'sherpa-onnx',
+      'c-api',
+      'c-api.h'
+    ),
+    path.join(
+      __dirname,
+      '..',
+      'ios',
+      'include',
+      'sherpa-onnx',
+      'c-api',
+      'cxx-api.h'
+    ),
+    path.join(
+      __dirname,
+      '..',
+      'android',
+      'src',
+      'main',
+      'cpp',
+      'include',
+      'sherpa-onnx',
+      'c-api',
+      'c-api.h'
+    ),
+    path.join(
+      __dirname,
+      '..',
+      'android',
+      'src',
+      'main',
+      'cpp',
+      'include',
+      'sherpa-onnx',
+      'c-api',
+      'cxx-api.h'
+    ),
+  ];
+
+  const missingHeaders = requiredHeaders.filter(
+    (header) => !fs.existsSync(header)
+  );
+
+  if (missingHeaders.length === 0) {
+    log('All header files verified at correct locations', 'success');
+    return true;
+  } else {
+    log(
+      `Missing header files found (${missingHeaders.length}/${requiredHeaders.length}):`,
+      'error'
+    );
+    missingHeaders.forEach((header) => {
+      log(`  - ${header}`, 'error');
+    });
+    return false;
+  }
+}
+
+/**
+ * Step 1: Copy header files
+ */
+function copyHeaders() {
+  log('Step 1: Copying header files...', 'info');
+
+  try {
+    // Call the script directly to avoid depending on yarn availability in consumers
+    const copyResult = runCommand('node scripts/copy-headers.js', {
+      allowFailure: true,
+    });
+
+    if (copyResult.ok) {
+      log('Header files copied successfully', 'success');
+    } else {
+      log(
+        'Warning: Header copy command reported a failure; verifying files...',
+        'warning'
+      );
+    }
+
+    // Verify headers after copy
+    console.log('');
+    const headersOk = verifyHeaders();
+    if (!headersOk) {
+      log('Header verification failed after copy', 'error');
+    }
+    return headersOk;
+  } catch (error) {
+    log('Warning: Header copy failed, may already exist', 'warning');
+    // Still try to verify if headers exist
+    console.log('');
+    return verifyHeaders();
+  }
+}
+
+/**
+ * Verify iOS framework is downloaded and extracted correctly
+ */
+function verifyIOSFramework() {
+  log('Verifying iOS framework...', 'info');
+
+  const frameworkPath = path.join(
+    __dirname,
+    '..',
+    'ios',
+    'Frameworks',
+    'sherpa_onnx.xcframework'
+  );
+
+  // Check if framework directory exists
+  if (!fs.existsSync(frameworkPath)) {
+    log(`Framework directory not found at ${frameworkPath}`, 'error');
+    return false;
+  }
+
+  log(`Framework directory exists`, 'success');
+
+  // Check for required framework files
+  const requiredFiles = [
+    path.join(frameworkPath, 'Info.plist'),
+    path.join(frameworkPath, 'ios-arm64', 'libsherpa-onnx.a'),
+    path.join(frameworkPath, 'ios-arm64_x86_64-simulator', 'libsherpa-onnx.a'),
+  ];
+
+  const missingFiles = requiredFiles.filter((file) => !fs.existsSync(file));
+
+  if (missingFiles.length === 0) {
+    // Calculate framework size
+    let totalSize = 0;
+    const getDirectorySize = (dirPath) => {
+      try {
+        const files = fs.readdirSync(dirPath);
+        files.forEach((file) => {
+          const filePath = path.join(dirPath, file);
+          const stats = fs.statSync(filePath);
+          if (stats.isDirectory()) {
+            totalSize += getDirectorySize(filePath);
+          } else {
+            totalSize += stats.size;
+          }
+        });
+      } catch (e) {
+        // Silently ignore errors
+      }
+      return totalSize;
+    };
+
+    getDirectorySize(frameworkPath);
+    const frameworkSizeMB = (totalSize / (1024 * 1024)).toFixed(2);
+
+    log(`All framework files present (${frameworkSizeMB}MB)`, 'success');
+    return true;
+  } else {
+    log(
+      `Missing framework files (${missingFiles.length}/${requiredFiles.length}):`,
+      'error'
+    );
+    missingFiles.forEach((file) => {
+      log(`  - ${file}`, 'error');
+    });
+    return false;
+  }
+}
+
+/**
+ * Step 2: Download iOS framework (only on macOS)
+ */
+function downloadIOSFramework() {
+  // Only download on macOS since it's iOS-specific
+  if (process.platform !== 'darwin') {
+    log('Skipping iOS framework download (not on macOS)', 'info');
+    return true;
+  }
+
+  log('Step 2: Downloading iOS framework...', 'info');
+
+  const frameworkPath = path.join(
+    __dirname,
+    '..',
+    'ios',
+    'Frameworks',
+    'sherpa_onnx.xcframework'
+  );
+
+  // Check if framework already exists
+  if (fs.existsSync(frameworkPath)) {
+    log('iOS framework already present, verifying...', 'success');
+    console.log('');
+    return verifyIOSFramework();
+  }
+
+  try {
+    // Call the shell script directly to avoid yarn dependency in consuming apps
+    const downloadResult = runCommand('bash scripts/setup-ios-framework.sh');
+
+    if (downloadResult.ok) {
+      log('iOS framework downloaded successfully', 'success');
+
+      // Verify framework after download
+      console.log('');
+      return verifyIOSFramework();
+    }
+
+    log('iOS framework download command reported failure', 'error');
+    return false;
+  } catch (error) {
+    log('iOS framework download failed', 'error');
+    return false;
+  }
+}
+
+/**
+ * Main setup function
+ */
+function setup() {
+  console.log('');
+  log('='.repeat(60), 'info');
+  log('SherpaOnnx SDK Setup Starting', 'info');
+  log('='.repeat(60), 'info');
+  console.log('');
+
+  let success = true;
+
+  // Step 1: Copy headers (critical for both Android and iOS)
+  if (!copyHeaders()) {
+    success = false;
+  }
+
+  console.log('');
+
+  // Step 2: Download iOS framework (macOS only)
+  if (!downloadIOSFramework()) {
+    success = false;
+  }
+
+  console.log('');
+  if (success) {
+    log('='.repeat(60), 'success');
+    log('Setup completed successfully!', 'success');
+    log('='.repeat(60), 'success');
+    console.log('');
+    process.exit(0);
+  } else {
+    log('Setup failed (see logs above)', 'error');
+    console.log('');
+    process.exit(1);
+  }
+}
+
+// Run setup
+setup();

package/scripts/setup-ios-framework.sh

@@ -0,0 +1,282 @@
+#!/bin/bash
+
+# Script to download and manage iOS Framework
+# Can be called manually or by Podfile during pod install
+# Usage:
+#   ./scripts/setup-ios-framework.sh          # Downloads/updates framework (auto mode, no interactive)
+#   ./scripts/setup-ios-framework.sh 1.12.23  # Downloads specific version
+#   ./scripts/setup-ios-framework.sh --interactive  # Interactive mode with prompts
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(dirname "$SCRIPT_DIR")"
+FRAMEWORKS_DIR="$PROJECT_ROOT/ios/Frameworks"
+VERSION_FILE="$FRAMEWORKS_DIR/.framework-version"
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Detect if running in interactive mode (terminal)
+INTERACTIVE=false
+[ -t 0 ] && INTERACTIVE=true
+
+# Check for explicit flags
+if [ "$1" = "--interactive" ]; then
+  INTERACTIVE=true
+  shift
+fi
+
+# Only print header if interactive
+if [ "$INTERACTIVE" = true ]; then
+  echo -e "${BLUE}iOS Framework Setup Script${NC}"
+  echo "Project root: $PROJECT_ROOT"
+  echo ""
+fi
+
+# Create frameworks directory if it doesn't exist
+mkdir -p "$FRAMEWORKS_DIR"
+
+# Function to compare semantic versions (e.g., "1.12.23" vs "1.12.24")
+compare_versions() {
+  local v1=$1
+  local v2=$2
+  
+  # Convert to arrays
+  IFS='.' read -ra v1_parts <<< "$v1"
+  IFS='.' read -ra v2_parts <<< "$v2"
+  
+  # Pad arrays to same length
+  local max_len=${#v1_parts[@]}
+  [ ${#v2_parts[@]} -gt $max_len ] && max_len=${#v2_parts[@]}
+  
+  # Compare each part
+  for ((i=0; i<max_len; i++)); do
+    local v1_num=${v1_parts[$i]:-0}
+    local v2_num=${v2_parts[$i]:-0}
+    
+    if [ "$v1_num" -lt "$v2_num" ]; then
+      echo "-1"  # v1 < v2
+      return 0
+    elif [ "$v1_num" -gt "$v2_num" ]; then
+      echo "1"   # v1 > v2
+      return 0
+    fi
+  done
+  
+  echo "0"  # v1 == v2
+}
+
+# Function to get latest framework version from GitHub
+get_latest_framework_version() {
+  echo -e "${YELLOW}Fetching latest framework release from GitHub...${NC}" >&2
+
+  local releases_json=$(curl -s -H "Accept: application/vnd.github+json" "https://api.github.com/repos/XDcobra/react-native-sherpa-onnx/releases" 2>/dev/null || echo "")
+
+  if [ -z "$releases_json" ]; then
+    echo -e "${RED}Error: Could not fetch releases from GitHub API${NC}" >&2
+    return 1
+  fi
+
+  # Avoid jq errors on rate-limit HTML or plain-text responses
+  if ! echo "$releases_json" | grep -q '"tag_name"'; then
+    echo -e "${RED}Error: GitHub API response did not contain release data (possible rate limit).${NC}" >&2
+    echo "Response (truncated):" >&2
+    echo "$releases_json" | head -5 >&2
+    return 1
+  fi
+
+  local version=""
+
+  if command -v jq &> /dev/null; then
+    if echo "$releases_json" | jq -e . > /dev/null 2>&1; then
+      version=$(echo "$releases_json" | jq -r '.[] | select(.tag_name | startswith("framework-v")) | .tag_name' | head -1 | sed 's/framework-v//')
+    else
+      echo -e "${RED}Error: GitHub releases response is not valid JSON${NC}" >&2
+      echo "$releases_json" | head -5 >&2
+      return 1
+    fi
+  else
+    version=$(echo "$releases_json" | grep -o '"tag_name": "framework-v[0-9.]*' | head -1 | sed 's/.*framework-v//')
+  fi
+
+  if [ -z "$version" ]; then
+    echo -e "${RED}Error: No framework releases found with tag format 'framework-vX.Y.Z'${NC}" >&2
+    return 1
+  fi
+
+  echo "$version"
+}
+
+# Function to get local framework version
+get_local_framework_version() {
+  if [ -f "$VERSION_FILE" ]; then
+    cat "$VERSION_FILE"
+  else
+    echo ""
+  fi
+}
+
+# Function to download and extract framework
+download_and_extract_framework() {
+  local version=$1
+  local tag="framework-v$version"
+
+  echo -e "${YELLOW}Downloading framework version $version...${NC}" >&2
+
+  # Get download URL from GitHub API
+  local release_json=$(curl -s -H "Accept: application/vnd.github+json" "https://api.github.com/repos/XDcobra/react-native-sherpa-onnx/releases/tags/$tag" 2>/dev/null || echo "")
+
+  if [ -z "$release_json" ]; then
+    echo -e "${RED}Error: Could not fetch release information for tag $tag${NC}" >&2
+    return 1
+  fi
+
+  if ! echo "$release_json" | grep -q '"assets"'; then
+    echo -e "${RED}Error: GitHub API response for $tag did not contain assets (possible rate limit).${NC}" >&2
+    echo "Response (truncated):" >&2
+    echo "$release_json" | head -5 >&2
+    return 1
+  fi
+
+  # Extract download URL using jq if available, otherwise grep/sed
+  local download_url
+  if command -v jq &> /dev/null; then
+    if echo "$release_json" | jq -e . > /dev/null 2>&1; then
+      download_url=$(echo "$release_json" | jq -r '.assets[] | select(.name == "sherpa_onnx.xcframework.zip") | .browser_download_url' | head -1)
+    else
+      echo -e "${RED}Error: Release response is not valid JSON${NC}" >&2
+      echo "$release_json" | head -5 >&2
+      return 1
+    fi
+  else
+    download_url=$(echo "$release_json" | grep -o '"browser_download_url": "[^"]*' | grep 'xcframework.zip' | head -1 | sed 's/.*: "//' | sed 's/"$//')
+  fi
+
+  if [ -z "$download_url" ]; then
+    echo -e "${RED}Error: Could not find download URL for version $version${NC}" >&2
+    echo -e "${RED}Available assets:${NC}" >&2
+    if command -v jq &> /dev/null; then
+      echo "$release_json" | jq -r '.assets[].name' | sed 's/^/  - /' >&2 || true
+    fi
+    return 1
+  fi
+
+  echo "Downloading from: $download_url" >&2
+
+  # Download the zip file
+  local zip_path="$FRAMEWORKS_DIR/sherpa_onnx.xcframework.zip"
+
+  if ! curl -L -f -o "$zip_path" "$download_url" 2>/dev/null; then
+    echo -e "${RED}Error: Failed to download framework from $download_url${NC}" >&2
+    rm -f "$zip_path"
+    return 1
+  fi
+
+  # Check if zip file is valid
+  if ! file "$zip_path" 2>/dev/null | grep -q "Zip archive"; then
+    echo -e "${RED}Error: Downloaded file is not a valid zip archive${NC}" >&2
+    echo "File type: $(file "$zip_path" 2>/dev/null || echo "unknown")" >&2
+    rm -f "$zip_path"
+    return 1
+  fi
+
+  # Remove old framework if it exists
+  if [ -d "$FRAMEWORKS_DIR/sherpa_onnx.xcframework" ]; then
+    echo -e "${YELLOW}Removing old framework...${NC}" >&2
+    rm -rf "$FRAMEWORKS_DIR/sherpa_onnx.xcframework"
+  fi
+
+  # Extract the zip
+  echo -e "${YELLOW}Extracting framework...${NC}" >&2
+  unzip -q -o "$zip_path" -d "$FRAMEWORKS_DIR"
+
+  if [ ! -d "$FRAMEWORKS_DIR/sherpa_onnx.xcframework" ]; then
+    echo -e "${RED}Error: Framework extraction failed${NC}" >&2
+    echo "Contents of $FRAMEWORKS_DIR:" >&2
+    ls -la "$FRAMEWORKS_DIR" 2>/dev/null | head -20 >&2 || true
+    rm -f "$zip_path"
+    return 1
+  fi
+
+  # Remove zip file
+  rm -f "$zip_path"
+
+  # Write version file
+  echo "$version" > "$VERSION_FILE"
+
+  echo -e "${GREEN}Framework v$version downloaded and extracted successfully${NC}" >&2
+  return 0
+}
+
+# Main logic
+if [ -n "$1" ]; then
+  # User provided a specific version
+  download_and_extract_framework "$1"
+else
+  # Auto mode: check version and download only if needed
+  [ "$INTERACTIVE" = true ] && echo -e "${YELLOW}Checking framework version...${NC}" >&2
+  
+  local_version=$(get_local_framework_version)
+
+  if ! latest_version=$(get_latest_framework_version); then
+    if [ -d "$FRAMEWORKS_DIR/sherpa_onnx.xcframework" ]; then
+      echo -e "${YELLOW}Warning: Could not fetch latest framework version, using existing local framework.${NC}" >&2
+      exit 0
+    fi
+    exit 1
+  fi
+
+  if [ -z "$latest_version" ]; then
+    echo -e "${RED}Error: Could not fetch framework version from GitHub${NC}" >&2
+    exit 1
+  fi
+  
+  [ "$INTERACTIVE" = true ] && echo -e "${GREEN}Latest framework version: $latest_version${NC}" >&2
+  
+  # Check if framework exists
+  if [ ! -d "$FRAMEWORKS_DIR/sherpa_onnx.xcframework" ]; then
+    [ "$INTERACTIVE" = true ] && echo "Framework not found locally, downloading..." >&2
+    download_and_extract_framework "$latest_version" || exit 1
+  elif [ -z "$local_version" ]; then
+    # Framework exists but no version file
+    [ "$INTERACTIVE" = true ] && echo "Framework exists but no version info, updating version file..." >&2
+    echo "$latest_version" > "$VERSION_FILE"
+  else
+    # Compare versions
+    local version_cmp=$(compare_versions "$local_version" "$latest_version")
+    
+    if [ "$version_cmp" = "0" ]; then
+      [ "$INTERACTIVE" = true ] && echo -e "${GREEN}Framework is up to date (v$local_version)${NC}" >&2
+    elif [ "$version_cmp" = "-1" ]; then
+      [ "$INTERACTIVE" = true ] && echo -e "${YELLOW}Update available: v$local_version → v$latest_version${NC}" >&2
+      if [ "$INTERACTIVE" = true ]; then
+        read -p "Do you want to update? (y/N): " -n 1 -r
+        echo
+        if [[ $REPLY =~ ^[Yy]$ ]]; then
+          download_and_extract_framework "$latest_version" || exit 1
+        fi
+      else
+        # Auto-update in non-interactive mode (e.g., from Podfile)
+        download_and_extract_framework "$latest_version" || exit 1
+      fi
+    else
+      [ "$INTERACTIVE" = true ] && echo -e "${YELLOW}Local version (v$local_version) is newer than latest release (v$latest_version)${NC}" >&2
+    fi
+  fi
+fi
+
+if [ "$INTERACTIVE" = true ]; then
+  echo "" >&2
+  echo -e "${GREEN}Framework setup complete!${NC}" >&2
+  echo "Framework location: $FRAMEWORKS_DIR/sherpa_onnx.xcframework" >&2
+  echo "" >&2
+  echo "Next steps:" >&2
+  echo "  1. cd example" >&2
+  echo "  2. pod install" >&2
+  echo "  3. Open ios/SherpaOnnxExample.xcworkspace in Xcode" >&2
+fi

package/scripts/switch-registry.js

@@ -0,0 +1,75 @@
+#!/usr/bin/env node
+
+/**
+ * Script to switch npm registry configuration
+ * Updates both .npmrc and publishConfig in package.json
+ * This ensures both npm publish and release-it use the correct registry
+ * Usage: node scripts/switch-registry.js [local|public]
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const rootDir = path.join(__dirname, '..');
+const npmrcPath = path.join(rootDir, '.npmrc');
+const npmrcLocalPath = path.join(rootDir, '.npmrc.local');
+const npmrcPublicPath = path.join(rootDir, '.npmrc.public');
+const packageJsonPath = path.join(rootDir, 'package.json');
+
+const mode = process.argv[2] || 'local';
+
+// Read package.json
+const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+
+if (mode === 'local') {
+  if (!fs.existsSync(npmrcLocalPath)) {
+    console.error(' .npmrc.local not found');
+    process.exit(1);
+  }
+  
+  // Update .npmrc
+  fs.copyFileSync(npmrcLocalPath, npmrcPath);
+  
+  // Update publishConfig in package.json
+  if (!packageJson.publishConfig) {
+    packageJson.publishConfig = {};
+  }
+  packageJson.publishConfig.registry = 'http://localhost:4873';
+  
+  // Write updated package.json
+  fs.writeFileSync(
+    packageJsonPath,
+    JSON.stringify(packageJson, null, 2) + '\n'
+  );
+  
+  console.log(' Switched to Verdaccio (local registry)');
+  console.log('   Registry: http://localhost:4873');
+  console.log('   Updated .npmrc and package.json publishConfig');
+} else if (mode === 'public') {
+  if (!fs.existsSync(npmrcPublicPath)) {
+    console.error(' .npmrc.public not found');
+    process.exit(1);
+  }
+  
+  // Update .npmrc
+  fs.copyFileSync(npmrcPublicPath, npmrcPath);
+  
+  // Update publishConfig in package.json
+  if (!packageJson.publishConfig) {
+    packageJson.publishConfig = {};
+  }
+  packageJson.publishConfig.registry = 'https://registry.npmjs.org/';
+  
+  // Write updated package.json
+  fs.writeFileSync(
+    packageJsonPath,
+    JSON.stringify(packageJson, null, 2) + '\n'
+  );
+  
+  console.log(' Switched to npm (public registry)');
+  console.log('   Registry: https://registry.npmjs.org/');
+  console.log('   Updated .npmrc and package.json publishConfig');
+} else {
+  console.error(' Invalid mode. Use "local" or "public"');
+  process.exit(1);
+}