@jsenv/core 19.7.2 → 20.0.2

package/src/internal/generateGroupMap/composeGroup.js

@@ -1,54 +0,0 @@
-import { composeRuntimeCompatMap } from "./composeRuntimeCompatMap.js"
-
-const compositionMappingToComposeStrict = (
-  compositionMapping,
-  createInitial = () => ({}),
-) => {
-  const reducer = compositionMappingToStrictReducer(compositionMapping)
-  return (...objects) => objects.reduce(reducer, createInitial())
-}
-
-const composeBabelPluginRequiredNameArray = (prevNameArray, nameArray) =>
-  arrayWithoutDuplicate([...prevNameArray, ...nameArray]).sort()
-
-const composeJsenvPluginRequiredNameArray = (prevNameArray, nameArray) =>
-  arrayWithoutDuplicate([...prevNameArray, ...nameArray]).sort()
-
-const arrayWithoutDuplicate = (array) =>
-  array.filter((value, index) => array.indexOf(value) === index)
-
-export const composeGroup = compositionMappingToComposeStrict(
-  {
-    babelPluginRequiredNameArray: composeBabelPluginRequiredNameArray,
-    jsenvPluginRequiredNameArray: composeJsenvPluginRequiredNameArray,
-    runtimeCompatMap: composeRuntimeCompatMap,
-  },
-  () => ({
-    babelPluginRequiredNameArray: [],
-    jsenvPluginRequiredNameArray: [],
-    runtimeCompatMap: {},
-  }),
-)
-
-const compositionMappingToStrictReducer = (compositionMapping) => {
-  const propertyComposeStrict = (key, previous, current) => {
-    const propertyExistInCurrent = key in current
-    if (!propertyExistInCurrent) return previous[key]
-
-    const propertyExistInPrevious = key in previous
-    if (!propertyExistInPrevious) return current[key]
-
-    const composeProperty = compositionMapping[key]
-    return composeProperty(previous[key], current[key])
-  }
-
-  return (previous, current) => {
-    if (typeof current !== "object" || current === null) return previous
-
-    const composed = {}
-    Object.keys(compositionMapping).forEach((key) => {
-      composed[key] = propertyComposeStrict(key, previous, current)
-    })
-    return composed
-  }
-}

package/src/internal/generateGroupMap/composeGroupArray.js

@@ -1,43 +0,0 @@
-import { composeRuntimeCompatMap } from "./composeRuntimeCompatMap.js"
-import { groupHaveSameRequirements } from "./groupHaveSameRequirements.js"
-
-export const composeGroupArray = (...arrayOfGroupArray) => {
-  return arrayOfGroupArray.reduce(groupArrayReducer, [])
-}
-
-const groupArrayReducer = (previousGroupArray, groupArray) => {
-  const reducedGroupArray = []
-
-  previousGroupArray.forEach((group) => {
-    reducedGroupArray.push(copyGroup(group))
-  })
-
-  groupArray.forEach((group) => {
-    const groupWithSameRequirements = reducedGroupArray.find(
-      (existingGroupCandidate) =>
-        groupHaveSameRequirements(group, existingGroupCandidate),
-    )
-    if (groupWithSameRequirements) {
-      groupWithSameRequirements.runtimeCompatMap = composeRuntimeCompatMap(
-        groupWithSameRequirements.runtimeCompatMap,
-        group.runtimeCompatMap,
-      )
-    } else {
-      reducedGroupArray.push(copyGroup(group))
-    }
-  })
-
-  return reducedGroupArray
-}
-
-const copyGroup = ({
-  babelPluginRequiredNameArray,
-  jsenvPluginRequiredNameArray,
-  runtimeCompatMap,
-}) => {
-  return {
-    babelPluginRequiredNameArray: babelPluginRequiredNameArray.slice(),
-    jsenvPluginRequiredNameArray: jsenvPluginRequiredNameArray.slice(),
-    runtimeCompatMap: { ...runtimeCompatMap },
-  }
-}

package/src/internal/generateGroupMap/composeRuntimeCompatMap.js

