@momo-kits/native-kits 0.157.1-com.1-debug → 0.157.1-com.1

package/src/doctor/src/utils/checkWrongVersionCommunityPackage.ts

@@ -1,64 +0,0 @@
-
-import fs from 'fs';
-import path from 'path';
-import semver from 'semver';
-import { logger } from '../logger';
-
-/**
- * Scans package.json dependencies and flags any package with version 0.x.x where minor < 80 as deprecated.
- * Returns true if no deprecated versions are found, false otherwise.
- */
-export interface DeprecatedVersionResult {
-  healthy: boolean;
-  found: string[];
-}
-
-export function checkWrongVersionCommunityPackage(): DeprecatedVersionResult {
-  const cwd = process.cwd();
-  const pkgPath = path.resolve(cwd, 'package.json');
-  if (!fs.existsSync(pkgPath)) {
-    logger.warn('No package.json found');
-    return { healthy: true, found: [] };
-  }
-
-  let pkg: any;
-  try {
-    pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-  } catch (error) {
-    logger.error(`Failed to parse package.json: ${error}`);
-    return { healthy: false, found: [] };
-  }
-
-  const allDeps: Record<string, string> = {
-    ...pkg.dependencies,
-    ...pkg.devDependencies,
-    ...pkg.peerDependencies,
-    ...pkg.optionalDependencies,
-  };
-
-  const communityPackage = [
-    {name: 'react-native-svg', version: '15.11.1'},
-    {name: 'react-native-video', version: '6.14.0'},
-    {name: 'react-native-maps', version: '0.27.0'},
-  ];
-
-  const found: string[] = [];
-
-  for (const [name, range] of Object.entries(allDeps)) {
-    if (!communityPackage.find(item => item.name === name)) {
-      continue;
-    }
-    const coerced = semver.coerce(range);
-    if (!coerced) continue;
-    if (coerced.major === 0 && coerced.minor < 80) {
-      logger.error(`${name}@${coerced.version} is using wrong version, please use ${communityPackage.find(item => item.name === name)?.version}`);
-      found.push(`${name}@${coerced.version} => ${communityPackage.find(item => item.name === name)?.version}`);
-    }
-  }
-
-  if (found.length > 0) {
-    return { healthy: false, found };
-  }
-
-  return { healthy: true, found: [] };
-} 

package/src/doctor/src/utils/getErrorMessage.ts

