Compatibility Utilities

/**
 * Get current Nuxt version
 * @param nuxt - Nuxt instance (defaults to current context)
 * @returns Nuxt version string
 */
function getNuxtVersion(nuxt?: Nuxt): string;

/**
 * Check if current Nuxt instance is of specified major version
 * @param majorVersion - Major version to check (2, 3, or 4)
 * @param nuxt - Nuxt instance (defaults to current context)
 * @returns True if major version matches
 */
function isNuxtMajorVersion(majorVersion: 2 | 3 | 4, nuxt?: Nuxt): boolean;

/**
 * Normalize semantic version by removing edge prefixes
 * @param version - Version string to normalize
 * @returns Normalized semantic version
 */
function normalizeSemanticVersion(version: string): string;

import { 
  getNuxtVersion, 
  isNuxtMajorVersion, 
  normalizeSemanticVersion 
} from "@nuxt/kit";

// Get current version
const version = getNuxtVersion();
console.log(`Running Nuxt ${version}`);

// Check major version
if (isNuxtMajorVersion(3)) {
  console.log("Running Nuxt 3");
} else if (isNuxtMajorVersion(2)) {
  console.log("Running Nuxt 2");
}

// Normalize version strings
const normalized = normalizeSemanticVersion("3.0.0-edge.1");
// Returns: "3.0.0"

/**
 * Check if constraints are satisfied
 * @param constraints - Compatibility constraints
 * @param nuxt - Nuxt instance (defaults to current context)
 * @returns Promise resolving to compatibility boolean
 */
function hasNuxtCompatibility(
  constraints: NuxtCompatibility,
  nuxt?: Nuxt
): Promise<boolean>;

/**
 * Check version constraints and return incompatibility issues
 * @param constraints - Compatibility constraints
 * @param nuxt - Nuxt instance (defaults to current context)
 * @returns Promise resolving to compatibility issues
 */
function checkNuxtCompatibility(
  constraints: NuxtCompatibility,
  nuxt?: Nuxt
): Promise<NuxtCompatibilityIssues>;

/**
 * Assert compatibility constraints, throw error if failed
 * @param constraints - Compatibility constraints
 * @param nuxt - Nuxt instance (defaults to current context)
 * @returns Promise resolving to true if compatible
 * @throws Error if compatibility check fails
 */
function assertNuxtCompatibility(
  constraints: NuxtCompatibility,
  nuxt?: Nuxt
): Promise<true>;

interface NuxtCompatibility {
  /** Nuxt version constraint (semver range) */
  nuxt?: string;
  /** Bridge compatibility flag */
  bridge?: boolean;
  /** Node.js version constraint */
  node?: string;
}

interface NuxtCompatibilityIssues extends Array<NuxtCompatibilityIssue> {
  /** Return formatted error message */
  toString(): string;
}

interface NuxtCompatibilityIssue {
  /** Issue name/type */
  name: string;
  /** Issue description */
  message: string;
}

import { 
  hasNuxtCompatibility, 
  checkNuxtCompatibility, 
  assertNuxtCompatibility 
} from "@nuxt/kit";

// Simple compatibility check
const isCompatible = await hasNuxtCompatibility({
  nuxt: "^3.0.0"
});

if (isCompatible) {
  console.log("Module is compatible");
}

// Detailed compatibility check
const issues = await checkNuxtCompatibility({
  nuxt: "^3.0.0",
  bridge: false,
  node: ">=16.0.0"
});

if (issues.length > 0) {
  console.log("Compatibility issues found:");
  issues.forEach(issue => {
    console.log(`- ${issue.name}: ${issue.message}`);
  });
  
  // Or use the formatted output
  console.log(issues.toString());
}

// Assert compatibility (throws on failure)
try {
  await assertNuxtCompatibility({
    nuxt: "^3.0.0"
  });
  console.log("Compatibility check passed");
} catch (error) {
  console.error("Compatibility check failed:", error.message);
}

export default defineNuxtModule({
  meta: {
    name: "my-module",
    compatibility: {
      nuxt: "^3.0.0",
      bridge: false
    }
  },
  async setup(options, nuxt) {
    // Manual compatibility check
    await assertNuxtCompatibility({
      nuxt: "^3.0.0"
    });
    
    // Conditional logic based on version
    const version = getNuxtVersion();
    if (version.startsWith("3.")) {
      // Nuxt 3 specific setup
    }
  }
});