@@ -1,37 +0,0 @@
-import { findHighestVersion } from "../semantic-versioning/index.js"
-
-export const composeRuntimeCompatMap = (
-  runtimeCompatMap,
-  secondRuntimeCompatMap,
-) => {
-  return objectComposeValue(
-    normalizeRuntimeCompatMapVersions(runtimeCompatMap),
-    normalizeRuntimeCompatMapVersions(secondRuntimeCompatMap),
-    (version, secondVersion) => findHighestVersion(version, secondVersion),
-  )
-}
-
-const normalizeRuntimeCompatMapVersions = (runtimeCompatibility) => {
-  return objectMapValue(runtimeCompatibility, (version) => String(version))
-}
-
-const objectMapValue = (object, callback) => {
-  const mapped = {}
-
-  Object.keys(object).forEach((key) => {
-    mapped[key] = callback(object[key], key, object)
-  })
-
-  return mapped
-}
-
-const objectComposeValue = (previous, object, callback) => {
-  const composed = { ...previous }
-
-  Object.keys(object).forEach((key) => {
-    composed[key] =
-      key in composed ? callback(composed[key], object[key]) : object[key]
-  })
-
-  return composed
-}

package/src/internal/generateGroupMap/computeBabelPluginMapForRuntime.js

@@ -1,64 +0,0 @@
-import { findHighestVersion } from "../semantic-versioning/index.js"
-import { jsenvBabelPluginCompatMap } from "../../jsenvBabelPluginCompatMap.js"
-
-export const computeBabelPluginMapForRuntime = ({
-  babelPluginMap,
-  babelPluginCompatMap = jsenvBabelPluginCompatMap,
-  runtimeName,
-  runtimeVersion,
-}) => {
-  if (typeof babelPluginMap !== "object") {
-    throw new TypeError(
-      `babelPluginMap must be an object, got ${babelPluginMap}`,
-    )
-  }
-  if (typeof babelPluginCompatMap !== "object") {
-    throw new TypeError(
-      `babelPluginCompatMap must be an object, got ${babelPluginCompatMap}`,
-    )
-  }
-  if (typeof runtimeName !== "string") {
-    throw new TypeError(`runtimeName must be a string, got ${runtimeName}`)
-  }
-  if (typeof runtimeVersion !== "string") {
-    throw new TypeError(
-      `runtimeVersion must be a string, got ${runtimeVersion}`,
-    )
-  }
-
-  const babelPluginMapForRuntime = {}
-  Object.keys(babelPluginMap).forEach((key) => {
-    const compatible = runtimeIsCompatibleWithFeature({
-      runtimeName,
-      runtimeVersion,
-      runtimeCompatMap:
-        key in babelPluginCompatMap ? babelPluginCompatMap[key] : {},
-    })
-    if (!compatible) {
-      babelPluginMapForRuntime[key] = babelPluginMap[key]
-    }
-  })
-  return babelPluginMapForRuntime
-}
-
-const runtimeIsCompatibleWithFeature = ({
-  runtimeName,
-  runtimeVersion,
-  runtimeCompatMap,
-}) => {
-  const runtimeCompatibleVersion = computeRuntimeCompatibleVersion({
-    runtimeCompatMap,
-    runtimeName,
-  })
-  const highestVersion = findHighestVersion(
-    runtimeVersion,
-    runtimeCompatibleVersion,
-  )
-  return highestVersion === runtimeVersion
-}
-
-const computeRuntimeCompatibleVersion = ({ runtimeCompatMap, runtimeName }) => {
-  return runtimeName in runtimeCompatMap
-    ? runtimeCompatMap[runtimeName]
-    : "Infinity"
-}

package/src/internal/generateGroupMap/computeJsenvPluginMapForRuntime.js

@@ -1,62 +0,0 @@
-import { findHighestVersion } from "../semantic-versioning/index.js"
-import { jsenvPluginCompatMap as jsenvPluginCompatMapFallback } from "../../jsenvPluginCompatMap.js"
-
-export const computeJsenvPluginMapForRuntime = ({
-  jsenvPluginMap,
-  jsenvPluginCompatMap = jsenvPluginCompatMapFallback,
-  runtimeName,
-  runtimeVersion,
-}) => {
-  if (typeof jsenvPluginMap !== "object") {
-    throw new TypeError(
-      `jsenvPluginMap must be a object, got ${jsenvPluginMap}`,
-    )
-  }
-  if (typeof jsenvPluginCompatMap !== "object") {
-    throw new TypeError(
-      `jsenvPluginCompatMap must be a string, got ${jsenvPluginCompatMap}`,
-    )
-  }
-  if (typeof runtimeName !== "string") {
-    throw new TypeError(`runtimeName must be a string, got ${runtimeName}`)
-  }
-  if (typeof runtimeVersion !== "string") {
-    throw new TypeError(
-      `runtimeVersion must be a string, got ${runtimeVersion}`,
-    )
-  }
-
-  const jsenvPluginMapForRuntime = {}
-  Object.keys(jsenvPluginMap).forEach((key) => {
-    const compatible = runtimeIsCompatibleWithFeature({
-      runtimeName,
-      runtimeVersion,
-      featureCompat:
-        key in jsenvPluginCompatMap ? jsenvPluginCompatMap[key] : {},
-    })
-    if (!compatible) {
-      jsenvPluginMapForRuntime[key] = jsenvPluginMap[key]
-    }
-  })
-  return jsenvPluginMapForRuntime
-}
-
-const runtimeIsCompatibleWithFeature = ({
-  runtimeName,
-  runtimeVersion,
-  featureCompat,
-}) => {
-  const runtimeCompatibleVersion = computeRuntimeCompatibleVersion({
-    featureCompat,
-    runtimeName,
-  })
-  const highestVersion = findHighestVersion(
-    runtimeVersion,
-    runtimeCompatibleVersion,
-  )
-  return highestVersion === runtimeVersion
-}
-
-const computeRuntimeCompatibleVersion = ({ featureCompat, runtimeName }) => {
-  return runtimeName in featureCompat ? featureCompat[runtimeName] : "Infinity"
-}

