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

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

@@ -0,0 +1,64 @@
+
+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

@@ -0,0 +1,84 @@
+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

@@ -0,0 +1,206 @@
+// @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

@@ -0,0 +1,169 @@
+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

@@ -0,0 +1,86 @@
+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

@@ -0,0 +1,78 @@
+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;
+}