@luciq/react-native 18.0.0

package/bin/upload/index.d.ts

@@ -0,0 +1,4 @@
+export * from './uploadSourcemaps';
+export * from './uploadSoFiles';
+export * from './uploadEasUpdatesSourcemaps';
+export * from './migrate';

package/bin/upload/migrate.d.ts

@@ -0,0 +1,14 @@
+interface MigrateOptions {
+    dryRun?: boolean;
+    silent?: boolean;
+    configPath?: string;
+    skipGitCheck?: boolean;
+}
+/**
+ * Performs migration operations on the codebase.
+ *
+ * @param opts Options for the migration process.
+ * @returns A promise that resolves to a boolean indicating whether the migration was successful.
+ */
+export declare const migrate: (opts: MigrateOptions) => Promise<boolean>;
+export {};

package/bin/upload/uploadEasUpdatesSourcemaps.d.ts

@@ -0,0 +1,21 @@
+export interface UploadEasUpdatesSourcemapsOptions {
+    file: string;
+    token: string;
+    name: string;
+    code: string;
+    androidUpdateId?: string;
+    iosUpdateId?: string;
+    /**
+     * Disables logging to the console and prevents process exit on error.
+     *
+     * @default false
+     * */
+    silent?: boolean;
+}
+/**
+ * Uploads JavaScript sourcemaps to Luciq.
+ *
+ * @param opts Options for the sourcemaps upload process.
+ * @returns A promise that resolves to a boolean indicating whether the upload was successful.
+ */
+export declare const UploadEasUpdatesSourcemaps: (opts: UploadEasUpdatesSourcemapsOptions) => Promise<boolean>;

package/bin/upload/uploadSoFiles.d.ts

@@ -0,0 +1,21 @@
+export interface UploadSoFilesOptions {
+    arch: 'x86' | 'x86_64' | 'arm64-v8a' | 'armeabi-v7a';
+    file: string;
+    token: string;
+    name: string;
+    api_key: string;
+    /**
+     * Disables logging to the console and prevents process exit on error.
+     *
+     * @default false
+     * */
+    silent?: boolean;
+}
+/**
+ * Uploads NDK `.so` files to Luciq.
+ *
+ * @param opts Options for the `.so` files upload process.
+ * @returns A promise that resolves to a boolean indicating whether the upload was successful.
+ */
+export declare const uploadSoFiles: (opts: UploadSoFilesOptions) => Promise<boolean>;
+export declare const assert: (condition: unknown, message: string, silent?: boolean) => boolean;

package/bin/upload/uploadSourcemaps.d.ts

@@ -0,0 +1,21 @@
+export interface UploadSourcemapsOptions {
+    platform: 'android' | 'ios';
+    file: string;
+    token: string;
+    name: string;
+    code: string;
+    label?: string;
+    /**
+     * Disables logging to the console and prevents process exit on error.
+     *
+     * @default false
+     * */
+    silent?: boolean;
+}
+/**
+ * Uploads JavaScript sourcemaps to Luciq.
+ *
+ * @param opts Options for the sourcemaps upload process.
+ * @returns A promise that resolves to a boolean indicating whether the upload was successful.
+ */
+export declare const uploadSourcemaps: (opts: UploadSourcemapsOptions) => Promise<boolean>;

package/cli/commands/MigrateCommand.ts

@@ -0,0 +1,32 @@
+import { Command, Option } from 'commander';
+// @ts-ignore
+import { migrate, MigrateOptions } from '../upload';
+
+/**
+ * This script performs migration operations on the codebase.
+ * Usage: node migrate.js [--dry-run]
+ */
+
+export const MigrateCommand = new Command();
+
+MigrateCommand.name('migrate')
+  .addOption(
+    new Option('--dry-run', 'Show what would be changed without making actual changes').default(
+      false,
+    ),
+  )
+  .addOption(
+    new Option('--config <path>', 'Path to custom migration configuration file').default(undefined),
+  )
+  .addOption(new Option('--silent', 'Run migration silently without console output').default(false))
+  .addOption(
+    new Option(
+      '--skip-git-check',
+      'Skip git status check and continue with uncommitted changes',
+    ).default(false),
+  )
+  .action(function (this: Command) {
+    const options = this.opts<MigrateOptions>();
+    migrate(options);
+  })
+  .showHelpAfterError();

