baseline-browser-mapping 0.3.1 → 1.0.0-beta.1

package/dist/scripts/baseline-browser-versions.d.ts

@@ -2,8 +2,8 @@ type BrowserVersion = {
     browser: string;
     version: string;
     release_date: string;
-    engine: string | null;
-    engine_version: string | null;
+    engine?: string;
+    engine_version?: string;
 };
 export declare function getMinimumWidelyAvailable(includeDownstream?: boolean): BrowserVersion[];
 export declare function getAllWidelyAvailable(includeDownstream?: boolean): BrowserVersion[];

package/dist/scripts/baseline-browser-versions.js

@@ -2,6 +2,7 @@ import { createRequire } from "node:module";
 const require = createRequire(import.meta.url);
 const bcdBrowsers = require("@mdn/browser-compat-data");
 const otherBrowsers = require("../data/downstream-browsers.json");
+import { features } from "web-features";
 const bcdCoreBrowserNames = [
     "chrome",
     "chrome_android",
@@ -23,6 +24,15 @@ const downstreamBrowserData = [
     ...Object.entries(otherBrowsers.browsers),
 ];
 const acceptableStatuses = ["current", "esr", "retired", "unknown"];
+const stripLTEPrefix = (str) => {
+    if (!str) {
+        return str;
+    }
+    if (!str.startsWith("≤")) {
+        return str;
+    }
+    return str.slice(1);
+};
 const compareVersions = (incomingVersionString, previousVersionString) => {
     let [incomingVersionStringMajor, incomingVersionStringMinor] = incomingVersionString.split(".");
     let [previousVersionStringMajor, previousVersionStringMinor] = previousVersionString.split(".");
@@ -33,8 +43,11 @@ const compareVersions = (incomingVersionString, previousVersionString) => {
             previousVersionString +
             "");
     }
+    if (parseInt(incomingVersionStringMajor) > parseInt(previousVersionStringMajor)) {
+        return 1;
+    }
     if (incomingVersionStringMinor) {
-        if (parseInt(incomingVersionStringMajor) >=
+        if (parseInt(incomingVersionStringMajor) ==
             parseInt(previousVersionStringMajor) &&
             (!previousVersionStringMinor ||
                 parseInt(incomingVersionStringMinor) >
@@ -42,59 +55,108 @@ const compareVersions = (incomingVersionString, previousVersionString) => {
             return 1;
         }
     }
-    else {
-        if (incomingVersionStringMajor > previousVersionStringMajor) {
-            return 1;
-        }
-    }
     return 0;
 };
+const getCompatibleFeaturesByDate = (date) => {
+    const compatibleFeatures = new Array();
+    Object.entries(features).forEach(([feature_id, feature]) => {
+        if (feature.status.baseline_low_date &&
+            new Date(feature.status.baseline_low_date) <= date) {
+            compatibleFeatures.push({
+                id: feature_id,
+                name: feature.name,
+                baseline_low_date: feature.status.baseline_low_date,
+                support: feature.status.support,
+            });
+        }
+    });
+    return compatibleFeatures;
+};
+const getMinimumVersionsFromFeatures = (features) => {
+    let minimumVersions = {};
+    Object.entries(coreBrowserData).forEach(([, browserData]) => {
+        minimumVersions[browserData[0]] = {
+            browser: browserData[0],
+            version: "0",
+            release_date: "",
+        };
+    });
+    features.forEach((feature) => {
+        Object.entries(feature.support).forEach((browser) => {
+            const browserName = browser[0];
+            const version = stripLTEPrefix(browser[1]);
+            if (minimumVersions[browserName] &&
+                compareVersions(version, stripLTEPrefix(minimumVersions[browserName].version)) === 1) {
+                minimumVersions[browserName] = {
+                    browser: browserName,
+                    version: version,
+                    release_date: feature.baseline_low_date,
+                };
+            }
+        });
+    });
+    return Object.values(minimumVersions);
+};
+const getSubsequentVersions = (minimumVersions) => {
+    let subsequentVersions = [];
+    minimumVersions.forEach((minimumVersion) => {
+        let bcdBrowser = coreBrowserData.find((bcdBrowser) => bcdBrowser[0] === minimumVersion.browser);
+        if (bcdBrowser) {
+            let sortedVersions = Object.entries(bcdBrowser[1].releases)
+                .filter(([, versionData]) => {
+                if (!acceptableStatuses.includes(versionData.status)) {
+                    return false;
+                }
+                return true;
+            })
+                .sort((a, b) => {
+                return compareVersions(a[0], b[0]);
+            });
+            sortedVersions.forEach(([version, versionData]) => {
+                if (!acceptableStatuses.includes(versionData.status)) {
+                    return false;
+                }
+                if (compareVersions(version, minimumVersion.version) === 1) {
+                    subsequentVersions.push({
+                        browser: minimumVersion.browser,
+                        version: version,
+                        release_date: versionData.release_date
+                            ? versionData.release_date
+                            : "unknown",
+                    });
+                    return true;
+                }
+                return false;
+            });
+        }
+    });
+    return subsequentVersions;
+};
 const getCoreVersionsByDate = (date, minOnly = true) => {
     if (date.getFullYear() < 2015) {
         throw new Error("There are no browser versions compatible with Baseline before 2015");
     }
-    if (date.getFullYear() >= new Date().getFullYear()) {
+    if (date.getFullYear() > new Date().getFullYear()) {
         throw new Error("There are no browser versions compatible with Baseline in the future");
     }
-    let versions = new Array();
-    coreBrowserData.forEach(([browserName, browserData]) => {
-        let sortedVersions = Object.entries(browserData.releases)
-            .filter(([, versionData]) => {
-            if (!acceptableStatuses.includes(versionData.status)) {
-                return false;
+    const compatibleFeatures = getCompatibleFeaturesByDate(date);
+    const minimumVersions = getMinimumVersionsFromFeatures(compatibleFeatures);
+    if (minOnly) {
+        return minimumVersions;
+    }
+    else {
+        return [...minimumVersions, ...getSubsequentVersions(minimumVersions)].sort((a, b) => {
+            if (a.browser < b.browser) {
+                return -1;
             }
-            return true;
-        })
-            .sort((a, b) => {
-            return compareVersions(a[0], b[0]);
-        });
-        for (let i = 1; i < sortedVersions.length; i++) {
-            const thisVersion = sortedVersions[i];
-            if (thisVersion) {
-                const versionData = thisVersion[1];
-                const prevVersion = sortedVersions[i - 1];
-                if (prevVersion) {
-                    const [prevVersionNumber, prevVersionData] = prevVersion;
-                    if (versionData.release_date &&
-                        new Date(versionData.release_date) > date) {
-                        versions.push({
-                            browser: browserName,
-                            version: prevVersionNumber,
-                            release_date: prevVersionData.release_date
-                                ? prevVersionData.release_date
-                                : "unknown",
-                            engine: null,
-                            engine_version: null,
-                        });
-                        if (minOnly) {
-                            break;
-                        }
-                    }
-                }
+            else if (a.browser > b.browser) {
+                return 1;
             }
-        }
-    });
-    return versions;
+            else {
+                return compareVersions(a.version, b.version);
+            }
+        });
+    }
 };
 const getDownstreamBrowsers = (inputArray = [], minOnly = true) => {
     let minimumChromeVersion = undefined;
@@ -133,13 +195,16 @@ const getDownstreamBrowsers = (inputArray = [], minOnly = true) => {
             const versionEntry = sortedAndFilteredVersions[i];
             if (versionEntry) {
                 const [versionNumber, versionData] = versionEntry;
-                downstreamArray.push({
+                let outputObject = {
                     browser: browserName,
                     version: versionNumber,
                     release_date: versionData.release_date ?? "unknown",
-                    engine: versionData.engine ?? null,
-                    engine_version: versionData.engine_version ?? null,
-                });
+                };
+                if (versionData.engine && versionData.engine_version) {
+                    outputObject.engine = versionData.engine;
+                    outputObject.engine_version = versionData.engine_version;
+                }
+                downstreamArray.push(outputObject);
                 if (minOnly) {
                     break;
                 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "baseline-browser-mapping",
-  "version": "0.3.1",
+  "version": "1.0.0-beta.1",
   "description": "A library for obtaining browser versions with their maximum supported Baseline feature set and Widely Available status.",
   "exports": {
     ".": "./dist/index.js"
@@ -18,7 +18,8 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@mdn/browser-compat-data": "latest"
+    "@mdn/browser-compat-data": "latest",
+    "web-features": "latest"
   },
   "devDependencies": {
     "@types/node": "^22.13.5",