fix: Better detection version (#2801)

* step 1 of version

* start managing things

* adding semver to test

* let's not redo semver!

* better fallback

* not only this ;)

* Update version.ts

---------

Co-authored-by: Simon H <5968653+dummdidumm@users.noreply.github.com>

Author: jycouet

packages/svelte-vscode/package.json

@@ -741,8 +741,10 @@
     "devDependencies": {
         "@types/lodash": "^4.14.116",
         "@types/node": "^18.0.0",
+        "@types/semver": "^7.7.0",
         "@types/vscode": "^1.67",
         "js-yaml": "^3.14.0",
+        "semver": "^7.7.2",
         "tslib": "^2.4.0",
         "typescript": "^5.8.2",
         "vitest": "^3.2.4",

packages/svelte-vscode/src/sveltekit/utils.ts

@@ -2,6 +2,7 @@ import { TextDecoder } from 'util';
 import * as path from 'path';
 import { Uri, workspace } from 'vscode';
 import type { GenerateConfig } from './generateFiles/types';
+import { atLeast } from '../version';
 
 export async function fileExists(file: string) {
     try {
@@ -31,10 +32,20 @@ export async function checkProjectKind(path: string): Promise<GenerateConfig['ki
     const jsconfig = await findFile(path, 'jsconfig.json');
 
     const svelteVersion = await getVersionFromPackageJson('svelte');
-    const withRunes = svelteVersion ? versionAtLeast(svelteVersion, 5) : true;
+    const withRunes = atLeast({
+        packageName: 'svelte',
+        versionMin: '5',
+        versionToCheck: svelteVersion ?? '',
+        fallback: true
+    });
 
     const svelteKitVersion = await getVersionFromPackageJson('@sveltejs/kit');
-    let withProps = svelteKitVersion ? versionAtLeast(svelteKitVersion, 2, 16) : true;
+    let withProps = atLeast({
+        packageName: '@sveltejs/kit',
+        versionMin: '2.16',
+        versionToCheck: svelteKitVersion ?? '',
+        fallback: true
+    });
 
     const withTs = !!tsconfig && (!jsconfig || tsconfig.length >= jsconfig.length);
     let withSatisfies = false;
@@ -44,7 +55,12 @@ export async function checkProjectKind(path: string): Promise<GenerateConfig['ki
                 paths: [tsconfig]
             });
             const { version } = require(packageJSONPath);
-            withSatisfies = version ? versionAtLeast(version, 4, 9) : true;
+            withSatisfies = atLeast({
+                packageName: 'typescript',
+                versionMin: '4.9',
+                versionToCheck: version,
+                fallback: true
+            });
         } catch (e) {
             withSatisfies = true;
         }
@@ -58,14 +74,6 @@ export async function checkProjectKind(path: string): Promise<GenerateConfig['ki
     };
 }
 
-function versionAtLeast(version: string, major: number, minor?: number): boolean {
-    const [majorVersion, minorVersion] = version.split('.');
-    return (
-        (Number(majorVersion) === major && Number(minorVersion) >= (minor ?? 0)) ||
-        Number(majorVersion) > major
-    );
-}
-
 export async function getVersionFromPackageJson(packageName: string): Promise<string | undefined> {
     const packageJsonList = await workspace.findFiles('**/package.json', '**/node_modules/**');
 

packages/svelte-vscode/src/version.ts

@@ -0,0 +1,51 @@
+import { lt, coerce, gte } from 'semver';
+
+/**
+ * @example
+ * const supported = atLeast({
+ *     packageName: 'node',
+ *     versionMin: '18.3',
+ *     versionToCheck: process.versions.node
+ *     fallback: true // optional
+ * });
+ */
+export function atLeast(o: {
+    packageName: string;
+    versionMin: string;
+    versionToCheck: string;
+    fallback: boolean;
+}): boolean;
+export function atLeast(o: {
+    packageName: string;
+    versionMin: string;
+    versionToCheck: string;
+    fallback?: undefined;
+}): boolean | undefined;
+
+// Implementation
+export function atLeast(o: {
+    packageName: string;
+    versionMin: string;
+    versionToCheck: string;
+    fallback?: boolean;
+}): boolean | undefined {
+    const { packageName, versionMin, versionToCheck, fallback } = o;
+    if (versionToCheck === undefined || versionToCheck === '') return fallback;
+
+    if (
+        versionToCheck.includes('latest') ||
+        versionToCheck.includes('catalog:') ||
+        versionToCheck.includes('http')
+    ) {
+        console.warn(`Version '${versionToCheck}' for '${packageName}' is not supported`);
+        return fallback;
+    }
+    try {
+        const vMin = coerce(versionMin);
+        const vToCheck = coerce(versionToCheck);
+        if (vMin && vToCheck) {
+            return gte(vToCheck, vMin);
+        }
+    } catch (error) {}
+    return fallback;
+}

packages/svelte-vscode/test/version.spec.ts

@@ -0,0 +1,41 @@
+import { expect, describe, it } from 'vitest';
+import { atLeast } from '../src/version';
+
+describe('atLeast', () => {
+    const combinationsAtLeast = [
+        { min: '5', version: '>=5', supported: true },
+        { min: '5', version: '>=5.0.0', supported: true },
+        { min: '5', version: '5.0.0', supported: true },
+        { min: '5', version: '5', supported: true },
+        { min: '5', version: '4', supported: false },
+        { min: '5', version: '4.9', supported: false },
+        { min: '5', version: '', supported: undefined },
+        { min: '5', version: 'catalog:', supported: undefined },
+        { min: '5', version: 'latest', supported: undefined },
+        { min: '5', version: 'latest', fallback: true, supported: true },
+        { min: '5', version: 'latest', fallback: false, supported: false }
+    ];
+    it.each(combinationsAtLeast)(
+        '(min $min, $version, $fallback) => $supported',
+        ({ min, version, supported, fallback }) => {
+            if (fallback !== undefined) {
+                expect(
+                    atLeast({
+                        packageName: 'myPkg',
+                        versionMin: min,
+                        versionToCheck: version,
+                        fallback
+                    })
+                ).toEqual(supported);
+            } else {
+                expect(
+                    atLeast({
+                        packageName: 'myPkg',
+                        versionMin: min,
+                        versionToCheck: version
+                    })
+                ).toEqual(supported);
+            }
+        }
+    );
+});