package/cli/commands/UploadEasUpdatesSourcemaps.ts

@@ -0,0 +1,34 @@
+import { Command, Option } from 'commander';
+import { UploadEasUpdatesSourcemaps, UploadEasUpdatesSourcemapsOptions } from '../upload';
+
+export const uploadEasUpdatesSourcemapsCommand = new Command();
+
+uploadEasUpdatesSourcemapsCommand
+  .name('upload-eas-updates-sourcemaps')
+  .addOption(
+    new Option('-f, --file <path>', 'The path of eas update folder')
+      .makeOptionMandatory()
+      .default('dist'),
+  )
+  .addOption(
+    new Option('-t, --token <value>', 'Your App Token')
+      .env('LUCIQ_APP_TOKEN')
+      .makeOptionMandatory(),
+  )
+  .addOption(
+    new Option('-n, --name <value>', 'The app version name')
+      .env('LUCIQ_APP_VERSION_NAME')
+      .makeOptionMandatory(),
+  )
+  .addOption(
+    new Option('-c, --code <value>', 'The app version code')
+      .env('LUCIQ_APP_VERSION_CODE')
+      .makeOptionMandatory(),
+  )
+  .addOption(new Option('--androidUpdateId <value>', 'The Android Update Id from Eas Update'))
+  .addOption(new Option('--iosUpdateId <value>', 'The iOS Update Id from Eas Update'))
+  .action(function (this: Command) {
+    const options = this.opts<UploadEasUpdatesSourcemapsOptions>();
+    UploadEasUpdatesSourcemaps(options);
+  })
+  .showHelpAfterError();

package/cli/commands/UploadSoFiles.ts

@@ -0,0 +1,38 @@
+import { Command, Option } from 'commander';
+import { uploadSoFiles, UploadSoFilesOptions } from '../upload/uploadSoFiles';
+
+/**
+ * This script uploads .so files to the specified endpoint used in NDK crash reporting.
+ * Usage: node upload-so-files.js --arch <arch> --file <path> --api_key <key> --token <token> --name <name>
+ */
+
+export const UploadSoFilesCommand = new Command();
+
+UploadSoFilesCommand.name('upload-so-files')
+  .addOption(
+    new Option('-arch, --arch <value>', 'arch')
+      .choices(['x86', 'x86_64', 'arm64-v8a', 'armeabi-v7a'])
+      .makeOptionMandatory(),
+  )
+  .addOption(
+    new Option(
+      '-f, --file <path>',
+      'The path of the symbol files in Zip format',
+    ).makeOptionMandatory(),
+  )
+  .addOption(new Option('--api_key <value>', 'Your App key').makeOptionMandatory())
+  .addOption(
+    new Option('-t, --token <value>', 'Your App Token')
+      .env('LUCIQ_APP_TOKEN')
+      .makeOptionMandatory(),
+  )
+  .addOption(
+    new Option('-n, --name <value>', 'The app version name')
+      .env('LUCIQ_APP_VERSION_NAME')
+      .makeOptionMandatory(),
+  )
+  .action(function (this: Command) {
+    const options = this.opts<UploadSoFilesOptions>();
+    uploadSoFiles(options);
+  })
+  .showHelpAfterError();

package/cli/commands/UploadSourcemaps.ts