package/src/internal/generateGroupMap/generateAllRuntimeGroupArray.js

@@ -1,22 +0,0 @@
-import { generateRuntimeGroupArray } from "./generateRuntimeGroupArray.js"
-import { composeGroupArray } from "./composeGroupArray.js"
-
-export const generateAllRuntimeGroupArray = ({
-  babelPluginMap,
-  jsenvPluginMap,
-  babelPluginCompatMap,
-  jsenvPluginCompatMap,
-  runtimeNames,
-}) => {
-  const arrayOfGroupArray = runtimeNames.map((runtimeName) =>
-    generateRuntimeGroupArray({
-      babelPluginMap,
-      jsenvPluginMap,
-      babelPluginCompatMap,
-      jsenvPluginCompatMap,
-      runtimeName,
-    }),
-  )
-  const groupArray = composeGroupArray(...arrayOfGroupArray)
-  return groupArray
-}

package/src/internal/generateGroupMap/generateRuntimeGroupArray.js

@@ -1,91 +0,0 @@
-import {
-  findHighestVersion,
-  versionCompare,
-} from "../semantic-versioning/index.js"
-import { jsenvBabelPluginCompatMap } from "../../jsenvBabelPluginCompatMap.js"
-import { jsenvPluginCompatMap as jsenvPluginCompatMapFallback } from "../../jsenvPluginCompatMap.js"
-import { computeBabelPluginMapForRuntime } from "./computeBabelPluginMapForRuntime.js"
-import { computeJsenvPluginMapForRuntime } from "./computeJsenvPluginMapForRuntime.js"
-import { groupHaveSameRequirements } from "./groupHaveSameRequirements.js"
-
-export const generateRuntimeGroupArray = ({
-  babelPluginMap,
-  jsenvPluginMap,
-  babelPluginCompatMap = jsenvBabelPluginCompatMap,
-  jsenvPluginCompatMap = jsenvPluginCompatMapFallback,
-  runtimeName,
-}) => {
-  const versionArray = []
-  Object.keys(babelPluginMap).forEach((babelPluginKey) => {
-    if (babelPluginKey in babelPluginCompatMap) {
-      const babelPluginCompat = babelPluginCompatMap[babelPluginKey]
-      if (runtimeName in babelPluginCompat) {
-        const version = String(babelPluginCompat[runtimeName])
-        if (!versionArray.includes(version)) {
-          versionArray.push(version)
-        }
-      }
-    }
-  })
-  Object.keys(jsenvPluginMap).forEach((jsenvPluginKey) => {
-    if (jsenvPluginKey in jsenvPluginCompatMap) {
-      const jsenvPluginCompat = jsenvPluginCompatMap[jsenvPluginKey]
-      if (runtimeName in jsenvPluginCompat) {
-        const version = String(jsenvPluginCompat[runtimeName])
-        if (!versionArray.includes(version)) {
-          versionArray.push(version)
-        }
-      }
-    }
-  })
-  versionArray.push("0.0.0")
-  versionArray.sort(versionCompare)
-
-  const runtimeGroupArray = []
-
-  versionArray.forEach((version) => {
-    const babelPluginMapForRuntime = computeBabelPluginMapForRuntime({
-      babelPluginMap,
-      babelPluginCompatMap,
-      runtimeName,
-      runtimeVersion: version,
-    })
-    const babelPluginRequiredNameArray = Object.keys(babelPluginMap)
-      .filter((babelPluginKey) => babelPluginKey in babelPluginMapForRuntime)
-      .sort()
-    const jsenvPluginMapForRuntime = computeJsenvPluginMapForRuntime({
-      jsenvPluginMap,
-      jsenvPluginCompatMap,
-      runtimeName,
-      runtimeVersion: version,
-    })
-    const jsenvPluginRequiredNameArray = Object.keys(jsenvPluginMap)
-      .filter((jsenvPluginKey) => jsenvPluginKey in jsenvPluginMapForRuntime)
-      .sort()
-
-    const group = {
-      babelPluginRequiredNameArray,
-      jsenvPluginRequiredNameArray,
-      runtimeCompatMap: {
-        [runtimeName]: version,
-      },
-    }
-
-    const groupWithSameRequirements = runtimeGroupArray.find(
-      (runtimeGroupCandidate) =>
-        groupHaveSameRequirements(runtimeGroupCandidate, group),
-    )
-
-    if (groupWithSameRequirements) {
-      groupWithSameRequirements.runtimeCompatMap[runtimeName] =
-        findHighestVersion(
-          groupWithSameRequirements.runtimeCompatMap[runtimeName],
-          version,
-        )
-    } else {
-      runtimeGroupArray.push(group)
-    }
-  })
-
-  return runtimeGroupArray
-}

