baseline-browser-mapping 0.1.1 → 0.2.2

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import { getAllWidelyAvailable, getMinimumWidelyAvailable, getAllWidelyAvailableOnDate, getMinimumWidelyAvailableOnDate, getAllByYear, getMinimumByYear } from "./scripts/baseline-browser-versions.js";
+export { getAllWidelyAvailable, getMinimumWidelyAvailable, getAllWidelyAvailableOnDate, getMinimumWidelyAvailableOnDate, getAllByYear, getMinimumByYear, };

package/dist/index.js

@@ -0,0 +1,2 @@
+import { getAllWidelyAvailable, getMinimumWidelyAvailable, getAllWidelyAvailableOnDate, getMinimumWidelyAvailableOnDate, getAllByYear, getMinimumByYear, } from "./scripts/baseline-browser-versions.js";
+export { getAllWidelyAvailable, getMinimumWidelyAvailable, getAllWidelyAvailableOnDate, getMinimumWidelyAvailableOnDate, getAllByYear, getMinimumByYear, };

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

@@ -0,0 +1,14 @@
+interface BrowserVersion {
+    browser: string;
+    version: string;
+    release_date: string;
+    engine: string | null;
+    engine_version: string | null;
+}
+export declare function getMinimumWidelyAvailable(includeDownstream?: boolean): BrowserVersion[];
+export declare function getAllWidelyAvailable(includeDownstream?: boolean): BrowserVersion[];
+export declare function getMinimumWidelyAvailableOnDate(dateString: string, includeDownstream?: boolean): BrowserVersion[];
+export declare function getAllWidelyAvailableOnDate(dateString: string, includeDownstream?: boolean): BrowserVersion[];
+export declare function getMinimumByYear(year: string, includeDownstream?: boolean): BrowserVersion[];
+export declare function getAllByYear(year: string, includeDownstream?: boolean): BrowserVersion[];
+export {};

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

