@jsenv/filesystem 3.2.1 → 4.0.1

package/src/registerFileLifecycle.js

@@ -1,12 +1,12 @@
 import { statSync } from "node:fs"
 import { dirname, basename } from "node:path"
+import { urlToFileSystemPath } from "@jsenv/urls"
 
+import { assertAndNormalizeFileUrl } from "./assertAndNormalizeFileUrl.js"
 import { guardTooFastSecondCall } from "./internal/guard_second_call.js"
 import { statsToType } from "./internal/statsToType.js"
 import { createWatcher } from "./internal/createWatcher.js"
 import { trackRessources } from "./internal/trackRessources.js"
-import { assertAndNormalizeFileUrl } from "./assertAndNormalizeFileUrl.js"
-import { urlToFileSystemPath } from "./urlToFileSystemPath.js"
 
 export const registerFileLifecycle = (
   source,

package/src/removeEntry.js

@@ -1,12 +1,14 @@
 import { unlink, rmdir, openSync, closeSync } from "node:fs"
 import { Abort } from "@jsenv/abort"
+import {
+  ensurePathnameTrailingSlash,
+  urlToFileSystemPath,
+  resolveUrl,
+} from "@jsenv/urls"
 
-import { ensureUrlTrailingSlash } from "./internal/ensureUrlTrailingSlash.js"
 import { assertAndNormalizeFileUrl } from "./assertAndNormalizeFileUrl.js"
-import { urlToFileSystemPath } from "./urlToFileSystemPath.js"
 import { readEntryStat } from "./readEntryStat.js"
 import { readDirectory } from "./readDirectory.js"
-import { resolveUrl } from "./resolveUrl.js"
 
 export const removeEntry = async (
   source,
@@ -54,7 +56,7 @@ export const removeEntry = async (
         },
       )
     } else if (sourceStats.isDirectory()) {
-      await removeDirectory(ensureUrlTrailingSlash(sourceUrl), {
+      await removeDirectory(ensurePathnameTrailingSlash(sourceUrl), {
         signal: removeOperation.signal,
         recursive,
         maxRetries,

package/src/testEntryPermissions.js

@@ -1,7 +1,6 @@
 import { promises, constants } from "node:fs"
 
 import { assertAndNormalizeFileUrl } from "./assertAndNormalizeFileUrl.js"
-import { urlToFileSystemPath } from "./urlToFileSystemPath.js"
 
 const { access } = promises
 const {
@@ -21,7 +20,6 @@ export const testEntryPermissions = async (
   } = {},
 ) => {
   const sourceUrl = assertAndNormalizeFileUrl(source)
-  const sourcePath = urlToFileSystemPath(sourceUrl)
   let binaryFlags = 0
 
   // if (visible) binaryFlags |= F_OK
@@ -30,7 +28,7 @@ export const testEntryPermissions = async (
   if (execute) binaryFlags |= X_OK
 
   try {
-    await access(sourcePath, binaryFlags)
+    await access(new URL(sourceUrl), binaryFlags)
     return true
   } catch (error) {
     if (error.code === "ENOENT") {

package/src/writeDirectory.js

@@ -1,8 +1,8 @@
 import { promises } from "node:fs"
+import { urlToFileSystemPath } from "@jsenv/urls"
 
-import { statsToType } from "./internal/statsToType.js"
 import { assertAndNormalizeDirectoryUrl } from "./assertAndNormalizeDirectoryUrl.js"
-import { urlToFileSystemPath } from "./urlToFileSystemPath.js"
+import { statsToType } from "./internal/statsToType.js"
 import { readEntryStat } from "./readEntryStat.js"
 
 // https://nodejs.org/dist/latest-v13.x/docs/api/fs.html#fs_fspromises_mkdir_path_options

package/src/writeEntryModificationTime.js

@@ -1,11 +1,9 @@
 import { utimes } from "node:fs"
 
 import { assertAndNormalizeFileUrl } from "./assertAndNormalizeFileUrl.js"
-import { urlToFileSystemPath } from "./urlToFileSystemPath.js"
 
 export const writeEntryModificationTime = (source, mtime) => {
   const sourceUrl = assertAndNormalizeFileUrl(source)
-  const sourcePath = urlToFileSystemPath(sourceUrl)
   const mtimeValue =
     typeof mtime === "number" ? new Date(Math.floor(mtime)) : mtime
   // reading atime mutates its value so there is no use case I can think of
@@ -13,7 +11,7 @@ export const writeEntryModificationTime = (source, mtime) => {
   const atimeValue = mtimeValue
 
   return new Promise((resolve, reject) => {
-    utimes(sourcePath, atimeValue, mtimeValue, (error) => {
+    utimes(new URL(sourceUrl), atimeValue, mtimeValue, (error) => {
       if (error) {
         reject(error)
       } else {

package/src/writeEntryPermissions.js

@@ -2,11 +2,9 @@ import { chmod } from "node:fs"
 
 import { permissionsToBinaryFlags } from "./internal/permissions.js"
 import { assertAndNormalizeFileUrl } from "./assertAndNormalizeFileUrl.js"
-import { urlToFileSystemPath } from "./urlToFileSystemPath.js"
 
 export const writeEntryPermissions = async (source, permissions) => {
   const sourceUrl = assertAndNormalizeFileUrl(source)
-  const sourcePath = urlToFileSystemPath(sourceUrl)
 
   let binaryFlags
   if (typeof permissions === "object") {
@@ -36,12 +34,8 @@ export const writeEntryPermissions = async (source, permissions) => {
     binaryFlags = permissions
   }
 
-  return chmodNaive(sourcePath, binaryFlags)
-}
-
-const chmodNaive = (fileSystemPath, binaryFlags) => {
   return new Promise((resolve, reject) => {
-    chmod(fileSystemPath, binaryFlags, (error) => {
+    chmod(new URL(sourceUrl), binaryFlags, (error) => {
       if (error) {
         reject(error)
       } else {

package/src/writeFile.js

@@ -1,22 +1,31 @@
-import { promises } from "node:fs"
+import { writeFile as writeFileNode } from "node:fs"
 
 import { assertAndNormalizeFileUrl } from "./assertAndNormalizeFileUrl.js"
 import { ensureParentDirectories } from "./ensureParentDirectories.js"
 
-// https://nodejs.org/dist/latest-v13.x/docs/api/fs.html#fs_fspromises_writefile_file_data_options
-const { writeFile: writeFileNode } = promises
-
 export const writeFile = async (destination, content = "") => {
   const destinationUrl = assertAndNormalizeFileUrl(destination)
   const destinationUrlObject = new URL(destinationUrl)
   try {
-    await writeFileNode(destinationUrlObject, content)
+    await writeFileNaive(destinationUrlObject, content)
   } catch (error) {
     if (error.code === "ENOENT") {
       await ensureParentDirectories(destinationUrl)
-      await writeFileNode(destinationUrlObject, content)
+      await writeFileNaive(destinationUrlObject, content)
       return
     }
     throw error
   }
 }
+
+const writeFileNaive = (urlObject, content) => {
+  return new Promise((resolve, reject) => {
+    writeFileNode(urlObject, content, (error) => {
+      if (error) {
+        reject(error)
+      } else {
+        resolve()
+      }
+    })
+  })
+}

package/src/writeSymbolicLink.js

@@ -1,10 +1,12 @@
 import { promises } from "node:fs"
+import {
+  fileSystemPathToUrl,
+  urlToFileSystemPath,
+  resolveUrl,
+  isFileSystemPath,
+} from "@jsenv/urls"
 
 import { assertAndNormalizeFileUrl } from "./assertAndNormalizeFileUrl.js"
-import { fileSystemPathToUrl } from "./fileSystemPathToUrl.js"
-import { urlToFileSystemPath } from "./urlToFileSystemPath.js"
-import { resolveUrl } from "./resolveUrl.js"
-import { isFileSystemPath } from "./isFileSystemPath.js"
 import { ensureParentDirectories } from "./ensureParentDirectories.js"
 import { readEntryStat } from "./readEntryStat.js"
 import { readSymbolicLink } from "./readSymbolicLink.js"

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2019 jsenv
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/src/fileSystemPathToUrl.js

@@ -1,9 +0,0 @@
-import { pathToFileURL } from "url"
-import { isFileSystemPath } from "./isFileSystemPath.js"
-
-export const fileSystemPathToUrl = (value) => {
-  if (!isFileSystemPath(value)) {
-    throw new Error(`received an invalid value for fileSystemPath: ${value}`)
-  }
-  return String(pathToFileURL(value))
-}

package/src/internal/ensureUrlTrailingSlash.js

@@ -1,3 +0,0 @@
-export const ensureUrlTrailingSlash = (url) => {
-  return url.endsWith("/") ? url : `${url}/`
-}

package/src/internal/getCommonPathname.js

@@ -1,42 +0,0 @@
-export const getCommonPathname = (pathname, otherPathname) => {
-  const firstDifferentCharacterIndex = findFirstDifferentCharacterIndex(
-    pathname,
-    otherPathname,
-  )
-
-  // pathname and otherpathname are exactly the same
-  if (firstDifferentCharacterIndex === -1) {
-    return pathname
-  }
-
-  const commonString = pathname.slice(0, firstDifferentCharacterIndex + 1)
-  // the first different char is at firstDifferentCharacterIndex
-  if (pathname.charAt(firstDifferentCharacterIndex) === "/") {
-    return commonString
-  }
-
-  if (otherPathname.charAt(firstDifferentCharacterIndex) === "/") {
-    return commonString
-  }
-
-  const firstDifferentSlashIndex = commonString.lastIndexOf("/")
-  return pathname.slice(0, firstDifferentSlashIndex + 1)
-}
-
-const findFirstDifferentCharacterIndex = (string, otherString) => {
-  const maxCommonLength = Math.min(string.length, otherString.length)
-  let i = 0
-  while (i < maxCommonLength) {
-    const char = string.charAt(i)
-    const otherChar = otherString.charAt(i)
-    if (char !== otherChar) {
-      return i
-    }
-    i++
-  }
-  if (string.length === otherString.length) {
-    return -1
-  }
-  // they differ at maxCommonLength
-  return maxCommonLength
-}

package/src/internal/getCommonPathname.test.js

@@ -1,62 +0,0 @@
-import { assert } from "@jsenv/assert"
-import { getCommonPathname } from "./getCommonPathname.js"
-
-{
-  const actual = getCommonPathname("/a/whatever.js", "/a/whatever.js")
-  const expected = "/a/whatever.js"
-  assert({ actual, expected })
-}
-
-{
-  const actual = getCommonPathname("/a/whatever.js", "/a/")
-  const expected = "/a/"
-  assert({ actual, expected })
-}
-
-{
-  const actual = getCommonPathname("/a/whatever.js", "/a/base.js")
-  const expected = "/a/"
-  assert({ actual, expected })
-}
-
-{
-  const actual = getCommonPathname("/a/whatever.js", "/b/base.js")
-  const expected = "/"
-  assert({ actual, expected })
-}
-
-{
-  const actual = getCommonPathname("/a/b/whatever.js", "/a/b/base.js")
-  const expected = "/a/b/"
-  assert({ actual, expected })
-}
-
-{
-  const actual = getCommonPathname("/a/b/c/d/whatever.js", "/a/b/base.js")
-  const expected = "/a/b/"
-  assert({ actual, expected })
-}
-
-{
-  const actual = getCommonPathname("/a/", "/a/base.js")
-  const expected = "/a/"
-  assert({ actual, expected })
-}
-
-{
-  const actual = getCommonPathname("/", "/")
-  const expected = "/"
-  assert({ actual, expected })
-}
-
-{
-  const actual = getCommonPathname("/whatever.js", "/")
-  const expected = "/"
-  assert({ actual, expected })
-}
-
-{
-  const actual = getCommonPathname("/", "/base.js")
-  const expected = "/"
-  assert({ actual, expected })
-}

package/src/internal/pathnameToParentPathname.js

@@ -1,8 +0,0 @@
-export const pathnameToParentPathname = (pathname) => {
-  const slashLastIndex = pathname.lastIndexOf("/")
-  if (slashLastIndex === -1) {
-    return "/"
-  }
-
-  return pathname.slice(0, slashLastIndex + 1)
-}

package/src/internal/replaceBackSlashesWithSlashes.js

@@ -1,2 +0,0 @@
-export const replaceBackSlashesWithSlashes = (string) =>
-  string.replace(/\\/g, "/")

package/src/isFileSystemPath.js

@@ -1,23 +0,0 @@
-export const isFileSystemPath = (value) => {
-  if (typeof value !== "string") {
-    throw new TypeError(
-      `isFileSystemPath first arg must be a string, got ${value}`,
-    )
-  }
-
-  if (value[0] === "/") {
-    return true
-  }
-
-  return startsWithWindowsDriveLetter(value)
-}
-
-const startsWithWindowsDriveLetter = (string) => {
-  const firstChar = string[0]
-  if (!/[a-zA-Z]/.test(firstChar)) return false
-
-  const secondChar = string[1]
-  if (secondChar !== ":") return false
-
-  return true
-}

package/src/memoize.js

@@ -1,24 +0,0 @@
-export const memoize = (compute) => {
-  let memoized = false
-  let memoizedValue
-
-  const fnWithMemoization = (...args) => {
-    if (memoized) {
-      return memoizedValue
-    }
-    // if compute is recursive wait for it to be fully done before storing the value
-    // so set memoized boolean after the call
-    memoizedValue = compute(...args)
-    memoized = true
-    return memoizedValue
-  }
-
-  fnWithMemoization.forget = () => {
-    const value = memoizedValue
-    memoized = false
-    memoizedValue = undefined
-    return value
-  }
-
-  return fnWithMemoization
-}

package/src/moveUrl.js

@@ -1,10 +0,0 @@
-import { urlToRelativeUrl } from "./urlToRelativeUrl.js"
-
-export const moveUrl = ({ url, from, to, preferAbsolute = false }) => {
-  const relativeUrl = urlToRelativeUrl(url, from)
-  const absoluteUrl = new URL(relativeUrl, to).href
-  if (preferAbsolute) {
-    return absoluteUrl
-  }
-  return urlToRelativeUrl(absoluteUrl, to)
-}

package/src/resolveDirectoryUrl.js

@@ -1,7 +0,0 @@
-import { ensureUrlTrailingSlash } from "./internal/ensureUrlTrailingSlash.js"
-import { resolveUrl } from "./resolveUrl.js"
-
-export const resolveDirectoryUrl = (specifier, baseUrl) => {
-  const url = resolveUrl(specifier, baseUrl)
-  return ensureUrlTrailingSlash(url)
-}

package/src/resolveUrl.js

@@ -1,7 +0,0 @@
-export const resolveUrl = (specifier, baseUrl) => {
-  if (typeof baseUrl === "undefined") {
-    throw new TypeError(`baseUrl missing to resolve ${specifier}`)
-  }
-
-  return String(new URL(specifier, baseUrl))
-}

package/src/urlIsInsideOf.js

@@ -1,17 +0,0 @@
-export const urlIsInsideOf = (url, otherUrl) => {
-  const urlObject = new URL(url)
-  const otherUrlObject = new URL(otherUrl)
-
-  if (urlObject.origin !== otherUrlObject.origin) {
-    return false
-  }
-
-  const urlPathname = urlObject.pathname
-  const otherUrlPathname = otherUrlObject.pathname
-  if (urlPathname === otherUrlPathname) {
-    return false
-  }
-
-  const isInside = urlPathname.startsWith(otherUrlPathname)
-  return isInside
-}

package/src/urlToBasename.js

@@ -1,9 +0,0 @@
-import { urlToFilename } from "./urlToFilename.js"
-
-export const urlToBasename = (url) => {
-  const filename = urlToFilename(url)
-  const dotLastIndex = filename.lastIndexOf(".")
-  const basename =
-    dotLastIndex === -1 ? filename : filename.slice(0, dotLastIndex)
-  return basename
-}

package/src/urlToExtension.js

@@ -1,19 +0,0 @@
-import { urlToPathname } from "./urlToPathname.js"
-
-export const urlToExtension = (url) => {
-  const pathname = urlToPathname(url)
-  return pathnameToExtension(pathname)
-}
-
-const pathnameToExtension = (pathname) => {
-  const slashLastIndex = pathname.lastIndexOf("/")
-  if (slashLastIndex !== -1) {
-    pathname = pathname.slice(slashLastIndex + 1)
-  }
-
-  const dotLastIndex = pathname.lastIndexOf(".")
-  if (dotLastIndex === -1) return ""
-  // if (dotLastIndex === pathname.length - 1) return ""
-  const extension = pathname.slice(dotLastIndex)
-  return extension
-}

package/src/urlToFileSystemPath.js

@@ -1,12 +0,0 @@
-import { fileURLToPath } from "url"
-
-export const urlToFileSystemPath = (url) => {
-  let urlString = String(url)
-  if (urlString[urlString.length - 1] === "/") {
-    // remove trailing / so that nodejs path becomes predictable otherwise it logs
-    // the trailing slash on linux but does not on windows
-    urlString = urlString.slice(0, -1)
-  }
-  const fileSystemPath = fileURLToPath(urlString)
-  return fileSystemPath
-}

package/src/urlToFilename.js

@@ -1,14 +0,0 @@
-import { urlToPathname } from "./urlToPathname.js"
-
-export const urlToFilename = (url) => {
-  const pathname = urlToPathname(url)
-  const pathnameBeforeLastSlash = pathname.endsWith("/")
-    ? pathname.slice(0, -1)
-    : pathname
-  const slashLastIndex = pathnameBeforeLastSlash.lastIndexOf("/")
-  const filename =
-    slashLastIndex === -1
-      ? pathnameBeforeLastSlash
-      : pathnameBeforeLastSlash.slice(slashLastIndex + 1)
-  return filename
-}

package/src/urlToOrigin.js

@@ -1,7 +0,0 @@
-export const urlToOrigin = (url) => {
-  const urlString = String(url)
-  if (urlString.startsWith("file://")) {
-    return `file://`
-  }
-  return new URL(urlString).origin
-}

package/src/urlToParentUrl.js

@@ -1,31 +0,0 @@
-import { urlToOrigin } from "./urlToOrigin.js"
-import { urlToRessource } from "./urlToRessource.js"
-
-export const urlToParentUrl = (url) => {
-  const ressource = urlToRessource(url)
-  const slashLastIndex = ressource.lastIndexOf("/")
-  if (slashLastIndex === -1) {
-    const urlAsString = String(url)
-    return urlAsString
-  }
-
-  const lastCharacterIndex = ressource.length - 1
-  if (slashLastIndex === lastCharacterIndex) {
-    const slashPreviousIndex = ressource.lastIndexOf(
-      "/",
-      lastCharacterIndex - 1,
-    )
-    if (slashPreviousIndex === -1) {
-      const urlAsString = String(url)
-      return urlAsString
-    }
-
-    const origin = urlToOrigin(url)
-    const parentUrl = `${origin}${ressource.slice(0, slashPreviousIndex + 1)}`
-    return parentUrl
-  }
-
-  const origin = urlToOrigin(url)
-  const parentUrl = `${origin}${ressource.slice(0, slashLastIndex + 1)}`
-  return parentUrl
-}

package/src/urlToPathname.js

@@ -1,19 +0,0 @@
-import { urlToRessource } from "./urlToRessource.js"
-
-export const urlToPathname = (url) => {
-  const ressource = urlToRessource(url)
-  const pathname = ressourceToPathname(ressource)
-  return pathname
-}
-
-const ressourceToPathname = (ressource) => {
-  const searchSeparatorIndex = ressource.indexOf("?")
-  if (searchSeparatorIndex > -1) {
-    return ressource.slice(0, searchSeparatorIndex)
-  }
-  const hashIndex = ressource.indexOf("#")
-  if (hashIndex > -1) {
-    return ressource.slice(0, hashIndex)
-  }
-  return ressource
-}

package/src/urlToRelativeUrl.js

@@ -1,49 +0,0 @@
-import { getCommonPathname } from "./internal/getCommonPathname.js"
-import { pathnameToParentPathname } from "./internal/pathnameToParentPathname.js"
-
-export const urlToRelativeUrl = (url, baseUrl) => {
-  const urlObject = new URL(url)
-  const baseUrlObject = new URL(baseUrl)
-
-  if (urlObject.protocol !== baseUrlObject.protocol) {
-    const urlAsString = String(url)
-    return urlAsString
-  }
-
-  if (
-    urlObject.username !== baseUrlObject.username ||
-    urlObject.password !== baseUrlObject.password ||
-    urlObject.host !== baseUrlObject.host
-  ) {
-    const afterUrlScheme = String(url).slice(urlObject.protocol.length)
-    return afterUrlScheme
-  }
-
-  const { pathname, hash, search } = urlObject
-  if (pathname === "/") {
-    const baseUrlRessourceWithoutLeadingSlash = baseUrlObject.pathname.slice(1)
-    return baseUrlRessourceWithoutLeadingSlash
-  }
-
-  const basePathname = baseUrlObject.pathname
-  const commonPathname = getCommonPathname(pathname, basePathname)
-  if (!commonPathname) {
-    const urlAsString = String(url)
-    return urlAsString
-  }
-  const specificPathname = pathname.slice(commonPathname.length)
-  const baseSpecificPathname = basePathname.slice(commonPathname.length)
-  if (baseSpecificPathname.includes("/")) {
-    const baseSpecificParentPathname =
-      pathnameToParentPathname(baseSpecificPathname)
-    const relativeDirectoriesNotation = baseSpecificParentPathname.replace(
-      /.*?\//g,
-      "../",
-    )
-    const relativeUrl = `${relativeDirectoriesNotation}${specificPathname}${search}${hash}`
-    return relativeUrl
-  }
-
-  const relativeUrl = `${specificPathname}${search}${hash}`
-  return relativeUrl
-}

package/src/urlToRessource.js

@@ -1,21 +0,0 @@
-import { urlToScheme } from "./urlToScheme.js"
-
-export const urlToRessource = (url) => {
-  const scheme = urlToScheme(url)
-
-  if (scheme === "file") {
-    const urlAsStringWithoutFileProtocol = String(url).slice("file://".length)
-    return urlAsStringWithoutFileProtocol
-  }
-
-  if (scheme === "https" || scheme === "http") {
-    // remove origin
-    const afterProtocol = String(url).slice(scheme.length + "://".length)
-    const pathnameSlashIndex = afterProtocol.indexOf("/", "://".length)
-    const urlAsStringWithoutOrigin = afterProtocol.slice(pathnameSlashIndex)
-    return urlAsStringWithoutOrigin
-  }
-
-  const urlAsStringWithoutProtocol = String(url).slice(scheme.length + 1)
-  return urlAsStringWithoutProtocol
-}

package/src/urlToScheme.js

@@ -1,10 +0,0 @@
-export const urlToScheme = (url) => {
-  const urlString = String(url)
-  const colonIndex = urlString.indexOf(":")
-  if (colonIndex === -1) {
-    return ""
-  }
-
-  const scheme = urlString.slice(0, colonIndex)
-  return scheme
-}