@@ -0,0 +1,40 @@
+import { Command, Option } from 'commander';
+import { uploadSourcemaps, UploadSourcemapsOptions } from '../upload/uploadSourcemaps';
+
+export const uploadSourcemapsCommand = new Command();
+
+uploadSourcemapsCommand
+  .name('upload-sourcemaps')
+  .addOption(
+    new Option('-p, --platform <value>', 'Platform')
+      .choices(['ios', 'android'])
+      .makeOptionMandatory(),
+  )
+  .addOption(
+    new Option('-f, --file <path>', 'The path of the source map file').makeOptionMandatory(),
+  )
+  .addOption(
+    new Option('-t, --token <value>', 'Your App Token')
+      .env('LUCIQ_APP_TOKEN')
+      .makeOptionMandatory(),
+  )
+  .addOption(
+    new Option('-n, --name <value>', 'The app version name')
+      .env('LUCIQ_APP_VERSION_NAME')
+      .makeOptionMandatory(),
+  )
+  .addOption(
+    new Option('-c, --code <value>', 'The app version code')
+      .env('LUCIQ_APP_VERSION_CODE')
+      .makeOptionMandatory(),
+  )
+  .addOption(
+    new Option('-l, --label <value>', "The CodePush label if it's a CodePush release").env(
+      'LUCIQ_APP_VERSION_LABEL',
+    ),
+  )
+  .action(function (this: Command) {
+    const options = this.opts<UploadSourcemapsOptions>();
+    uploadSourcemaps(options);
+  })
+  .showHelpAfterError();

package/cli/config/migration-config.json

