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

package/src/doctor/src/utils/checkCoreDependencies.ts

@@ -0,0 +1,138 @@
+import fs from 'fs';
+import path from 'path';
+import {parse as parseYarnLock} from '@yarnpkg/lockfile';
+import semver from 'semver';
+import {logger} from '../logger';
+
+function checkCoreDependencies() {
+  const cwd = process.cwd();
+  const lockPath = path.resolve(cwd, 'yarn.lock');
+  if (!fs.existsSync(lockPath)) {
+    logger.warn(
+      'No lockfile found (yarn.lock, pnpm-lock.yaml or package-lock.json)'
+    );
+    return false;
+  }
+
+  const raw = fs.readFileSync(lockPath, 'utf8');
+  const {object: tree} = parseYarnLock(raw);
+
+  const platformEntries = Object.entries(tree).filter(([key, _]) =>
+    key.startsWith('@momo-platform/momo-core@')
+  );
+
+  if (platformEntries.length === 0) {
+    logger.warn('Không phát hiện @momo-platform/momo-core trong lockfile');
+  }
+
+  const allowedCoreVersions = new Set();
+  for (const [_, meta] of platformEntries) {
+    const deps = meta.dependencies || {};
+    const spec = deps['@momo-kits/core'];
+    if (spec) {
+      for (const [coreKey, coreMeta] of Object.entries(tree)) {
+        if (coreKey.startsWith('@momo-kits/core@')) {
+          const v = coreMeta.version;
+          if (semver.satisfies(v, spec)) {
+            allowedCoreVersions.add(v);
+          }
+        }
+      }
+    }
+  }
+
+  const actualCoreVersions = new Set();
+  for (const [key, meta] of Object.entries(tree)) {
+    if (key.startsWith('@momo-kits/core@')) {
+      actualCoreVersions.add(meta.version);
+    }
+  }
+
+  const offending = [...actualCoreVersions].filter(
+    v => !allowedCoreVersions.has(v)
+  );
+
+  if (offending.length === 0) {
+    logger.success(
+      'Your project is not have @momo-kits/core in yarn.lock, good job!'
+    );
+    return true;
+  } else {
+    logger.error(
+      `Your project is using @momo-kits/core, please remove it from your project: ${offending.join(
+        ', '
+      )}`
+    );
+    return false;
+  }
+}
+
+const importRegex =
+  /(?:import .* from ['"]@momo-kits\/core['"]|require\(['"]@momo-kits\/core['"]\))/;
+const validExtensions = ['.js', '.jsx', '.ts', '.tsx'];
+
+function scanCoreNodeModule(): boolean {
+  let hasViolation = false;
+
+  function scanFile(filePath: string) {
+    const content = fs.readFileSync(filePath, 'utf8');
+    const lines = content.split('\n');
+
+    lines.forEach((line, index) => {
+      const trimmedLine = line.trim();
+
+      const isCommentedLine =
+        trimmedLine.startsWith('//') ||
+        trimmedLine.startsWith('*') ||
+        trimmedLine.startsWith('/*') ||
+        (trimmedLine.includes('//') &&
+          trimmedLine.indexOf('//') < trimmedLine.indexOf('@momo-kits/core'));
+
+      if (
+        importRegex.test(trimmedLine) &&
+        !trimmedLine.includes('@momo-platform/momo-core') &&
+        !isCommentedLine
+      ) {
+        console.log(`[VIOLATION] ${filePath}:${index + 1}: ${trimmedLine}`);
+        hasViolation = true;
+      }
+    });
+  }
+
+  function walk(dir: string) {
+    fs.readdirSync(dir).forEach(file => {
+      const fullPath = path.join(dir, file);
+      const stat = fs.statSync(fullPath);
+
+      if (stat.isDirectory()) {
+        const normalizedPath = fullPath.split(path.sep).join('/'); // cross-platform check
+        if (
+          normalizedPath.includes('node_modules/@momo-kits/calculator') ||
+          normalizedPath.includes('node_modules/@momo-kits/qrcode') ||
+          normalizedPath.includes('node_modules/@momo-platform/momo-core')
+        ) {
+          return;
+        }
+
+        walk(fullPath);
+      } else if (validExtensions.includes(path.extname(file))) {
+        scanFile(fullPath);
+      }
+    });
+  }
+
+  walk('node_modules');
+
+  const paths = ['src', 'app', 'miniApp', 'miniApps'];
+
+  paths.forEach(path => {
+    if (fs.existsSync(path)) {
+      walk(path);
+    }
+  });
+
+  logger.success('Your project do not have @momo-kits/core, good job!');
+  return !hasViolation;
+}
+
+export {checkCoreDependencies, scanCoreNodeModule};

package/src/doctor/src/utils/checkDeletedPackage.ts

@@ -0,0 +1,53 @@
+import fs from 'fs';
+import path from 'path';
+import {logger} from '../logger';
+
+export const deletedPackage = [
+  '@momo-kits/core',
+  '@react-native-community/art',
+  '@react-native-community/push-notification-ios',
+  '@react-native-voice/voice',
+  'react-native-contacts',
+  'react-native-sensors',
+  'rn-fetch-blob',
+  'react-native-keychain',
+  'react-native-geolocation-service',
+];
+
+export function checkDeletedPackages() {
+  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 {
+    const content = fs.readFileSync(pkgPath, 'utf8');
+    pkg = JSON.parse(content);
+  } catch (error) {
+    logger.error(`Failed to parse package.json: ${error}`);
+    return {healthy: false, found: []};
+  }
+
+  const allDeps = {
+    ...pkg.dependencies,
+    ...pkg.devDependencies,
+    ...pkg.peerDependencies,
+    ...pkg.optionalDependencies,
+  };
+
+  const found = deletedPackage.filter(name => allDeps && allDeps[name]);
+
+  if (found.length > 0) {
+    found.forEach(name => {
+      logger.error(
+        `${name} is delelted – please remove it from your package.json.`
+      );
+    });
+    return {healthy: false, found};
+  }
+
+  return {healthy: true, found: []};
+}

package/src/doctor/src/utils/checkDeprecatedPackages.ts

@@ -0,0 +1,168 @@
+import fs from 'fs';
+import path from 'path';
+import {logger} from '../logger';
+
+export const deprecatedPackagesList = [
+  '@momo-kits/scrollable-tab-view',
+  '@momo-kits/toast',
+  '@momo-kits/expand',
+  '@momo-kits/money',
+  '@momo-kits/separator',
+  '@momo-kits/suggest-email',
+  '@momo-kits/guide',
+  '@momo-kits/switch',
+  '@momo-kits/skeleton',
+  '@momo-kits/selection',
+  '@momo-kits/radio',
+  '@momo-kits/core',
+  '@momo-kits/check-box',
+  '@momo-kits/custom',
+  '@momo-kits/message',
+  '@momo-kits/alert-message',
+  '@momo-kits/data-picker',
+  '@momo-kits/transaction',
+  '@momo-kits/rating-star',
+  '@momo-kits/chart',
+  '@momo-kits/bank',
+  '@momo-kits/sticker',
+  '@momo-kits/effect',
+  '@momo-kits/voucher',
+  '@momo-kits/film',
+  '@momo-kits/zoomable-image',
+  '@momo-kits/shortcut',
+  '@momo-kits/draggbale-list',
+  '@momo-kits/tag',
+  '@momo-kits/scanner',
+  '@momo-kits/sof',
+  '@momo-kits/floating-button',
+  '@momo-kits/face-detect',
+  '@momo-kits/header',
+  '@momo-kits/circle-progress',
+  '@momo-kits/segmented-control',
+  '@momo-kits/recommend-sof',
+  '@momo-kits/camerax',
+  '@momo-kits/floating-action',
+  '@momo-kits/scrollable-tab-string',
+  '@momo-kits/ncc',
+  '@momo-kits/navigation',
+  '@momo-kits/scroll-indicator',
+  '@momo-kits/v2-core',
+  '@momo-kits/gameview',
+  '@momo-kits/hashtag',
+  'react-native-sensors',
+  'react-native-share',
+  'rn-fetch-blob',
+  'react-native-image-picker',
+  'react-native-image-resizer',
+  'react-native-fs',
+  'react-native-fast-image',
+  'react-native-document-picker',
+  'react-native-contacts',
+  'react-native-exception-handler',
+  '@react-native-community/netinfo',
+];
+
+export const deprecatedPackageReplacements: Record<string, string> = {
+  '@momo-kits/scrollable-tab-view': '@momo-kits/tab-view',
+  '@momo-kits/toast': 'MaxApi.showToast',
+  '@momo-kits/expand': '@momo-kits/collapse',
+  '@momo-kits/money': 'your own component',
+  '@momo-kits/separator': 'Divider in @momo-kits/foundation',
+  '@momo-kits/suggest-email': 'your own component',
+  '@momo-kits/guide': 'your own component',
+  '@momo-kits/switch': 'Switch in @momo-kits/foundation',
+  '@momo-kits/skeleton': 'Skeleton in @momo-kits/foundation',
+  '@momo-kits/selection': 'your own component',
+  '@momo-kits/radio': 'Radio in @momo-kits/foundation',
+  '@momo-kits/check-box': 'Checkbox in @momo-kits/foundation',
+  '@momo-kits/custom': 'your own component',
+  '@momo-kits/message': 'your own component',
+  '@momo-kits/alert-message': 'your own component',
+  '@momo-kits/data-picker': 'your own component',
+  '@momo-kits/transaction': 'your own component',
+  '@momo-kits/rating-star': '@momo-kits/rating',
+  '@momo-kits/chart': 'your own component',
+  '@momo-kits/bank': 'your own component',
+  '@momo-kits/sticker': 'your own component',
+  '@momo-kits/effect': 'your own component',
+  '@momo-kits/voucher': 'your own component',
+  '@momo-kits/film': 'your own component',
+  '@momo-kits/zoomable-image': 'your own component',
+  '@momo-kits/shortcut': 'your own component',
+  '@momo-kits/draggbale-list': 'your own component',
+  '@momo-kits/tag': 'Tag in @momo-kits/foundation',
+  '@momo-kits/scanner': 'your own component',
+  '@momo-kits/sof': 'your own component',
+  '@momo-kits/floating-button': 'your own component',
+  '@momo-kits/face-detect': 'your own component',
+  '@momo-kits/header': 'your own component',
+  '@momo-kits/circle-progress': 'your own component',
+  '@momo-kits/segmented-control': 'your own component',
+  '@momo-kits/recommend-sof': 'your own component',
+  '@momo-kits/camerax': 'your own component',
+  '@momo-kits/floating-action': 'your own component',
+  '@momo-kits/scrollable-tab-string': 'your own component',
+  '@momo-kits/ncc': 'your own component',
+  '@momo-kits/navigation': 'your own component',
+  '@momo-kits/scroll-indicator': 'your own component',
+  '@momo-kits/v2-core': 'your own component',
+  '@momo-kits/gameview': 'your own component',
+  '@momo-kits/hashtag': 'your own component',
+  'react-native-sensors': 'maxApi',
+  'react-native-share': 'maxApi',
+  'rn-fetch-blob': 'maxApi',
+  'react-native-image-picker': 'maxApi',
+  // 'react-native-image-resizer': 'maxApi',
+  'react-native-fs': 'maxApi',
+  'react-native-fast-image': 'Image in @momo-kits/foundation',
+  'react-native-document-picker': 'maxApi',
+  'react-native-contacts': 'maxApi',
+  'react-native-exception-handler': 'maxApi',
+  '@react-native-community/netinfo': 'maxApi',
+};
+
+// Add result type for deprecated package checks
+export interface DeprecatedPackagesResult {
+  healthy: boolean;
+  found: string[];
+}
+
+export function checkDeprecatedPackages(): DeprecatedPackagesResult {
+  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 {
+    const content = fs.readFileSync(pkgPath, 'utf8');
+    pkg = JSON.parse(content);
+  } catch (error) {
+    logger.error(`Failed to parse package.json: ${error}`);
+    return {healthy: false, found: []};
+  }
+
+  const allDeps = {
+    ...pkg.dependencies,
+    ...pkg.devDependencies,
+    ...pkg.peerDependencies,
+    ...pkg.optionalDependencies,
+  };
+
+  const found = deprecatedPackagesList.filter(name => allDeps && allDeps[name]);
+
+  if (found.length > 0) {
+    found.forEach(name => {
+      const replacement =
+        deprecatedPackageReplacements[name] || '<replacement>';
+      logger.error(
+        `${name} is deprecated – please use ${replacement} instead.`
+      );
+    });
+    return {healthy: false, found};
+  }
+
+  return {healthy: true, found: []};
+}

package/src/doctor/src/utils/checkDeprecatedVersion.ts

@@ -0,0 +1,60 @@
+import fs from 'fs';
+import path from 'path';
+import semver from 'semver';
+import { logger } from '../logger';
+import { deprecatedPackagesList } from './checkDeprecatedPackages';
+
+/**
+ * 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 checkDeprecatedVersion(): 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 found: string[] = [];
+
+  // Only consider @momo-kits packages for version deprecation, skip statically deprecated
+  for (const [name, range] of Object.entries(allDeps)) {
+    if (!name.startsWith('@momo-kits/') || deprecatedPackagesList.includes(name)) {
+      continue;
+    }
+    const coerced = semver.coerce(range);
+    if (!coerced) continue;
+    if (coerced.major === 0 && coerced.minor < 77) {
+      logger.error(`@momo-kits dependency ${name}@${coerced.version} uses deprecated version (<0.77.x)`);
+      found.push(`${name}@${coerced.version}`);
+    }
+  }
+
+  if (found.length > 0) {
+    return { healthy: false, found };
+  }
+
+  logger.success('No @momo-kits dependencies using deprecated 0.x.x versions (<0.77.x)');
+  return { healthy: true, found: [] };
+} 

package/src/doctor/src/utils/checkShareDependencies.ts

@@ -0,0 +1,251 @@
+import fs from 'fs';
+import path from 'path';
+import {logger} from '../logger';
+
+// Shared dependencies that should be declared in package.json if used
+const sharedDependencies = [
+  '@momo-kits/foundation',
+  '@momo-kits/webview',
+  '@react-native-community/masked-view',
+  '@react-navigation/bottom-tabs',
+  '@react-navigation/core',
+  '@react-navigation/native',
+  '@react-navigation/routers',
+  '@react-navigation/stack',
+  'd3-shape',
+  'entities',
+  'htmlparser2-without-node-native',
+  'lodash',
+  'lottie-ios',
+  'lottie-react-native',
+  'moment',
+  'prop-types',
+  'react',
+  'react-native',
+  'react-native-camera-kit',
+  'react-native-fast-image',
+  'react-native-gesture-handler',
+  'react-native-image-pan-zoom',
+  'react-native-linear-gradient',
+  'react-native-maps',
+  'react-native-pager-view',
+  'react-native-progress',
+  'react-native-reanimated',
+  'react-native-safe-area-context',
+  'react-native-screens',
+  'metro-react-native-babel-preset',
+];
+
+// Directories to scan (following the same pattern as other utils)
+const scanTargetDirs = ['src', 'miniapp', 'miniApp', 'app', 'miniApps'];
+
+interface PackageJson {
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+  peerDependencies?: Record<string, string>;
+}
+
+export interface DependencyIssue {
+  package: string;
+  usedInFiles: string[];
+}
+
+export interface ShareDependenciesResult {
+  healthy: boolean;
+  issues: DependencyIssue[];
+}
+
+/**
+ * Scans project files for usage of shared dependencies and checks if they are declared in package.json
+ * @returns ShareDependenciesResult - contains healthy status and detailed issues
+ */
+export function checkShareDependencies(): ShareDependenciesResult {
+  const cwd = process.cwd();
+  const skipDirs = new Set([
+    'node_modules',
+    'dist',
+    'build',
+    'coverage',
+    '__tests__',
+    '__mocks__',
+  ]);
+  const skipTestFileRegex = /\.(test|spec)\.(js|jsx|ts|tsx)$/;
+
+  // Find all package.json files and collect dependencies
+  const allDependencies = new Set<string>();
+
+  function scanPackageJsonFiles() {
+    const packageJsonFiles: string[] = [];
+
+    function findPackageJson(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()) {
+          findPackageJson(fullPath);
+        } else if (entry.name === 'package.json') {
+          packageJsonFiles.push(fullPath);
+        }
+      }
+    }
+
+    // Scan from current directory
+    findPackageJson(cwd);
+
+    // Read all package.json files and collect dependencies
+    for (const packageFile of packageJsonFiles) {
+      try {
+        const content: PackageJson = JSON.parse(
+          fs.readFileSync(packageFile, 'utf-8')
+        );
+        const allDeps = {
+          ...content.dependencies,
+          ...content.devDependencies,
+          ...content.peerDependencies,
+        };
+
+        Object.keys(allDeps).forEach(dep => allDependencies.add(dep));
+      } catch (error) {
+        logger.warn(`Failed to read package.json: ${packageFile}`);
+      }
+    }
+  }
+
+  // Scan for dependency usage in source files
+  function scanSourceFiles(): Record<string, string[]> {
+    const usageResults: Record<string, string[]> = {};
+
+    // Initialize results for each shared dependency
+    sharedDependencies.forEach(dep => {
+      usageResults[dep] = [];
+    });
+
+    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;
+          }
+
+          // Check each shared dependency for usage in this file
+          for (const sharedDep of sharedDependencies) {
+            const escapedDep = sharedDep.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            const importPatterns = [
+              new RegExp(`from\\s+['"]${escapedDep}['"]`, 'g'),
+              new RegExp(`import\\s+.*\\s+from\\s+['"]${escapedDep}['"]`, 'g'),
+              new RegExp(`require\\s*\\(\\s*['"]${escapedDep}['"]\\s*\\)`, 'g'),
+              new RegExp(`import\\s*\\(\\s*['"]${escapedDep}['"]\\s*\\)`, 'g'),
+            ];
+
+            const isUsed = importPatterns.some(pattern =>
+              pattern.test(content)
+            );
+
+            if (isUsed && !usageResults[sharedDep].includes(fullPath)) {
+              usageResults[sharedDep].push(fullPath);
+            }
+          }
+        }
+      }
+    }
+
+    // Find target directory and scan it
+    for (const dir of scanTargetDirs) {
+      const dirPath = path.resolve(cwd, dir);
+      if (fs.existsSync(dirPath) && fs.statSync(dirPath).isDirectory()) {
+        scanDir(dirPath);
+        break;
+      }
+    }
+
+    return usageResults;
+  }
+
+  // Main logic
+  scanPackageJsonFiles();
+  const usageResults = scanSourceFiles();
+
+  // Find issues
+  const issues: DependencyIssue[] = [];
+
+  for (const [dep, usedInFiles] of Object.entries(usageResults)) {
+    if (usedInFiles.length > 0 && !allDependencies.has(dep)) {
+      issues.push({
+        package: dep,
+        usedInFiles,
+      });
+    }
+  }
+
+    // Report results
+  if (issues.length > 0) {
+    logger.error('🚨 Shared dependency issues found:');
+    for (const issue of issues) {
+      logger.error(`\n📦 Package: ${issue.package}`);
+      logger.error(`   Used in ${issue.usedInFiles.length} files:`);
+      issue.usedInFiles.slice(0, 5).forEach(file => {
+        logger.error(`   - ${path.relative(cwd, file)}`);
+      });
+      if (issue.usedInFiles.length > 5) {
+        logger.error(`   ... and ${issue.usedInFiles.length - 5} more files`);
+      }
+      logger.error(`   ❌ Missing from package.json dependencies`);
+    }
+    return {
+      healthy: false,
+      issues
+    };
+  }
+  
+  logger.success('✅ All shared dependencies are properly declared');
+  return {
+    healthy: true,
+    issues: []
+  };
+}
+
+// Backwards compatibility - returns boolean for simple usage
+export function checkShareDependenciesSimple(): boolean {
+  return checkShareDependencies().healthy;
+}
+
+export default checkShareDependencies;