@@ -1,84 +0,0 @@
-import {DependencyIssue} from './checkShareDependencies';
-import {ScanResult} from './scanNativeModulesUsage';
-
-export const getErrorMessage = (
-  coreHealthy: boolean,
-  nativeHealthy: boolean,
-  nativeUsageCount: number,
-  componentRate: number,
-  maxApiHealthy: boolean,
-  maxApiResults: Record<string, string[]>,
-  deprecatedPkgList: string[],
-  deprecatedVerList: string[],
-  wrongVersionList: string[],
-  sharedDependencyIssues: DependencyIssue[],
-  foundationImportIssues: ScanResult
-): string | null => {
-  const messages: string[] = [];
-  if (!coreHealthy) {
-    messages.push(
-      '❗️ Core dependencies check failed. Please ensure you have removed any @momo-kits/core usage.'
-    );
-  }
-  if (!nativeHealthy) {
-    messages.push(
-      `❗️ Native modules usage detected in ${nativeUsageCount} file(s). Please remove native module imports.`
-    );
-  }
-  if (componentRate < 0.5) {
-    messages.push(
-      `❗️ Component adoption rate is low: ${(componentRate * 100).toFixed(
-        2
-      )}%. Aim for at least 50%.`
-    );
-  }
-  if (!maxApiHealthy) {
-    const deprecatedUsages = Object.entries(maxApiResults).flatMap(
-      ([file, apis]) => apis.map(api => `${api} in ${file}`)
-    );
-    messages.push(
-      `❗️ Deprecated MaxAPI usage found: ${deprecatedUsages.join('; ')}`
-    );
-  }
-  if (deprecatedPkgList.length > 0) {
-    messages.push(
-      `❗️ Deprecated @momo-kits packages found: ${deprecatedPkgList.join(
-        ', '
-      )}. Please remove or update them accordingly.`
-    );
-  }
-  if (deprecatedVerList.length > 0) {
-    messages.push(
-      `❗️ Deprecated @momo-kits dependency versions detected (<0.80.x): ${deprecatedVerList.join(
-        ', '
-      )}. Please upgrade to latest versions.`
-    );
-  }
-  if (wrongVersionList.length > 0) {
-    messages.push(
-      `❗️ Wrong version dependency found: ${wrongVersionList.join(
-        ', '
-      )}. Please upgrade to correct versions.`
-    );
-  }
-  if (sharedDependencyIssues.length > 0) {
-    const missingDeps = sharedDependencyIssues
-      .map(issue => issue.package)
-      .join(', ');
-    messages.push(
-      `❗️ Shared dependencies issues found: ${missingDeps}. These dependencies are used in code but not declared in package.json.`
-    );
-  }
-  if (Object.keys(foundationImportIssues).length > 0) {
-    const invalidImports = Object.entries(foundationImportIssues)
-      .flatMap(([file, imports]) => imports.map(imp => `${imp} in ${file}`))
-      .join('; ');
-    messages.push(
-      `❗️ Invalid nested imports found: ${invalidImports}. Only imports from entry are allowed, not from internal paths.`
-    );
-  }
-  if (messages.length === 0) {
-    return null;
-  }
-  return messages.join('\n');
-};

package/src/doctor/src/utils/scanComponentUsage.ts