@@ -0,0 +1,212 @@
+import bcdBrowsers from "@mdn/browser-compat-data" assert { type: "json" };
+import otherBrowsers from "../data/downstream-browsers.json" assert { type: "json" };
+const bcdCoreBrowserNames = [
+    "chrome",
+    "chrome_android",
+    "edge",
+    "firefox",
+    "firefox_android",
+    "safari",
+    "safari_ios",
+];
+const coreBrowserData = Object.entries(bcdBrowsers.browsers).filter(([browserName, browserData]) => bcdCoreBrowserNames.includes(browserName));
+const bcdDownstreamBrowserNames = [
+    "webview_android",
+    "samsunginternet_android",
+    "opera_android",
+    "opera",
+];
+const downstreamBrowserData = [
+    ...Object.entries(bcdBrowsers.browsers).filter(([browserName, browserData]) => bcdDownstreamBrowserNames.includes(browserName)),
+    ...Object.entries(otherBrowsers.browsers),
+];
+const acceptableStatuses = ["current", "esr", "retired", "unknown"];
+const compareVersions = (incomingVersionString, previousVersionString) => {
+    let [incomingVersionStringMajor, incomingVersionStringMinor] = incomingVersionString.split(".");
+    let [previousVersionStringMajor, previousVersionStringMinor] = previousVersionString.split(".");
+    if (!incomingVersionStringMajor || !previousVersionStringMajor) {
+        throw new Error("One of these version strings is broken: " +
+            incomingVersionString +
+            " or " +
+            previousVersionString +
+            "");
+    }
+    if (incomingVersionStringMinor) {
+        if (parseInt(incomingVersionStringMajor) >=
+            parseInt(previousVersionStringMajor) &&
+            (!previousVersionStringMinor ||
+                parseInt(incomingVersionStringMinor) >
+                    parseInt(previousVersionStringMinor))) {
+            return 1;
+        }
+    }
+    else {
+        if (incomingVersionStringMajor > previousVersionStringMajor) {
+            return 1;
+        }
+    }
+    return 0;
+};
+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()) {
+        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(([versionNumber, versionData]) => {
+            if (!acceptableStatuses.includes(versionData.status)) {
+                return false;
+            }
+            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;
+                        }
+                    }
+                }
+            }
+        }
+    });
+    return versions;
+};
+const getDownstreamBrowsers = (inputArray = [], minOnly = true) => {
+    let minimumChromeVersion = undefined;
+    if (inputArray && inputArray.length > 0) {
+        minimumChromeVersion = inputArray
+            .filter((browser) => browser.browser === "chrome")
+            .sort((a, b) => {
+            return compareVersions(a.version, b.version);
+        })[0]?.version;
+    }
+    if (!minimumChromeVersion) {
+        throw new Error("There are no browser versions compatible with Baseline before Chrome");
+    }
+    let downstreamArray = new Array();
+    downstreamBrowserData.forEach(([browserName, browserData]) => {
+        let sortedAndFilteredVersions = Object.entries(browserData.releases)
+            .filter(([versionNumber, versionData]) => {
+            if (!versionData.engine) {
+                return false;
+            }
+            if (versionData.engine != "Blink") {
+                return false;
+            }
+            if (parseInt(versionData.engine_version) < parseInt(minimumChromeVersion)) {
+                return false;
+            }
+            return true;
+        })
+            .sort((a, b) => {
+            return compareVersions(a[0], b[0]);
+        });
+        for (let i = 0; i < sortedAndFilteredVersions.length; i++) {
+            const versionEntry = sortedAndFilteredVersions[i];
+            if (versionEntry) {
+                const [versionNumber, versionData] = versionEntry;
+                downstreamArray.push({
+                    browser: browserName,
+                    version: versionNumber,
+                    release_date: versionData.release_date,
+                    engine: versionData.engine,
+                    engine_version: versionData.engine_version,
+                });
+                if (minOnly) {
+                    break;
+                }
+            }
+        }
+    });
+    let outputArray = [...inputArray, ...downstreamArray];
+    return outputArray;
+};
+export function getMinimumWidelyAvailable(includeDownstream = false) {
+    const date30MonthsAgo = new Date();
+    date30MonthsAgo.setMonth(new Date().getMonth() - 30);
+    let coreBrowserArray = getCoreVersionsByDate(date30MonthsAgo);
+    if (!includeDownstream) {
+        return coreBrowserArray;
+    }
+    else {
+        return getDownstreamBrowsers(coreBrowserArray);
+    }
+}
+export function getAllWidelyAvailable(includeDownstream = false) {
+    let date30MonthsAgo = new Date();
+    date30MonthsAgo.setMonth(new Date().getMonth() - 30);
+    let coreBrowserArray = getCoreVersionsByDate(date30MonthsAgo, false);
+    if (!includeDownstream) {
+        return coreBrowserArray;
+    }
+    else {
+        return getDownstreamBrowsers(coreBrowserArray, false);
+    }
+}
+export function getMinimumWidelyAvailableOnDate(dateString, includeDownstream = false) {
+    const givenDate = new Date(Date.parse(dateString));
+    const givenDateLess30Months = new Date(givenDate.setMonth(givenDate.getMonth() - 30));
+    let coreBrowserArray = getCoreVersionsByDate(givenDateLess30Months);
+    if (!includeDownstream) {
+        return coreBrowserArray;
+    }
+    else {
+        return getDownstreamBrowsers(coreBrowserArray);
+    }
+}
+export function getAllWidelyAvailableOnDate(dateString, includeDownstream = false) {
+    const givenDate = new Date(Date.parse(dateString));
+    const givenDateLess30Months = new Date(givenDate.setMonth(givenDate.getMonth() - 30));
+    let coreBrowserArray = getCoreVersionsByDate(givenDateLess30Months, false);
+    if (!includeDownstream) {
+        return coreBrowserArray;
+    }
+    else {
+        return getDownstreamBrowsers(coreBrowserArray, false);
+    }
+}
+export function getMinimumByYear(year, includeDownstream = false) {
+    const date = new Date(parseInt(year) + 1, 0, 1);
+    let coreBrowserArray = getCoreVersionsByDate(date);
+    if (!includeDownstream) {
+        return coreBrowserArray;
+    }
+    else {
+        return getDownstreamBrowsers(coreBrowserArray);
+    }
+}
+export function getAllByYear(year, includeDownstream = false) {
+    const date = new Date(parseInt(year) + 1, 0, 1);
+    let coreBrowserArray = getCoreVersionsByDate(date, false);
+    if (!includeDownstream) {
+        return coreBrowserArray;
+    }
+    else {
+        return getDownstreamBrowsers(coreBrowserArray, false);
+    }
+}

package/package.json

@@ -1,14 +1,23 @@
 {
   "name": "baseline-browser-mapping",
-  "version": "0.1.1",
+  "version": "0.2.2",
   "description": "A library for obtaining browser versions with their maximum supported Baseline feature set and Widely Available status.",
-  "main": "index.js",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "LICENSE.txt",
+    "README.md"
+  ],
+  "types": "./dist/index.d.ts",
   "type": "module",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "prepare": "prettier . --write; tsc"
   },
   "license": "Apache-2.0",
   "dependencies": {
     "@mdn/browser-compat-data": "latest"
   }
-}
+}