@jsenv/urls 1.1.2 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/urls",
-  "version": "1.1.2",
+  "version": "1.2.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -19,13 +19,12 @@
   "type": "module",
   "exports": {
     ".": {
-      "import": "./main.js"
+      "import": "./src/urls.js"
     },
     "./*": "./*"
   },
   "files": [
-    "/src/",
-    "/main.js"
+    "/src/"
   ],
   "scripts": {
     "test": "node --conditions=development ./scripts/test.mjs"

package/src/data_url.js

@@ -5,7 +5,7 @@
 
 /* eslint-env browser, node */
 
-export const DataUrl = {
+export const DATA_URL = {
   parse: (string) => {
     const afterDataProtocol = string.slice("data:".length)
     const commaIndex = afterDataProtocol.indexOf(",")

package/src/urls.js

@@ -0,0 +1,42 @@
+export { DATA_URL } from "./data_url.js"
+export { generateInlineContentUrl } from "./inline_content_url_generator.js"
+export {
+  stringifyUrlTrace,
+  stringifyUrlSite,
+  humanizeUrl,
+  showSourceLocation,
+} from "./url_trace.js"
+export {
+  asUrlWithoutSearch,
+  isValidUrl,
+  normalizeUrl,
+  injectQueryParamsIntoSpecifier,
+  injectQueryParams,
+  setUrlExtension,
+  setUrlFilename,
+  ensurePathnameTrailingSlash,
+  asUrlUntilPathname,
+} from "./url_utils.js"
+export {
+  startsWithWindowsDriveLetter,
+  windowsFilePathToUrl,
+  replaceBackSlashesWithSlashes,
+} from "./windows_file_path_utils.js"
+export { getCallerPosition } from "./caller_position.js"
+
+export { fileSystemPathToUrl } from "./filesystem_path_to_url.js"
+export { isFileSystemPath } from "./is_filesystem_path.js"
+export { resolveDirectoryUrl } from "./resolve_directory_url.js"
+export { moveUrl } from "./move_url.js"
+export { resolveUrl } from "./resolve_url.js"
+export { urlIsInsideOf } from "./url_is_inside_of.js"
+export { urlToBasename } from "./url_to_basename.js"
+export { urlToExtension } from "./url_to_extension.js"
+export { urlToFilename } from "./url_to_filename.js"
+export { urlToFileSystemPath } from "./url_to_filesystem_path.js"
+export { urlToOrigin } from "./url_to_origin.js"
+export { urlToParentUrl } from "./url_to_parent_url.js"
+export { urlToPathname } from "./url_to_pathname.js"
+export { urlToRelativeUrl } from "./url_to_relative_url.js"
+export { urlToRessource } from "./url_to_ressource.js"
+export { urlToScheme } from "./url_to_scheme.js"

package/main.js

@@ -1,44 +0,0 @@
-export { DataUrl } from "./src/data_url.js"
-export { generateInlineContentUrl } from "./src/inline_content_url_generator.js"
-export {
-  stringifyUrlTrace,
-  stringifyUrlSite,
-  humanizeUrl,
-  showSourceLocation,
-} from "./src/url_trace.js"
-export {
-  asUrlWithoutSearch,
-  isValidUrl,
-  normalizeUrl,
-  injectQueryParamsIntoSpecifier,
-  injectQueryParams,
-  setUrlExtension,
-  setUrlFilename,
-  ensurePathnameTrailingSlash,
-  asUrlUntilPathname,
-} from "./src/url_utils.js"
-export {
-  startsWithWindowsDriveLetter,
-  windowsFilePathToUrl,
-  replaceBackSlashesWithSlashes,
-} from "./src/windows_file_path_utils.js"
-export { getCallerPosition } from "./src/caller_position.js"
-
-export { URL_META } from "./src/meta/url_meta.js"
-
-export { fileSystemPathToUrl } from "./src/filesystem_path_to_url.js"
-export { isFileSystemPath } from "./src/is_filesystem_path.js"
-export { resolveDirectoryUrl } from "./src/resolve_directory_url.js"
-export { moveUrl } from "./src/move_url.js"
-export { resolveUrl } from "./src/resolve_url.js"
-export { urlIsInsideOf } from "./src/url_is_inside_of.js"
-export { urlToBasename } from "./src/url_to_basename.js"
-export { urlToExtension } from "./src/url_to_extension.js"
-export { urlToFilename } from "./src/url_to_filename.js"
-export { urlToFileSystemPath } from "./src/url_to_filesystem_path.js"
-export { urlToOrigin } from "./src/url_to_origin.js"
-export { urlToParentUrl } from "./src/url_to_parent_url.js"
-export { urlToPathname } from "./src/url_to_pathname.js"
-export { urlToRelativeUrl } from "./src/url_to_relative_url.js"
-export { urlToRessource } from "./src/url_to_ressource.js"
-export { urlToScheme } from "./src/url_to_scheme.js"

package/src/meta/aliases.js

@@ -1,28 +0,0 @@
-import { applyPatternMatching } from "./pattern_matching.js"
-
-export const applyAliases = ({ url, aliases }) => {
-  let aliasFullMatchResult
-  const aliasMatchingKey = Object.keys(aliases).find((key) => {
-    const aliasMatchResult = applyPatternMatching({
-      pattern: key,
-      url,
-    })
-    if (aliasMatchResult.matched) {
-      aliasFullMatchResult = aliasMatchResult
-      return true
-    }
-    return false
-  })
-  if (!aliasMatchingKey) {
-    return url
-  }
-  const { matchGroups } = aliasFullMatchResult
-  const alias = aliases[aliasMatchingKey]
-  const parts = alias.split("*")
-  const newUrl = parts.reduce((previous, value, index) => {
-    return `${previous}${value}${
-      index === parts.length - 1 ? "" : matchGroups[index]
-    }`
-  }, "")
-  return newUrl
-}

package/src/meta/as_flat_associations.js

@@ -1,28 +0,0 @@
-import { isPlainObject } from "./assertions.js"
-
-export const asFlatAssociations = (associations) => {
-  if (!isPlainObject(associations)) {
-    throw new TypeError(
-      `associations must be a plain object, got ${associations}`,
-    )
-  }
-  const flatAssociations = {}
-  Object.keys(associations).forEach((key) => {
-    const valueMap = associations[key]
-    if (!isPlainObject(valueMap)) {
-      throw new TypeError(
-        `all associations value must be objects, found "${key}": ${valueMap}`,
-      )
-    }
-    Object.keys(valueMap).forEach((pattern) => {
-      const value = valueMap[pattern]
-      const previousValue = flatAssociations[pattern]
-      flatAssociations[pattern] = previousValue
-        ? { ...previousValue, [key]: value }
-        : {
-            [key]: value,
-          }
-    })
-  })
-  return flatAssociations
-}

package/src/meta/assertions.js

@@ -1,57 +0,0 @@
-export const assertSpecifierMetaMap = (value, checkComposition = true) => {
-  if (!isPlainObject(value)) {
-    throw new TypeError(`specifierMetaMap must be a plain object, got ${value}`)
-  }
-  if (checkComposition) {
-    const plainObject = value
-    Object.keys(plainObject).forEach((key) => {
-      assertUrlLike(key, "specifierMetaMap key")
-      const value = plainObject[key]
-      if (value !== null && !isPlainObject(value)) {
-        throw new TypeError(
-          `specifierMetaMap value must be a plain object or null, got ${value} under key ${key}`,
-        )
-      }
-    })
-  }
-}
-
-export const assertUrlLike = (value, name = "url") => {
-  if (typeof value !== "string") {
-    throw new TypeError(`${name} must be a url string, got ${value}`)
-  }
-  if (isWindowsPathnameSpecifier(value)) {
-    throw new TypeError(
-      `${name} must be a url but looks like a windows pathname, got ${value}`,
-    )
-  }
-  if (!hasScheme(value)) {
-    throw new TypeError(
-      `${name} must be a url and no scheme found, got ${value}`,
-    )
-  }
-}
-
-export const isPlainObject = (value) => {
-  if (value === null) {
-    return false
-  }
-  if (typeof value === "object") {
-    if (Array.isArray(value)) {
-      return false
-    }
-    return true
-  }
-  return false
-}
-
-const isWindowsPathnameSpecifier = (specifier) => {
-  const firstChar = specifier[0]
-  if (!/[a-zA-Z]/.test(firstChar)) return false
-  const secondChar = specifier[1]
-  if (secondChar !== ":") return false
-  const thirdChar = specifier[2]
-  return thirdChar === "/" || thirdChar === "\\"
-}
-
-const hasScheme = (specifier) => /^[a-zA-Z]+:/.test(specifier)

package/src/meta/associations.js

@@ -1,25 +0,0 @@
-import { assertUrlLike, isPlainObject } from "./assertions.js"
-import { asFlatAssociations } from "./as_flat_associations.js"
-import { applyPatternMatching } from "./pattern_matching.js"
-
-export const applyAssociations = ({ url, associations }) => {
-  assertUrlLike(url)
-  const flatAssociations = asFlatAssociations(associations)
-  return Object.keys(flatAssociations).reduce((previousValue, pattern) => {
-    const { matched } = applyPatternMatching({
-      pattern,
-      url,
-    })
-    if (matched) {
-      const value = flatAssociations[pattern]
-      if (isPlainObject(previousValue) && isPlainObject(value)) {
-        return {
-          ...previousValue,
-          ...value,
-        }
-      }
-      return value
-    }
-    return previousValue
-  }, {})
-}

package/src/meta/pattern_matching.js

@@ -1,245 +0,0 @@
-/*
- * Link to things doing pattern matching:
- * https://git-scm.com/docs/gitignore
- * https://github.com/kaelzhang/node-ignore
- */
-
-import { assertUrlLike } from "./assertions.js"
-
-/** @module jsenv_url_meta **/
-/**
- * An object representing the result of applying a pattern to an url
- * @typedef {Object} MatchResult
- * @property {boolean} matched Indicates if url matched pattern
- * @property {number} patternIndex Index where pattern stopped matching url, otherwise pattern.length
- * @property {number} urlIndex Index where url stopped matching pattern, otherwise url.length
- * @property {Array} matchGroups Array of strings captured during pattern matching
- */
-
-/**
- * Apply a pattern to an url
- * @param {Object} applyPatternMatchingParams
- * @param {string} applyPatternMatchingParams.pattern "*", "**" and trailing slash have special meaning
- * @param {string} applyPatternMatchingParams.url a string representing an url
- * @return {MatchResult}
- */
-export const applyPatternMatching = ({ url, pattern }) => {
-  assertUrlLike(pattern, "pattern")
-  assertUrlLike(url, "url")
-  const { matched, patternIndex, index, groups } = applyMatching(pattern, url)
-  const matchGroups = []
-  let groupIndex = 0
-  groups.forEach((group) => {
-    if (group.name) {
-      matchGroups[group.name] = group.string
-    } else {
-      matchGroups[groupIndex] = group.string
-      groupIndex++
-    }
-  })
-  return {
-    matched,
-    patternIndex,
-    urlIndex: index,
-    matchGroups,
-  }
-}
-
-const applyMatching = (pattern, string) => {
-  const groups = []
-  let patternIndex = 0
-  let index = 0
-  let remainingPattern = pattern
-  let remainingString = string
-  let restoreIndexes = true
-
-  const consumePattern = (count) => {
-    const subpattern = remainingPattern.slice(0, count)
-    remainingPattern = remainingPattern.slice(count)
-    patternIndex += count
-    return subpattern
-  }
-  const consumeString = (count) => {
-    const substring = remainingString.slice(0, count)
-    remainingString = remainingString.slice(count)
-    index += count
-    return substring
-  }
-  const consumeRemainingString = () => {
-    return consumeString(remainingString.length)
-  }
-
-  let matched
-  const iterate = () => {
-    const patternIndexBefore = patternIndex
-    const indexBefore = index
-    matched = matchOne()
-    if (matched === undefined) {
-      consumePattern(1)
-      consumeString(1)
-      iterate()
-      return
-    }
-    if (matched === false && restoreIndexes) {
-      patternIndex = patternIndexBefore
-      index = indexBefore
-    }
-  }
-  const matchOne = () => {
-    // pattern consumed and string consumed
-    if (remainingPattern === "" && remainingString === "") {
-      return true // string fully matched pattern
-    }
-    // pattern consumed, string not consumed
-    if (remainingPattern === "" && remainingString !== "") {
-      return false // fails because string longer than expected
-    }
-    // -- from this point pattern is not consumed --
-    // string consumed, pattern not consumed
-    if (remainingString === "") {
-      if (remainingPattern === "**") {
-        // trailing "**" is optional
-        consumePattern(2)
-        return true
-      }
-      if (remainingPattern === "*") {
-        groups.push({ string: "" })
-      }
-      return false // fail because string shorter than expected
-    }
-    // -- from this point pattern and string are not consumed --
-    // fast path trailing slash
-    if (remainingPattern === "/") {
-      if (remainingString[0] === "/") {
-        // trailing slash match remaining
-        consumePattern(1)
-        groups.push({ string: consumeRemainingString() })
-        return true
-      }
-      return false
-    }
-    // fast path trailing '**'
-    if (remainingPattern === "**") {
-      consumePattern(2)
-      consumeRemainingString()
-      return true
-    }
-    // pattern leading **
-    if (remainingPattern.slice(0, 2) === "**") {
-      consumePattern(2) // consumes "**"
-      if (remainingPattern[0] === "/") {
-        consumePattern(1) // consumes "/"
-      }
-      // pattern ending with ** always match remaining string
-      if (remainingPattern === "") {
-        consumeRemainingString()
-        return true
-      }
-      const skipResult = skipUntilMatch({
-        pattern: remainingPattern,
-        string: remainingString,
-        canSkipSlash: true,
-      })
-      groups.push(...skipResult.groups)
-      consumePattern(skipResult.patternIndex)
-      consumeRemainingString()
-      restoreIndexes = false
-      return skipResult.matched
-    }
-    if (remainingPattern[0] === "*") {
-      consumePattern(1) // consumes "*"
-      if (remainingPattern === "") {
-        // matches everything except '/'
-        const slashIndex = remainingString.indexOf("/")
-        if (slashIndex === -1) {
-          groups.push({ string: consumeRemainingString() })
-          return true
-        }
-        groups.push({ string: consumeString(slashIndex) })
-        return false
-      }
-      // the next char must not the one expected by remainingPattern[0]
-      // because * is greedy and expect to skip at least one char
-      if (remainingPattern[0] === remainingString[0]) {
-        groups.push({ string: "" })
-        patternIndex = patternIndex - 1
-        return false
-      }
-      const skipResult = skipUntilMatch({
-        pattern: remainingPattern,
-        string: remainingString,
-        canSkipSlash: false,
-      })
-      groups.push(skipResult.group, ...skipResult.groups)
-      consumePattern(skipResult.patternIndex)
-      consumeString(skipResult.index)
-      restoreIndexes = false
-      return skipResult.matched
-    }
-    if (remainingPattern[0] !== remainingString[0]) {
-      return false
-    }
-    return undefined
-  }
-  iterate()
-
-  return {
-    matched,
-    patternIndex,
-    index,
-    groups,
-  }
-}
-
-const skipUntilMatch = ({ pattern, string, canSkipSlash }) => {
-  let index = 0
-  let remainingString = string
-  let longestMatchRange = null
-  const tryToMatch = () => {
-    const matchAttempt = applyMatching(pattern, remainingString)
-    if (matchAttempt.matched) {
-      return {
-        matched: true,
-        patternIndex: matchAttempt.patternIndex,
-        index: index + matchAttempt.index,
-        groups: matchAttempt.groups,
-        group: {
-          string:
-            remainingString === ""
-              ? string
-              : string.slice(0, -remainingString.length),
-        },
-      }
-    }
-    const matchAttemptIndex = matchAttempt.index
-    const matchRange = {
-      patternIndex: matchAttempt.patternIndex,
-      index,
-      length: matchAttemptIndex,
-      groups: matchAttempt.groups,
-    }
-    if (!longestMatchRange || longestMatchRange.length < matchRange.length) {
-      longestMatchRange = matchRange
-    }
-    const nextIndex = matchAttemptIndex + 1
-    const canSkip =
-      nextIndex < remainingString.length &&
-      (canSkipSlash || remainingString[0] !== "/")
-    if (canSkip) {
-      // search against the next unattempted string
-      index += nextIndex
-      remainingString = remainingString.slice(nextIndex)
-      return tryToMatch()
-    }
-    return {
-      matched: false,
-      patternIndex: longestMatchRange.patternIndex,
-      index: longestMatchRange.index + longestMatchRange.length,
-      groups: longestMatchRange.groups,
-      group: {
-        string: string.slice(0, longestMatchRange.index),
-      },
-    }
-  }
-  return tryToMatch()
-}

package/src/meta/resolve_associations.js

@@ -1,25 +0,0 @@
-import { assertUrlLike } from "./assertions.js"
-
-export const resolveAssociations = (associations, baseUrl) => {
-  assertUrlLike(baseUrl, "baseUrl")
-  const associationsResolved = {}
-  Object.keys(associations).forEach((key) => {
-    const valueMap = associations[key]
-    const valueMapResolved = {}
-    Object.keys(valueMap).forEach((pattern) => {
-      const value = valueMap[pattern]
-      const patternResolved = normalizeUrlPattern(pattern, baseUrl)
-      valueMapResolved[patternResolved] = value
-    })
-    associationsResolved[key] = valueMapResolved
-  })
-  return associationsResolved
-}
-
-const normalizeUrlPattern = (urlPattern, baseUrl) => {
-  // starts with a scheme
-  if (/^[a-zA-Z]{2,}:/.test(urlPattern)) {
-    return urlPattern
-  }
-  return String(new URL(urlPattern, baseUrl))
-}

package/src/meta/url_child_may_match.js

@@ -1,47 +0,0 @@
-import { assertUrlLike, isPlainObject } from "./assertions.js"
-import { asFlatAssociations } from "./as_flat_associations.js"
-import { applyPatternMatching } from "./pattern_matching.js"
-
-export const urlChildMayMatch = ({ url, associations, predicate }) => {
-  assertUrlLike(url, "url")
-  // the function was meants to be used on url ending with '/'
-  if (!url.endsWith("/")) {
-    throw new Error(`url should end with /, got ${url}`)
-  }
-  if (typeof predicate !== "function") {
-    throw new TypeError(`predicate must be a function, got ${predicate}`)
-  }
-  const flatAssociations = asFlatAssociations(associations)
-  // for full match we must create an object to allow pattern to override previous ones
-  let fullMatchMeta = {}
-  let someFullMatch = false
-  // for partial match, any meta satisfying predicate will be valid because
-  // we don't know for sure if pattern will still match for a file inside pathname
-  const partialMatchMetaArray = []
-  Object.keys(flatAssociations).forEach((pattern) => {
-    const value = flatAssociations[pattern]
-    const matchResult = applyPatternMatching({
-      pattern,
-      url,
-    })
-    if (matchResult.matched) {
-      someFullMatch = true
-      if (isPlainObject(fullMatchMeta) && isPlainObject(value)) {
-        fullMatchMeta = {
-          ...fullMatchMeta,
-          ...value,
-        }
-      } else {
-        fullMatchMeta = value
-      }
-    } else if (someFullMatch === false && matchResult.urlIndex >= url.length) {
-      partialMatchMetaArray.push(value)
-    }
-  })
-  if (someFullMatch) {
-    return Boolean(predicate(fullMatchMeta))
-  }
-  return partialMatchMetaArray.some((partialMatchMeta) =>
-    predicate(partialMatchMeta),
-  )
-}

package/src/meta/url_meta.js

@@ -1,13 +0,0 @@
-import { resolveAssociations } from "./resolve_associations.js"
-import { applyAssociations } from "./associations.js"
-import { applyAliases } from "./aliases.js"
-import { applyPatternMatching } from "./pattern_matching.js"
-import { urlChildMayMatch } from "./url_child_may_match.js"
-
-export const URL_META = {
-  resolveAssociations,
-  applyAssociations,
-  urlChildMayMatch,
-  applyPatternMatching,
-  applyAliases,
-}