@@ -1,206 +0,0 @@
-// @ts-ignore
-import scanner from 'react-scanner';
-import fs from 'fs';
-import path from 'path';
-import {getLogger} from '../logger';
-
-const scan = async (config: any) => {
-  const originalLog = console.log;
-  const originalWarn = console.warn;
-  const originalInfo = console.info;
-  console.log = () => {};
-  console.warn = () => {};
-  console.info = () => {};
-  try {
-    return await scanner.run(config);
-  } finally {
-    console.log = originalLog;
-    console.warn = originalWarn;
-    console.info = originalInfo;
-  }
-};
-
-function ensureFileExists(filePath: string, defaultContent: any = {}) {
-  if (!fs.existsSync(filePath)) {
-    fs.mkdirSync(path.dirname(filePath), {recursive: true});
-    fs.writeFileSync(filePath, JSON.stringify(defaultContent, null, 2));
-  }
-}
-
-/**
- * Calculates adoption rate based on component usage counts in scan JSON files.
- * Formula: (Foundation + Library + FS + RN) / All components
- */
-function calculateAdoptionRate(files: Record<string, string>) {
-  const counts: Record<string, number> = {};
-  for (const [key, file] of Object.entries(files)) {
-    let json: Record<string, number> = {};
-    try {
-      json = JSON.parse(fs.readFileSync(file, 'utf-8'));
-    } catch {
-      json = {};
-    }
-    counts[key] = Object.values(json).reduce(
-      (sum, v) => sum + (typeof v === 'number' ? v : 0),
-      0
-    );
-  }
-  const numerator =
-    counts.foundation + counts.library + counts.verLib + counts.rn;
-  const log = getLogger('ADOPTION_RATE');
-  log.info('Components count\n');
-  const tableData = Object.entries(counts).map(
-    ([components, count]) => ({ components, count })
-  );
-  console.table(tableData);
-
-  const denominator = Object.values(counts).reduce((sum, v) => sum + v, 0);
-  const rate = denominator > 0 ? numerator / denominator : 0;
-  return {rate, counts};
-}
-
-const scanBranch = async (scanPath: string) => {
-  const corePath = process.cwd() + '/scan/core.json';
-  const foundationPath = process.cwd() + '/scan/foundation.json';
-  const libPath = process.cwd() + '/scan/library.json';
-  const rnPath = process.cwd() + '/scan/RN.json';
-  const unIdentifiedPath = process.cwd() + '/scan/unidentify.json';
-  const verLibPath = process.cwd() + '/scan/verLibPath.json';
-
-  const files = {
-    foundation: foundationPath,
-    library: libPath,
-    rn: rnPath,
-    unidentify: unIdentifiedPath,
-    verLib: verLibPath,
-  };
-
-  const allKitsReg = /@momo-kits/;
-  const fsReg =
-    /^(?:@fs-mobile-platform\/(components(\/.*)?|investment(\/.*)?|screens(\/.*)?|foundation(\/.*)?)|@miniapp-platform\/(components(\/.*)?|foundation(\/.*)?))$/;
-  const RNReg = /react-native|react-native-svg/;
-  const excludeReg = new RegExp(
-    `^(?!(${allKitsReg.source}|${fsReg.source}|${RNReg.source})).*$`
-  );
-
-  const config1 = {
-    crawlFrom: scanPath,
-    includeSubComponents: true,
-    importedFrom: '@momo-kits/foundation',
-    processors: [['count-components', {outputTo: foundationPath}]],
-    rootDir: process.cwd(),
-  };
-
-  const config2 = {
-    crawlFrom: scanPath,
-    importedFrom: '@momo-kits/core',
-    includeSubComponents: true,
-    processors: [['count-components', {outputTo: corePath}]],
-    rootDir: process.cwd(),
-  };
-
-  const config3 = {
-    crawlFrom: scanPath,
-    includeSubComponents: true,
-    importedFrom: /^@momo-kits\/(?!core|foundation)/,
-    processors: [['count-components', {outputTo: libPath}]],
-    rootDir: process.cwd(),
-  };
-
-  const config4 = {
-    crawlFrom: scanPath,
-    includeSubComponents: true,
-    importedFrom: 'react-native',
-    processors: [['count-components', {outputTo: rnPath}]],
-    rootDir: process.cwd(),
-  };
-
-  const config5 = {
-    crawlFrom: scanPath,
-    includeSubComponents: true,
-    importedFrom: excludeReg,
-    processors: [['count-components', {outputTo: unIdentifiedPath}]],
-    rootDir: process.cwd(),
-  };
-
-  const config6 = {
-    crawlFrom: scanPath,
-    includeSubComponents: true,
-    importedFrom: fsReg,
-    processors: [['count-components', {outputTo: verLibPath}]],
-    rootDir: process.cwd(),
-  };
-
-  try {
-    ensureFileExists(corePath, {});
-    ensureFileExists(foundationPath, {});
-    ensureFileExists(libPath, {});
-    ensureFileExists(rnPath, {});
-    ensureFileExists(unIdentifiedPath, {});
-    ensureFileExists(verLibPath, {});
-
-    await scan(config1);
-    await scan(config2);
-    await scan(config3);
-    await scan(config4);
-    await scan(config5);
-    await scan(config6);
-
-    const {rate, counts} = calculateAdoptionRate(files);
-
-    return {
-      rate,
-      counts,
-    };
-  } catch (error) {
-    console.error('Error during scan or calculation:', error);
-  }
-};
-
-const getScanPath = () => {
-  const possiblePaths = [
-    './src',
-    './miniapp',
-    './miniApp',
-    './app',
-    './miniApps',
-  ];
-
-  for (const p of possiblePaths) {
-    if (fs.existsSync(path.resolve(p))) {
-      console.log(`✅ Found source folder: ${p}`);
-      return p;
-    }
-  }
-
-  throw new Error('❌ No valid src folder found');
-};
-
-const scanComponentUsage: () => Promise<{
-  rate: number;
-  counts: Record<string, number>;
-}> = async () => {
-  let scanPath;
-  try {
-    scanPath = getScanPath();
-  } catch (error: any) {
-    console.error(error.message);
-    return {rate: 0, counts: {}};
-  }
-
-  const log = getLogger('ADOPTION_RATE');
-  const result = await scanBranch(scanPath);
-  if (!result) {
-    return {rate: 0, counts: {}};
-  }
-  if (result.rate < 0.5) {
-    log.error(`Adoption rate: ${(result.rate * 100).toFixed(2)}%`);
-  } else {
-    log.success(
-      `Adoption rate: ${(result.rate * 100).toFixed(2)}%`
-    );
-  }
-  return result;
-};
-
-export default scanComponentUsage;

