@clerk/upgrade 2.0.0-snapshot.v20251204175016 → 2.0.0-snapshot.v20251208202852

package/dist/codemods/transform-remove-deprecated-props.cjs

@@ -20,14 +20,13 @@ const COMPONENT_REDIRECT_ATTR = new Map([['ClerkProvider', {
 const COMPONENTS_WITH_USER_BUTTON_REMOVALS = new Map([['UserButton', ['afterSignOutUrl', 'afterMultiSessionSingleSignOutUrl']]]);
 const ORGANIZATION_SWITCHER_RENAMES = new Map([['afterSwitchOrganizationUrl', 'afterSelectOrganizationUrl']]);
 module.exports = function transformDeprecatedProps({
-  source,
-  path: filePath
+  source
 }, {
-  jscodeshift: j
-}, options = {}) {
+  jscodeshift: j,
+  stats
+}) {
   const root = j(source);
   let dirty = false;
-  const stats = options.clerkUpgradeStats;
   const {
     namedImports,
     namespaceImports
@@ -41,29 +40,15 @@ module.exports = function transformDeprecatedProps({
     if (COMPONENTS_WITH_HIDE_SLUG.has(canonicalName)) {
       if (removeJsxAttribute(j, jsxNode, 'hideSlug')) {
         dirty = true;
-        if (stats) {
-          stats.hideSlugRemoved = (stats.hideSlugRemoved || 0) + 1;
-          stats.hideSlugFiles = stats.hideSlugFiles || [];
-          if (!stats.hideSlugFiles.includes(filePath)) {
-            stats.hideSlugFiles.push(filePath);
-          }
-        }
+        stats('hideSlugRemoved');
       }
     }
     if (COMPONENTS_WITH_USER_BUTTON_REMOVALS.has(canonicalName)) {
       const propsToRemove = COMPONENTS_WITH_USER_BUTTON_REMOVALS.get(canonicalName);
-      let removedCount = 0;
       for (const attrName of propsToRemove) {
         if (removeJsxAttribute(j, jsxNode, attrName)) {
           dirty = true;
-          removedCount += 1;
-        }
-      }
-      if (removedCount > 0 && stats) {
-        stats.userbuttonAfterSignOutPropsRemoved = (stats.userbuttonAfterSignOutPropsRemoved || 0) + removedCount;
-        stats.userbuttonFilesAffected = stats.userbuttonFilesAffected || [];
-        if (!stats.userbuttonFilesAffected.includes(filePath)) {
-          stats.userbuttonFilesAffected.push(filePath);
+          stats('userbuttonAfterSignOutPropsRemoved');
         }
       }
     }
@@ -115,7 +100,7 @@ module.exports = function transformDeprecatedProps({
   if (renameObjectProperties(root, j, 'activeSessions', 'signedInSessions')) {
     dirty = true;
   }
-  if (transformSetActiveBeforeEmit(root, j, stats, filePath)) {
+  if (transformSetActiveBeforeEmit(root, j, stats)) {
     dirty = true;
   }
   if (renameTypeReferences(root, j, 'ClerkMiddlewareAuthObject', 'ClerkMiddlewareSessionAuthObject')) {
@@ -338,7 +323,7 @@ function renameTSPropertySignatures(root, j, oldName, newName) {
   });
   return changed;
 }
-function transformSetActiveBeforeEmit(root, j, stats, filePath) {
+function transformSetActiveBeforeEmit(root, j, stats) {
   let changed = false;
   root.find(j.CallExpression).filter(path => isSetActiveCall(path.node.callee)).forEach(path => {
     const [args0] = path.node.arguments;
@@ -362,13 +347,7 @@ function transformSetActiveBeforeEmit(root, j, stats, filePath) {
     const navigateProp = j.objectProperty(j.identifier('navigate'), buildNavigateArrowFunction(j, originalValue));
     args0.properties.splice(beforeEmitIndex, 1, navigateProp);
     changed = true;
-    if (stats) {
-      stats.beforeEmitTransformed = (stats.beforeEmitTransformed || 0) + 1;
-      stats.beforeEmitFiles = stats.beforeEmitFiles || [];
-      if (!stats.beforeEmitFiles.includes(filePath)) {
-        stats.beforeEmitFiles.push(filePath);
-      }
-    }
+    stats('beforeEmitTransformed');
   });
   return changed;
 }
@@ -399,8 +378,8 @@ function getPropertyValueExpression(valueNode) {
 }
 function buildNavigateArrowFunction(j, originalExpression) {
   const paramIdentifier = j.identifier('params');
-  const calleeExpression = clone(originalExpression);
-  const callExpression = j.callExpression(calleeExpression, [j.memberExpression(paramIdentifier, j.identifier('session'))]);
+  // No need to clone - we're moving the expression from beforeEmit to navigate
+  const callExpression = j.callExpression(originalExpression, [j.memberExpression(paramIdentifier, j.identifier('session'))]);
   return j.arrowFunctionExpression([paramIdentifier], callExpression);
 }
 function renameTypeReferences(root, j, oldName, newName) {

package/dist/codemods/transform-themes-to-ui-themes.cjs

@@ -0,0 +1,65 @@
+const LEGACY_PACKAGE = '@clerk/themes';
+const TARGET_PACKAGE = '@clerk/ui/themes';
+const isStringLiteral = (j, node) => j.Literal.check(node) && typeof node.value === 'string' || j.StringLiteral && j.StringLiteral.check(node);
+const getReplacement = value => {
+  if (typeof value !== 'string' || !value.startsWith(LEGACY_PACKAGE)) {
+    return null;
+  }
+  return `${TARGET_PACKAGE}${value.slice(LEGACY_PACKAGE.length)}`;
+};
+module.exports = function transformThemesToUiThemes({
+  source
+}, {
+  jscodeshift: j
+}) {
+  const root = j(source);
+  let dirty = false;
+  const replaceSourceLiteral = literal => {
+    if (!isStringLiteral(j, literal)) {
+      return;
+    }
+    const nextValue = getReplacement(literal.value);
+    if (nextValue && nextValue !== literal.value) {
+      literal.value = nextValue;
+      dirty = true;
+    }
+  };
+  root.find(j.ImportDeclaration).forEach(path => {
+    replaceSourceLiteral(path.node.source);
+  });
+  root.find(j.ExportNamedDeclaration).forEach(path => {
+    if (path.node.source) {
+      replaceSourceLiteral(path.node.source);
+    }
+  });
+  root.find(j.ExportAllDeclaration).forEach(path => {
+    replaceSourceLiteral(path.node.source);
+  });
+  root.find(j.CallExpression, {
+    callee: {
+      name: 'require'
+    }
+  }).forEach(path => {
+    const [arg] = path.node.arguments || [];
+    if (arg) {
+      replaceSourceLiteral(arg);
+    }
+  });
+  if (j.ImportExpression) {
+    root.find(j.ImportExpression).forEach(path => {
+      replaceSourceLiteral(path.node.source);
+    });
+  }
+  root.find(j.CallExpression, {
+    callee: {
+      type: 'Import'
+    }
+  }).forEach(path => {
+    const [arg] = path.node.arguments || [];
+    if (arg) {
+      replaceSourceLiteral(arg);
+    }
+  });
+  return dirty ? root.toSource() : undefined;
+};
+module.exports.parser = 'tsx';

package/dist/config.js

@@ -0,0 +1,122 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import matter from 'gray-matter';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const VERSIONS_DIR = path.join(__dirname, 'versions');
+export async function loadConfig(sdk, currentVersion) {
+  const versionDirs = fs.readdirSync(VERSIONS_DIR, {
+    withFileTypes: true
+  }).filter(d => d.isDirectory()).map(d => d.name);
+  let applicableConfig = null;
+  for (const versionDir of versionDirs) {
+    const configPath = path.join(VERSIONS_DIR, versionDir, 'index.js');
+    if (!fs.existsSync(configPath)) {
+      continue;
+    }
+    const moduleUrl = pathToFileURL(configPath).href;
+    const mod = await import(moduleUrl);
+    const config = mod.default ?? mod;
+    if (!config.sdkVersions) {
+      continue;
+    }
+    const versionStatus = getVersionStatus(config, sdk, currentVersion);
+    if (versionStatus === 'unsupported' || versionStatus === 'unknown') {
+      continue;
+    }
+    if (versionStatus === 'needs-upgrade') {
+      const changes = loadChanges(versionDir, sdk);
+      return {
+        ...config,
+        changes,
+        versionStatus,
+        needsUpgrade: true,
+        alreadyUpgraded: false
+      };
+    }
+    if (versionStatus === 'already-upgraded' && !applicableConfig) {
+      applicableConfig = {
+        config,
+        versionDir
+      };
+    }
+  }
+  if (applicableConfig) {
+    const changes = loadChanges(applicableConfig.versionDir, sdk);
+    return {
+      ...applicableConfig.config,
+      changes,
+      versionStatus: 'already-upgraded',
+      needsUpgrade: false,
+      alreadyUpgraded: true
+    };
+  }
+  return null;
+}
+function getVersionStatus(config, sdk, currentVersion) {
+  if (!config?.sdkVersions) {
+    return 'unknown';
+  }
+  const range = config.sdkVersions[sdk];
+  if (!range) {
+    return 'unknown';
+  }
+  if (typeof currentVersion !== 'number') {
+    return 'unknown';
+  }
+  if (typeof range.from === 'number' && currentVersion < range.from) {
+    return 'unsupported';
+  }
+  if (typeof range.to === 'number' && currentVersion >= range.to) {
+    return 'already-upgraded';
+  }
+  return 'needs-upgrade';
+}
+export function getTargetPackageName(sdk) {
+  if (sdk === 'clerk-react' || sdk === 'react') {
+    return '@clerk/react';
+  }
+  if (sdk === 'clerk-expo' || sdk === 'expo') {
+    return '@clerk/expo';
+  }
+  return `@clerk/${sdk}`;
+}
+export function getOldPackageName(sdk) {
+  if (sdk === 'clerk-react' || sdk === 'react') {
+    return '@clerk/clerk-react';
+  }
+  if (sdk === 'clerk-expo' || sdk === 'expo') {
+    return '@clerk/clerk-expo';
+  }
+  return null;
+}
+function loadChanges(versionDir, sdk) {
+  const changesDir = path.join(VERSIONS_DIR, versionDir, 'changes');
+  if (!fs.existsSync(changesDir)) {
+    return [];
+  }
+  const files = fs.readdirSync(changesDir).filter(f => f.endsWith('.md'));
+  const changes = [];
+  for (const file of files) {
+    const filePath = path.join(changesDir, file);
+    const content = fs.readFileSync(filePath, 'utf8');
+    const parsed = matter(content);
+    const fm = parsed.data;
+    const packages = fm.packages || ['*'];
+    const appliesToSdk = packages.includes('*') || packages.includes(sdk);
+    if (!appliesToSdk) {
+      continue;
+    }
+    const matcher = fm.matcher ? Array.isArray(fm.matcher) ? fm.matcher.map(m => new RegExp(m, `g${fm.matcherFlags || ''}`)) : new RegExp(fm.matcher, `g${fm.matcherFlags || ''}`) : null;
+    changes.push({
+      title: fm.title,
+      matcher,
+      packages,
+      category: fm.category || 'breaking',
+      warning: fm.warning || fm.category === 'warning',
+      docsAnchor: fm.docsAnchor || file.replace('.md', ''),
+      content: parsed.content
+    });
+  }
+  return changes;
+}

package/dist/render.js

@@ -0,0 +1,164 @@
+import * as readline from 'node:readline';
+import chalk from 'chalk';
+export function renderHeader() {
+  console.log('');
+  console.log(chalk.magenta.bold('>> Clerk Upgrade CLI <<'));
+  console.log('');
+}
+export function renderText(message, color) {
+  const colorFn = chalk[color] || (s => s);
+  console.log(colorFn(message));
+}
+export function renderSuccess(message) {
+  console.log(chalk.green(`✅ ${message}`));
+}
+export function renderError(message) {
+  console.error(chalk.red(`⛔ ${message}`));
+}
+export function renderWarning(message) {
+  console.log(chalk.yellow(`⚠️ ${message}`));
+}
+export function renderNewline() {
+  console.log('');
+}
+export function renderConfig({
+  sdk,
+  currentVersion,
+  fromVersion,
+  toVersion,
+  versionName,
+  dir,
+  packageManager
+}) {
+  console.log(`🔧 ${chalk.bold('Upgrade config')}`);
+  const versionSuffix = currentVersion ? ` ${chalk.gray(`(v${currentVersion})`)}` : '';
+  console.log(`Clerk SDK: ${chalk.green(`@clerk/${sdk}`)}${versionSuffix}`);
+  if (fromVersion && toVersion) {
+    const versionLabel = versionName ? ` ${chalk.gray(`(${versionName})`)}` : '';
+    console.log(`Upgrade: ${chalk.green(`v${fromVersion}`)} → ${chalk.green(`v${toVersion}`)}${versionLabel}`);
+  }
+  console.log(`Directory: ${chalk.green(dir)}`);
+  if (packageManager) {
+    console.log(`Package manager: ${chalk.green(packageManager)}`);
+  }
+  console.log('');
+}
+export async function promptConfirm(message) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise(resolve => {
+    rl.question(`${message} (y/n): `, answer => {
+      rl.close();
+      resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+    });
+  });
+}
+export async function promptSelect(message, options) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  console.log(message);
+  options.forEach((opt, i) => {
+    console.log(`  ${i + 1}) ${opt.label}`);
+  });
+  return new Promise(resolve => {
+    rl.question('Enter number: ', answer => {
+      rl.close();
+      const index = parseInt(answer, 10) - 1;
+      if (index >= 0 && index < options.length) {
+        resolve(options[index].value);
+      } else {
+        resolve(null);
+      }
+    });
+  });
+}
+export async function promptText(message, defaultValue = '') {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const prompt = defaultValue ? `${message} [${defaultValue}]: ` : `${message}: `;
+  return new Promise(resolve => {
+    rl.question(prompt, answer => {
+      rl.close();
+      resolve(answer || defaultValue);
+    });
+  });
+}
+const spinnerFrames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+export function createSpinner(label) {
+  let frameIndex = 0;
+  let interval = null;
+  let currentLabel = label;
+  const start = () => {
+    interval = setInterval(() => {
+      process.stdout.write(`\r${spinnerFrames[frameIndex]} ${currentLabel}`);
+      frameIndex = (frameIndex + 1) % spinnerFrames.length;
+    }, 80);
+  };
+  start();
+  return {
+    update(newLabel) {
+      currentLabel = newLabel;
+    },
+    stop() {
+      if (interval) {
+        clearInterval(interval);
+        interval = null;
+        process.stdout.write('\r\x1b[K');
+      }
+    },
+    success(message) {
+      if (interval) {
+        clearInterval(interval);
+        interval = null;
+      }
+      process.stdout.write(`\r\x1b[K${chalk.green('✓')} ${message}\n`);
+    },
+    error(message) {
+      if (interval) {
+        clearInterval(interval);
+        interval = null;
+      }
+      process.stdout.write(`\r\x1b[K${chalk.red('✗')} ${message}\n`);
+    }
+  };
+}
+export function renderCodemodResults(transform, result) {
+  console.log(`  ${result.ok ?? 0} file(s) modified, ${chalk.red(`  ${result.error ?? 0} errors`)}`);
+  console.log('');
+}
+export function renderScanResults(results, docsUrl) {
+  if (results.length === 0) {
+    console.log(chalk.green('✓ No breaking changes detected!'));
+    console.log('');
+    return;
+  }
+  console.log(chalk.yellow.bold(`Found ${results.length} potential issue(s) to review:`));
+  console.log('');
+  for (const item of results) {
+    console.log(chalk.bold(item.title));
+    if (item.warning) {
+      console.log(chalk.yellow('(warning - may not require action)'));
+    }
+    console.log(chalk.gray(`Found ${item.instances.length} instance(s):`));
+    for (const inst of item.instances) {
+      console.log(chalk.gray(`  ${inst.file}:${inst.position.line}:${inst.position.column}`));
+    }
+    const link = docsUrl && item.docsAnchor ? `${docsUrl}#${item.docsAnchor}` : null;
+    if (link) {
+      console.log(chalk.blue(`→ View in migration guide: ${link}`));
+    }
+    console.log('');
+  }
+}
+export function renderComplete(sdk, docsUrl) {
+  console.log(chalk.green.bold(`✅ Upgrade complete for @clerk/${sdk}`));
+  console.log('');
+  console.log(`Review the changes above and test your application before deployment.`);
+  console.log(chalk.gray(`For more information, see the migration guide: ${docsUrl}`));
+}

package/dist/runner.js

@@ -0,0 +1,98 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import chalk from 'chalk';
+import { convertPathToPattern, globby } from 'globby';
+import indexToPosition from 'index-to-position';
+import { getCodemodConfig, runCodemod } from './codemods/index.js';
+import { createSpinner, renderCodemodResults } from './render.js';
+const GLOBBY_IGNORE = ['node_modules/**', '**/node_modules/**', '.git/**', 'dist/**', '**/dist/**', 'build/**', '**/build/**', '.next/**', '**/.next/**', 'package.json', '**/package.json', 'package-lock.json', '**/package-lock.json', 'yarn.lock', '**/yarn.lock', 'pnpm-lock.yaml', '**/pnpm-lock.yaml', '**/*.(png|webp|svg|gif|jpg|jpeg)+', '**/*.(mp4|mkv|wmv|m4v|mov|avi|flv|webm|flac|mka|m4a|aac|ogg)+'];
+export async function runCodemods(config, sdk, options) {
+  const codemods = config.codemods || [];
+  if (codemods.length === 0) {
+    return;
+  }
+  const glob = typeof options.glob === 'string' ? options.glob.split(/[ ,]/).filter(Boolean) : options.glob;
+  for (const transform of codemods) {
+    const spinner = createSpinner(`Running codemod: ${transform}`);
+    try {
+      const result = await runCodemod(transform, glob, options);
+      spinner.success(`Codemod applied: ${chalk.dim(transform)}`);
+      renderCodemodResults(transform, result);
+      const codemodConfig = getCodemodConfig(transform);
+      if (codemodConfig?.renderSummary && result.stats) {
+        codemodConfig.renderSummary(result.stats);
+      }
+    } catch (error) {
+      spinner.error(`Codemod failed: ${transform}`);
+      throw error;
+    }
+  }
+}
+export async function runScans(config, sdk, options) {
+  const matchers = loadMatchers(config, sdk);
+  if (matchers.length === 0) {
+    return [];
+  }
+  const spinner = createSpinner('Scanning files for breaking changes...');
+  try {
+    const pattern = convertPathToPattern(path.resolve(options.dir));
+    const files = await globby(pattern, {
+      ignore: [...GLOBBY_IGNORE, ...(options.ignore || [])]
+    });
+    const results = {};
+    for (let idx = 0; idx < files.length; idx++) {
+      const file = files[idx];
+      spinner.update(`Scanning ${path.basename(file)} (${idx + 1}/${files.length})`);
+      const content = await fs.readFile(file, 'utf8');
+      for (const matcher of matchers) {
+        const matches = findMatches(content, matcher.matcher);
+        if (matches.length === 0) {
+          continue;
+        }
+        if (!results[matcher.title]) {
+          results[matcher.title] = {
+            instances: [],
+            ...matcher
+          };
+        }
+        for (const match of matches) {
+          const position = indexToPosition(content, match.index, {
+            oneBased: true
+          });
+          const fileRelative = path.relative(process.cwd(), file);
+          const isDuplicate = results[matcher.title].instances.some(i => i.position.line === position.line && i.position.column === position.column && i.file === fileRelative);
+          if (!isDuplicate) {
+            results[matcher.title].instances.push({
+              sdk,
+              position,
+              file: fileRelative
+            });
+          }
+        }
+      }
+    }
+    spinner.success(`Scanned ${files.length} files`);
+    return Object.values(results);
+  } catch (error) {
+    spinner.error('Scan failed');
+    throw error;
+  }
+}
+function loadMatchers(config, sdk) {
+  if (!config.changes) {
+    return [];
+  }
+  return config.changes.filter(change => {
+    if (!change.matcher) {
+      return false;
+    }
+    const packages = change.packages || ['*'];
+    return packages.includes('*') || packages.includes(sdk);
+  });
+}
+function findMatches(content, matcher) {
+  if (Array.isArray(matcher)) {
+    return matcher.flatMap(m => Array.from(content.matchAll(m)));
+  }
+  return Array.from(content.matchAll(matcher));
+}

package/dist/util/detect-sdk.js

@@ -0,0 +1,125 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { readPackageSync } from 'read-pkg';
+import semverRegex from 'semver-regex';
+import { getOldPackageName } from '../config.js';
+const SUPPORTED_SDKS = [{
+  label: '@clerk/nextjs',
+  value: 'nextjs'
+}, {
+  label: '@clerk/react',
+  value: 'react'
+}, {
+  label: '@clerk/clerk-react',
+  value: 'react'
+}, {
+  label: '@clerk/expo',
+  value: 'expo'
+}, {
+  label: '@clerk/clerk-expo',
+  value: 'expo'
+}, {
+  label: '@clerk/react-router',
+  value: 'react-router'
+}, {
+  label: '@clerk/tanstack-react-start',
+  value: 'tanstack-react-start'
+}, {
+  label: '@clerk/astro',
+  value: 'astro'
+}, {
+  label: '@clerk/nuxt',
+  value: 'nuxt'
+}, {
+  label: '@clerk/vue',
+  value: 'vue'
+}, {
+  label: '@clerk/express',
+  value: 'express'
+}, {
+  label: '@clerk/fastify',
+  value: 'fastify'
+}, {
+  label: '@clerk/clerk-js',
+  value: 'js'
+}, {
+  label: '@clerk/backend',
+  value: 'backend'
+}];
+export function getSupportedSdks() {
+  return SUPPORTED_SDKS;
+}
+export function detectSdk(dir) {
+  let pkg;
+  try {
+    const pkgPath = path.join(dir, 'package.json');
+    pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+  } catch {
+    return null;
+  }
+  const deps = pkg.dependencies ? Object.keys(pkg.dependencies) : [];
+  const devDeps = pkg.devDependencies ? Object.keys(pkg.devDependencies) : [];
+  const allDeps = [...deps, ...devDeps];
+  for (const {
+    label,
+    value
+  } of SUPPORTED_SDKS) {
+    if (allDeps.includes(label)) {
+      return value;
+    }
+  }
+  return null;
+}
+export function getSdkVersion(sdk, dir) {
+  let pkg;
+  try {
+    pkg = readPackageSync({
+      cwd: dir
+    });
+  } catch {
+    return null;
+  }
+  const pkgName = sdk.startsWith('@clerk/') ? sdk : `@clerk/${sdk}`;
+  const oldPkgName = getOldPackageName(sdk);
+  const version = pkg.dependencies?.[pkgName] || pkg.devDependencies?.[pkgName] || oldPkgName && pkg.dependencies?.[oldPkgName] || oldPkgName && pkg.devDependencies?.[oldPkgName];
+  if (!version) {
+    return null;
+  }
+  return getMajorVersion(version);
+}
+export function getMajorVersion(semver) {
+  const cleaned = semver.replace(/^[\^~]/, '');
+  const match = cleaned.match(semverRegex());
+  if (match) {
+    const [major] = match[0].split('.');
+    return parseInt(major, 10);
+  }
+  return null;
+}
+export function getInstalledClerkPackages(dir) {
+  let pkg;
+  try {
+    const pkgPath = path.join(dir, 'package.json');
+    pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+  } catch {
+    return {};
+  }
+  const deps = pkg.dependencies ? Object.entries(pkg.dependencies) : [];
+  const devDeps = pkg.devDependencies ? Object.entries(pkg.devDependencies) : [];
+  return Object.fromEntries([...deps, ...devDeps].filter(([name]) => name.startsWith('@clerk/')).map(([name, version]) => [name, getMajorVersion(version)]));
+}
+export function normalizeSdkName(sdk) {
+  if (!sdk) {
+    return null;
+  }
+  if (sdk.startsWith('@clerk/')) {
+    return sdk.replace('@clerk/', '');
+  }
+  if (sdk === 'clerk-react') {
+    return 'react';
+  }
+  if (sdk === 'clerk-expo') {
+    return 'expo';
+  }
+  return sdk;
+}