@@ -0,0 +1,125 @@
+{
+  "migrationMethods": [
+    {
+      "name": "Dependency Version Updates",
+      "description": "Update dependency versions from Instabug to Luciq (runs first)",
+      "priority": 1,
+      "searchReplace": [
+        {
+          "search": "com\\.instabug\\.library:instabug:[0-9]+\\.[0-9]+\\.[0-9]+",
+          "replacement": "ai.luciq.library:luciq:18.0.0",
+          "isRegex": true
+        },
+        {
+          "search": "com\\.instabug\\.library:instabug:[0-9]+\\.[0-9]+\\.[0-9]+-.*",
+          "replacement": "ai.luciq.library:luciq:18.0.0",
+          "isRegex": true
+        },
+        {
+          "search": "com\\.instabug\\.library:instabug:[0-9]+\\.[0-9]+\\.[0-9]+-SNAPSHOT",
+          "replacement": "ai.luciq.library:luciq:18.0.0",
+          "isRegex": true
+        },
+        {
+          "search": "\"instabug-react-native\":\\s*\"[^\"]+\"",
+          "replacement": "\"@luciq/react-native\": \"^18.0.0\"",
+          "isRegex": true
+        },
+        {
+          "search": "'instabug-react-native':\\s*'[^']+'",
+          "replacement": "'@luciq/react-native': '^18.0.0'",
+          "isRegex": true
+        }
+      ],
+      "targetExtensions": [".gradle", ".properties", ".xml", ".json", ".js", ".ts"],
+      "ignoredDirs": ["node_modules", "build", "Pods", "vendor", ".git", "dist", "coverage"],
+      "enabled": true
+    },
+    {
+      "name": "Package Name Updates",
+      "description": "Update package names and references",
+      "priority": 2,
+      "searchReplace": [
+        { "search": "com.instabug", "replacement": "ai.luciq" },
+        { "search": "com.instabug.reactlibrary", "replacement": "ai.luciq.reactlibrary" },
+        { "search": "RNInstabug", "replacement": "RNLuciq" },
+        { "search": "rninstabug", "replacement": "rnluciq" },
+        { "search": "instabug-reactnative", "replacement": "@luciq/react-native" },
+        { "search": "instabug-react-native", "replacement": "@luciq/react-native" }
+      ],
+      "targetExtensions": [".java", ".kt", ".ts", ".tsx", ".js", ".jsx", ".json"],
+      "ignoredDirs": ["node_modules", "build", "Pods", "vendor", ".git", "dist", "coverage"],
+      "enabled": true
+    },
+    {
+      "name": "Instabug to Luciq",
+      "description": "Replace all instances of Instabug with Luciq",
+      "priority": 3,
+      "searchReplace": [
+        { "search": "Instabug", "replacement": "Luciq" },
+        { "search": "instabug", "replacement": "luciq" },
+        { "search": "INSTABUG", "replacement": "LUCIQ" },
+        { "search": "IBG", "replacement": "LCQ" },
+        { "search": "ibg", "replacement": "lcq" }
+      ],
+      "targetExtensions": [".h", ".m", ".java", ".kt", ".ts", ".tsx", ".js", ".jsx"],
+      "ignoredDirs": [
+        "node_modules",
+        "build",
+        "Pods",
+        "vendor",
+        ".git",
+        "dist",
+        "coverage",
+        ".next",
+        ".nuxt",
+        "target"
+      ],
+      "enabled": true
+    },
+    {
+      "name": "Cleanup",
+      "description": "Clean up file extensions and references",
+      "priority": 4,
+      "searchReplace": [
+        { "search": ".instabug", "replacement": ".luciq" },
+        { "search": "_instabug", "replacement": "_luciq" },
+        { "search": "instabug_", "replacement": "luciq_" }
+      ],
+      "targetExtensions": [".ts", ".tsx", ".js", ".jsx"],
+      "ignoredDirs": ["node_modules", "build", "Pods", "vendor", ".git", "dist", "coverage"],
+      "enabled": true
+    },
+    {
+      "name": "IOS File changes objective c",
+      "description": "IOS Objective C files",
+      "priority": 5,
+      "searchReplace": [
+        { "search": "Instabug", "replacement": "Luciq" },
+        { "search": "instabug", "replacement": "luciq" },
+        { "search": "INSTABUG", "replacement": "LUCIQ" },
+        { "search": "IBG", "replacement": "LCQ" }
+      ],
+      "targetExtensions": [".h", ".m"],
+      "ignoredDirs": ["node_modules", "build", "Pods", "vendor", ".git", "dist", "coverage"],
+      "enabled": true
+    },
+    {
+      "name": "IOS File changes objective swift",
+      "description": "IOS Swift files",
+      "priority": 6,
+      "searchReplace": [
+        { "search": "Instabug", "replacement": "Luciq" },
+        { "search": "instabug", "replacement": "luciq" },
+        { "search": "INSTABUG", "replacement": "LUCIQ" }
+      ],
+      "targetExtensions": [".swift"],
+      "ignoredDirs": ["node_modules", "build", "Pods", "vendor", ".git", "dist", "coverage"],
+      "enabled": true
+    }
+  ],
+  "defaultOptions": {
+    "dryRun": false,
+    "silent": false
+  }
+}

package/cli/index.ts

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+
+import { uploadSourcemapsCommand } from './commands/UploadSourcemaps';
+import { UploadSoFilesCommand } from './commands/UploadSoFiles';
+import { uploadEasUpdatesSourcemapsCommand } from './commands/UploadEasUpdatesSourcemaps';
+import { MigrateCommand } from './commands/MigrateCommand';
+
+const program = new Command();
+
+program
+  .name('luciq')
+  .version('1.0.0-beta1')
+  .description('A CLI for uploading source maps to Luciq dashboard.')
+  .usage('[command]')
+  .addCommand(uploadSourcemapsCommand)
+  .addCommand(UploadSoFilesCommand)
+  .addCommand(uploadEasUpdatesSourcemapsCommand)
+  .addCommand(MigrateCommand);
+
+program.parse(process.argv);

package/cli/upload/index.ts

@@ -0,0 +1,4 @@
+export * from './uploadSourcemaps';
+export * from './uploadSoFiles';
+export * from './uploadEasUpdatesSourcemaps';
+export * from './migrate';