package/src/doctor/src/utils/scanFoundationImports.ts

@@ -1,169 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import {ScanResult, scanTargetDirs} from './scanNativeModulesUsage';
-import {logger} from '../logger';
-
-/**
- * Scans project files and flags any import that uses an internal subpath
- * for packages declared in package.json (dependencies and devDependencies).
- *
- * Example flagged patterns:
- *  - import X from 'some-pkg/internal';
- *  - export {Y} from "@scope/pkg/utils";
- *  - const x = require('lib/sub/module');
- *  - const x = await import("@scope/lib/deep/path");
- *
- * Valid (NOT flagged):
- *  - import X from 'some-pkg';
- *
- * @returns ScanResult mapping file paths to list of invalid import paths found.
- */
-function scanInternalImportsCore(): {
-  byFile: ScanResult;
-  foundations: string[];
-  momoKitsOthers: string[];
-  others: string[];
-} {
-  const cwd = process.cwd();
-  const dirs = scanTargetDirs;
-
-  // Read declared packages from package.json
-  let packageNames: string[] = [];
-  try {
-    const pkgJsonPath = path.resolve(cwd, 'package.json');
-    const pkgRaw = fs.readFileSync(pkgJsonPath, 'utf8');
-    const pkg = JSON.parse(pkgRaw) as {
-      dependencies?: Record<string, string>;
-      devDependencies?: Record<string, string>;
-    };
-    const deps = Object.keys(pkg.dependencies || {});
-    const devDeps = Object.keys(pkg.devDependencies || {});
-    // Unique list
-    packageNames = Array.from(new Set([...deps, ...devDeps]));
-  } catch (e) {
-    logger.warn(
-      'Unable to read package.json to determine package list. Falling back to empty set.'
-    );
-    packageNames = [];
-  }
-
-  // Build a regex to match any import/re-export/require/dynamic import that uses a subpath
-  // for one of the declared packages, e.g. from 'pkg/subpath'
-  const escapeRegex = (s: string) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-  const namesAlternation = packageNames.map(escapeRegex).join('|');
-  // If no packages, use a regex that matches nothing
-  const invalidImportRegex = namesAlternation
-    ? new RegExp(
-        // import ... from 'pkg/sub' | export ... from 'pkg/sub' | require('pkg/sub') | import('pkg/sub')
-        String.raw`(?:import\s+[^;]*?from\s+|export\s+[^;]*?from\s+|require\(|import\()\s*['"](?:${namesAlternation})\/[^'\"]+['"]`,
-        'g'
-      )
-    : /$a/; // matches nothing when no packages
-
-  const results: ScanResult = {};
-  const foundationSet = new Set<string>();
-  const momoKitsOtherSet = new Set<string>();
-  const othersSet = new Set<string>();
-  const skipDirs = new Set([
-    'node_modules',
-    'dist',
-    'build',
-    'coverage',
-    '__tests__',
-    '__mocks__',
-  ]);
-  const skipTestFileRegex = /\.(test|spec)\.(js|jsx|ts|tsx)$/;
-
-  function scanDir(dirPath: string) {
-    let entries: fs.Dirent[];
-    try {
-      entries = fs.readdirSync(dirPath, {withFileTypes: true});
-    } catch {
-      return;
-    }
-
-    for (const entry of entries) {
-      const fullPath = path.join(dirPath, entry.name);
-
-      if (
-        entry.isDirectory() &&
-        (skipDirs.has(entry.name) || entry.name.startsWith('.'))
-      ) {
-        continue;
-      }
-
-      if (entry.isDirectory()) {
-        scanDir(fullPath);
-      } else if (entry.isFile() && /\.(js|jsx|ts|tsx)$/.test(entry.name)) {
-        if (skipTestFileRegex.test(entry.name)) {
-          continue;
-        }
-
-        let content: string;
-        try {
-          content = fs.readFileSync(fullPath, 'utf8');
-        } catch {
-          continue;
-        }
-
-        const matches = content.match(invalidImportRegex);
-        if (matches && matches.length > 0) {
-          if (!results[fullPath]) {
-            results[fullPath] = [];
-          }
-
-          // Extract the quoted import path from each match
-          for (const match of matches) {
-            const pathMatch = match.match(/['"]([^'"]+)['"]/);
-            const importPath = pathMatch?.[1];
-            if (importPath && !results[fullPath].includes(importPath)) {
-              results[fullPath].push(importPath);
-
-              if (importPath.startsWith('@momo-kits/')) {
-                logger.error(
-                  `Invalid internal package import "${importPath}" found in file: ${fullPath}`
-                );
-                if (importPath.startsWith('@momo-kits/foundation/')) {
-                  foundationSet.add(importPath);
-                } else {
-                  momoKitsOtherSet.add(importPath);
-                }
-              } else {
-                othersSet.add(importPath);
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-
-  for (const dir of dirs) {
-    const dirPath = path.resolve(cwd, dir);
-    if (fs.existsSync(dirPath) && fs.statSync(dirPath).isDirectory()) {
-      scanDir(dirPath);
-      break;
-    }
-  }
-
-  return {
-    byFile: results,
-    foundations: Array.from(foundationSet),
-    momoKitsOthers: Array.from(momoKitsOtherSet),
-    others: Array.from(othersSet),
-  };
-}
-
-export function scanFoundationImports(): ScanResult {
-  const {byFile} = scanInternalImportsCore();
-  return byFile;
-}
-
-export function scanInternalImportsBuckets(): {
-  foundations: string[];
-  momoKitsOthers: string[];
-  others: string[];
-} {
-  const {foundations, momoKitsOthers, others} = scanInternalImportsCore();
-  return {foundations, momoKitsOthers, others};
-}

package/src/doctor/src/utils/scanMaxApiUsage.ts

@@ -1,86 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import { ScanResult, scanTargetDirs } from './scanNativeModulesUsage';
-import { logger } from '../logger';
-
-/**
- * Scans directories for usage of deprecated MaxAPI methods.
- * @returns ScanResult mapping file paths to list of deprecated API names found.
- */
-export function scanMaxApiUsage(): ScanResult {
-  const cwd = process.cwd();
-  const dirs = scanTargetDirs;
-  const apiNames = [
-    'startMiniApp',
-    'getIpAddress',
-    'startServiceId',
-    'listenAndroidKeyboardHeight',
-    'useNetInfo',
-    'sendConfirmMessage',
-    'shareApp',
-    'isFavoriteApp',
-    'isHighPerformanceDevice',
-    'updateToastDebugConfig',
-    'popBackStack',
-    'setSoftInputMode',
-    'getSystemBrightnessLevel',
-    'getFirebaseWebAppConfig',
-    'preLoadFiles',
-    'getPathFiles',
-    'requestATTPermision',
-    'compressVideo'
-  ];
-  const patterns = apiNames.map(name => ({ name, regex: new RegExp(`\\bMaxApi\\.${name}\\b`, 'i') }));
-  const results: ScanResult = {};
-  const skipDirs = new Set(['node_modules','dist','build','coverage','__tests__','__mocks__']);
-  const skipTestFileRegex = /\.(test|spec)\.(js|jsx|ts|tsx)$/;
-
-  function scanDir(dirPath: string) {
-    let entries: fs.Dirent[];
-    try {
-      entries = fs.readdirSync(dirPath, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      const fullPath = path.join(dirPath, entry.name);
-      if (entry.isDirectory() && (skipDirs.has(entry.name) || entry.name.startsWith('.'))) {
-        continue;
-      }
-      if (entry.isDirectory()) {
-        scanDir(fullPath);
-      } else if (entry.isFile() && /\.(js|jsx|ts|tsx)$/.test(entry.name)) {
-        if (skipTestFileRegex.test(entry.name)) {
-          continue;
-        }
-        let content: string;
-        try {
-          content = fs.readFileSync(fullPath, 'utf8');
-        } catch {
-          continue;
-        }
-        for (const { name, regex } of patterns) {
-          if (regex.test(content)) {
-            if (!results[fullPath]) {
-              results[fullPath] = [];
-            }
-            if (!results[fullPath].includes(name)) {
-              results[fullPath].push(name);
-              logger.error(`Deprecated MaxAPI "${name}" used in file: ${fullPath}`);
-            }
-          }
-        }
-      }
-    }
-  }
-
-  for (const dir of dirs) {
-    const dirPath = path.resolve(cwd, dir);
-    if (fs.existsSync(dirPath) && fs.statSync(dirPath).isDirectory()) {
-      scanDir(dirPath);
-      break;
-    }
-  }
-
-  return results;
-} 

package/src/doctor/src/utils/scanNativeModulesUsage.ts

@@ -1,78 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-
-// Directories to scan, shared by both native modules and MaxAPI scanners
-export const scanTargetDirs = ['src', 'miniapp', 'miniApp', 'app', 'miniApps'];
-
-export interface ScanResult {
-  [filePath: string]: string[];
-}
-
-/**
- * Recursively scans directories for React Native native modules usage.
- * Looks for patterns like NativeModules, requireNativeComponent, UIManager, etc.
- * Scans the following folders at project root if they exist: src, miniapp, miniApp, app, miniApps.
- */
-export function scanNativeModulesUsage(): ScanResult {
-  const cwd = process.cwd();
-  const dirs = scanTargetDirs;
-  const patterns: {name: string; regex: RegExp}[] = [
-    {name: 'NativeModules import', regex: /import\s+{\s*NativeModules\s*}/},
-    {name: 'NativeModules usage', regex: /NativeModules\./},
-    {name: 'requireNativeComponent', regex: /requireNativeComponent/},
-  ];
-  const results: ScanResult = {};
-  const skipDirs = new Set(['node_modules','dist','build','coverage','__tests__','__mocks__']);
-  const skipTestFileRegex = /\.(test|spec)\.(js|jsx|ts|tsx)$/;
-
-  function scanDir(dirPath: string) {
-    let entries: fs.Dirent[];
-    try {
-      entries = fs.readdirSync(dirPath, {withFileTypes: true});
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      const fullPath = path.join(dirPath, entry.name);
-      if (entry.isDirectory() && (skipDirs.has(entry.name) || entry.name.startsWith('.'))) {
-        continue;
-      }
-      if (entry.isDirectory()) {
-        scanDir(fullPath);
-      } else if (
-        entry.isFile() &&
-        /\.(js|jsx|ts|tsx)$/.test(entry.name)
-      ) {
-        if (skipTestFileRegex.test(entry.name)) {
-          continue;
-        }
-        let content: string;
-        try {
-          content = fs.readFileSync(fullPath, 'utf8');
-        } catch {
-          continue;
-        }
-        for (const {name, regex} of patterns) {
-          if (regex.test(content)) {
-            if (!results[fullPath]) {
-              results[fullPath] = [];
-            }
-            if (!results[fullPath].includes(name)) {
-              results[fullPath].push(name);
-            }
-          }
-        }
-      }
-    }
-  }
-
-  for (const dir of dirs) {
-    const dirPath = path.resolve(cwd, dir);
-    if (fs.existsSync(dirPath) && fs.statSync(dirPath).isDirectory()) {
-      scanDir(dirPath);
-      break;
-    }
-  }
-
-  return results;
-}