package/src/internal/generateGroupMap/groupHaveSameRequirements.js

@@ -1,8 +0,0 @@
-export const groupHaveSameRequirements = (leftGroup, rightGroup) => {
-  return (
-    leftGroup.babelPluginRequiredNameArray.join("") ===
-      rightGroup.babelPluginRequiredNameArray.join("") &&
-    leftGroup.jsenvPluginRequiredNameArray.join("") ===
-      rightGroup.jsenvPluginRequiredNameArray.join("")
-  )
-}

package/src/internal/generateGroupMap/runtimeCompatMapToScore.js

@@ -1,39 +0,0 @@
-import {
-  versionCompare,
-  findHighestVersion,
-} from "../semantic-versioning/index.js"
-
-export const runtimeCompatMapToScore = (runtimeCompatMap, runtimeScoreMap) => {
-  return Object.keys(runtimeCompatMap).reduce((previous, runtimeName) => {
-    const runtimeVersion = runtimeCompatMap[runtimeName]
-    return (
-      previous + runtimeToScore(runtimeName, runtimeVersion, runtimeScoreMap)
-    )
-  }, 0)
-}
-
-const runtimeToScore = (runtimeName, runtimeVersion, runtimeScoreMap) => {
-  if (runtimeName in runtimeScoreMap === false)
-    return runtimeScoreMap.other || 0
-
-  const versionUsageMap = runtimeScoreMap[runtimeName]
-  const versionArray = Object.keys(versionUsageMap)
-  if (versionArray.length === 0) return runtimeScoreMap.other || 0
-
-  const versionArrayAscending = versionArray.sort(versionCompare)
-  const highestVersion = versionArrayAscending[versionArray.length - 1]
-
-  if (findHighestVersion(runtimeVersion, highestVersion) === runtimeVersion)
-    return versionUsageMap[highestVersion]
-
-  const closestVersion = versionArrayAscending
-    .reverse()
-    .find(
-      (version) =>
-        findHighestVersion(runtimeVersion, version) === runtimeVersion,
-    )
-
-  if (!closestVersion) return runtimeScoreMap.other || 0
-
-  return versionUsageMap[closestVersion]
-}

package/src/jsenvBrowserScoreMap.js

@@ -1,27 +0,0 @@
-// https://www.statista.com/statistics/268299/most-popular-internet-browsers/
-// this source of stat is what I found in 5min
-// we could improve these default usage score using better stats
-// and keep in mind this should be updated time to time or even better
-// come from a project specific audience
-
-export const jsenvBrowserScoreMap = {
-  android: 0.001,
-  chrome: {
-    71: 0.3,
-    69: 0.19,
-    0: 0.01, // it means oldest version of chrome will get a score of 0.01
-  },
-  firefox: {
-    61: 0.3,
-  },
-  edge: {
-    12: 0.1,
-  },
-  electron: 0.001,
-  ios: 0.001,
-  opera: 0.001,
-  other: 0.001,
-  safari: {
-    10: 0.1,
-  },
-}

package/src/jsenvNodeVersionScoreMap.js

@@ -1,12 +0,0 @@
-// https://nodejs.org/metrics/summaries/version/nodejs.org-access.log.csv
-export const jsenvNodeVersionScoreMap = {
-  "0.10": 0.02,
-  "0.12": 0.01,
-  "4": 0.1,
-  "6": 0.25,
-  "7": 0.1,
-  "8": 1,
-  "9": 0.1,
-  "10": 0.5,
-  "11": 0.25,
-}