package/cli/upload/migrate.ts

@@ -0,0 +1,271 @@
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import * as readline from 'readline';
+
+interface SearchReplaceRule {
+  search: string;
+  replacement: string;
+  isRegex?: boolean;
+}
+
+interface MigrationMethod {
+  name: string;
+  description: string;
+  searchReplace: SearchReplaceRule[];
+  targetExtensions: string[];
+  ignoredDirs: string[];
+  enabled: boolean;
+  priority?: number; // Lower number = higher priority
+}
+
+interface MigrationConfig {
+  migrationMethods: MigrationMethod[];
+  defaultOptions: {
+    dryRun: boolean;
+    silent: boolean;
+  };
+}
+
+interface MigrateOptions {
+  dryRun?: boolean;
+  silent?: boolean;
+  configPath?: string;
+  skipGitCheck?: boolean;
+}
+
+/**
+ * Loads migration configuration from JSON file
+ */
+function loadMigrationConfig(configPath?: string): MigrationMethod[] {
+  const defaultConfigPath = path.join(__dirname, 'config/migration-config.json');
+  const configFilePath = configPath || defaultConfigPath;
+
+  if (!fs.existsSync(configFilePath)) {
+    throw new Error(`Configuration file not found: ${configFilePath}`);
+  }
+
+  const config: MigrationConfig = JSON.parse(fs.readFileSync(configFilePath, 'utf8'));
+  return config.migrationMethods;
+}
+
+/**
+ * Performs migration operations on the codebase.
+ *
+ * @param opts Options for the migration process.
+ * @returns A promise that resolves to a boolean indicating whether the migration was successful.
+ */
+export const migrate = async (opts: MigrateOptions): Promise<boolean> => {
+  try {
+    const allMethods = loadMigrationConfig(opts.configPath);
+    const enabledMethods = allMethods.filter((m) => m.enabled);
+
+    if (enabledMethods.length === 0) {
+      if (!opts.silent) {
+        console.error('❌ No migration methods are enabled');
+        process.exit(1);
+      }
+      return false;
+    }
+
+    // Check git status unless skipped
+    if (!opts.skipGitCheck) {
+      const shouldSkip = await checkGitStatus(opts.silent);
+      if (!shouldSkip) {
+        return false;
+      }
+    }
+
+    // Sort methods by priority (lower number = higher priority)
+    const sortedMethods = enabledMethods.sort((a, b) => (a.priority || 999) - (b.priority || 999));
+
+    if (!opts.silent) {
+      console.log('🔄 Starting migration with all enabled methods');
+      console.log(`📝 Found ${sortedMethods.length} enabled method(s):`);
+      sortedMethods.forEach((method) => {
+        console.log(`   - ${method.name}: ${method.description}`);
+      });
+      if (opts.dryRun) {
+        console.log('🔍 Dry run mode enabled - no changes will be made');
+      }
+      console.log('================================');
+    }
+
+    await executeAllMethods(sortedMethods, opts.dryRun || false, opts.silent);
+
+    if (!opts.silent) {
+      if (opts.dryRun) {
+        console.log('\n🔍 Dry run completed. No changes were made.');
+      } else {
+        console.log('\n🎉 All migrations completed successfully!');
+      }
+    }
+
+    return true;
+  } catch (error) {
+    if (!opts.silent) {
+      console.error('❌ Migration failed:', error);
+      process.exit(1);
+    }
+    return false;
+  }
+};
+
+async function checkGitStatus(silent?: boolean): Promise<boolean> {
+  try {
+    const status = execSync('git status --porcelain').toString();
+    if (status.trim()) {
+      if (silent) {
+        return false;
+      }
+
+      console.warn('⚠️ Uncommitted changes detected.');
+      console.log('Current changes:');
+      console.log(status);
+
+      const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+      });
+
+      const answer = await new Promise<string>((resolve) => {
+        rl.question('Do you want to continue anyway? (y/N): ', resolve);
+      });
+
+      rl.close();
+
+      if (answer.toLowerCase() !== 'y' && answer.toLowerCase() !== 'yes') {
+        console.log('Migration cancelled.');
+        return false;
+      }
+
+      console.log('Continuing with migration...');
+    }
+    return true;
+  } catch (error) {
+    if (!silent) {
+      console.warn('⚠️ Git check failed, continuing without git validation...');
+    }
+    return true;
+  }
+}
+
+function isIgnored(filePath: string, ignoredDirs: string[]): boolean {
+  return ignoredDirs.some((dir) => filePath.split(path.sep).includes(dir));
+}
+
+function casePreservingReplace(str: string, searchReplace: SearchReplaceRule[]): string {
+  let result = str;
+
+  for (const { search, replacement, isRegex } of searchReplace) {
+    if (isRegex) {
+      // For regex patterns, use direct replacement without case preservation
+      result = result.replace(new RegExp(search, 'g'), replacement);
+    } else {
+      // For literal strings, preserve case
+      result = result.replace(new RegExp(search, 'gi'), (match) => {
+        if (match === match.toUpperCase()) {
+          return replacement.toUpperCase();
+        }
+        if (match[0] === match[0].toUpperCase()) {
+          return replacement[0].toUpperCase() + replacement.slice(1);
+        }
+        return replacement.toLowerCase();
+      });
+    }
+  }
+
+  return result;
+}
+
+function processFile(
+  filePath: string,
+  method: MigrationMethod,
+  dryRun: boolean,
+  silent?: boolean,
+): void {
+  if (isIgnored(filePath, method.ignoredDirs)) {
+    return;
+  }
+
+  try {
+    const fileExt = path.extname(filePath);
+
+    if (!method.targetExtensions.includes(fileExt)) {
+      return;
+    }
+
+    const content = fs.readFileSync(filePath, 'utf8');
+    const newContent = casePreservingReplace(content, method.searchReplace);
+
+    if (newContent !== content) {
+      if (dryRun) {
+        if (!silent) {
+          console.log(`📝 [${method.name}] Would update content: ${filePath}`);
+        }
+        return;
+      }
+
+      fs.writeFileSync(filePath, newContent, 'utf8');
+      if (!silent) {
+        console.log(`📝 [${method.name}] Updated content: ${filePath}`);
+      }
+    }
+  } catch (error) {
+    if (!silent) {
+      console.error(`❌ Error processing file ${filePath}:`, error);
+    }
+  }
+}
+
+function walkDirectory(
+  dirPath: string,
+  method: MigrationMethod,
+  dryRun: boolean,
+  silent?: boolean,
+): void {
+  if (isIgnored(dirPath, method.ignoredDirs)) {
+    return;
+  }
+
+  try {
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+
+    for (const entry of entries) {
+      const fullPath = path.join(dirPath, entry.name);
+      if (entry.isDirectory()) {
+        walkDirectory(fullPath, method, dryRun, silent);
+      } else {
+        processFile(fullPath, method, dryRun, silent);
+      }
+    }
+  } catch (error) {
+    if (!silent) {
+      console.error(`❌ Error walking directory ${dirPath}:`, error);
+    }
+  }
+}
+
+async function executeAllMethods(
+  methods: MigrationMethod[],
+  dryRun: boolean,
+  silent?: boolean,
+): Promise<void> {
+  for (const method of methods) {
+    await executeMethod(method, dryRun, silent);
+  }
+}
+
+async function executeMethod(
+  method: MigrationMethod,
+  dryRun: boolean,
+  silent?: boolean,
+): Promise<void> {
+  const startDir = process.cwd();
+
+  if (!silent) {
+    console.log(`🚀 Executing method: ${method.name}`);
+  }
+
+  walkDirectory(startDir, method, dryRun, silent);
+}