/**
 * Check if running Nuxt 2
 * @deprecated Use isNuxtMajorVersion(2) instead
 * @param nuxt - Nuxt instance (defaults to current context)
 * @returns True if running Nuxt 2
 */
function isNuxt2(nuxt?: Nuxt): boolean;

/**
 * Check if running Nuxt 3
 * @deprecated Use isNuxtMajorVersion(3) instead
 * @param nuxt - Nuxt instance (defaults to current context)
 * @returns True if running Nuxt 3
 */
function isNuxt3(nuxt?: Nuxt): boolean;

import { 
  isNuxtMajorVersion, 
  hasNuxtCompatibility,
  addComponent 
} from "@nuxt/kit";

export default defineNuxtModule({
  meta: {
    name: "advanced-module",
    compatibility: {
      nuxt: ">=3.0.0"
    }
  },
  async setup(options, nuxt) {
    // Check if Nuxt 3.5+ for specific features
    const hasAdvancedFeatures = await hasNuxtCompatibility({
      nuxt: ">=3.5.0"
    });
    
    if (hasAdvancedFeatures) {
      // Use newer APIs
      addComponent({
        name: "AdvancedComponent",
        filePath: "~/components/Advanced.vue",
        island: true // Islands feature requires 3.5+
      });
    } else {
      // Fallback for older versions
      addComponent({
        name: "BasicComponent",
        filePath: "~/components/Basic.vue"
      });
    }
  }
});

import { 
  checkNuxtCompatibility, 
  getNuxtVersion,
  useLogger 
} from "@nuxt/kit";

export default defineNuxtModule({
  async setup(options, nuxt) {
    const logger = useLogger("my-module");
    const version = getNuxtVersion();
    
    // Check for ideal version
    const idealIssues = await checkNuxtCompatibility({
      nuxt: "^3.8.0"
    });
    
    if (idealIssues.length === 0) {
      logger.info("Using full feature set");
      // Enable all features
    } else {
      // Check minimum version
      const minIssues = await checkNuxtCompatibility({
        nuxt: "^3.0.0"
      });
      
      if (minIssues.length === 0) {
        logger.warn(`Limited features on Nuxt ${version}`);
        // Enable basic features only
      } else {
        logger.error("Incompatible Nuxt version");
        throw new Error("This module requires Nuxt 3.0.0 or higher");
      }
    }
  }
});

import { 
  hasNuxtCompatibility,
  isNuxtMajorVersion 
} from "@nuxt/kit";

export default defineNuxtModule({
  async setup(options, nuxt) {
    // Check Node.js compatibility
    const nodeCompat = await hasNuxtCompatibility({
      node: ">=18.0.0"
    });
    
    if (!nodeCompat) {
      throw new Error("This module requires Node.js 18 or higher");
    }
    
    // Bridge compatibility
    if (nuxt.options.bridge && !isNuxtMajorVersion(3)) {
      const bridgeCompat = await hasNuxtCompatibility({
        bridge: true
      });
      
      if (!bridgeCompat) {
        throw new Error("Nuxt Bridge is required for Nuxt 2 compatibility");
      }
    }
  }
});

import { 
  getNuxtVersion,
  isNuxtMajorVersion,
  useLogger 
} from "@nuxt/kit";

export default defineNuxtModule({
  setup(options, nuxt) {
    const logger = useLogger("migration-helper");
    const version = getNuxtVersion();
    
    if (isNuxtMajorVersion(2)) {
      logger.warn("Nuxt 2 support is deprecated");
      logger.info("Please migrate to Nuxt 3 for continued support");
      logger.info("Migration guide: https://nuxt.com/docs/migration/overview");
    }
    
    if (version.includes("edge")) {
      logger.warn("Using edge version - expect breaking changes");
    }
  }
});

interface VersionInfo {
  /** Major version number */
  major: number;
  /** Minor version number */
  minor: number;
  /** Patch version number */
  patch: number;
  /** Pre-release identifier */
  prerelease?: string;
  /** Build metadata */
  build?: string;
}