@cjser/is-filesystem-case-sensitive 0.1.0-cjser.2

package/dist-cjser/index.cjs

@@ -0,0 +1,236 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/@cjser/is-filesystem-case-sensitive.tmp-26-1778152554483/index.js
+var index_exports = {};
+__export(index_exports, {
+  isFileSystemCaseSensitive: () => isFileSystemCaseSensitive,
+  isFileSystemCaseSensitiveSync: () => isFileSystemCaseSensitiveSync
+});
+module.exports = __toCommonJS(index_exports);
+var import_node_process = __toESM(require("node:process"), 1);
+var import_node_crypto = __toESM(require("node:crypto"), 1);
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_promises = __toESM(require("node:fs/promises"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+async function isFileSystemCaseSensitive(pathToCheck = import_node_process.default.cwd()) {
+  if (typeof pathToCheck !== "string") {
+    throw new TypeError("Expected a string path");
+  }
+  const resolvedInputPath = import_node_path.default.resolve(pathToCheck);
+  const existingDirectoryPath = await findExistingDirectoryPath(resolvedInputPath);
+  const canonicalDirectoryPath = await import_promises.default.realpath(existingDirectoryPath);
+  const fastPathResult = await tryFastPathByInvertingPathCasing(canonicalDirectoryPath);
+  if (fastPathResult !== void 0) {
+    return fastPathResult;
+  }
+  return probeByExclusiveCreate(canonicalDirectoryPath);
+}
+function isFileSystemCaseSensitiveSync(pathToCheck = import_node_process.default.cwd()) {
+  if (typeof pathToCheck !== "string") {
+    throw new TypeError("Expected a string path");
+  }
+  const resolvedInputPath = import_node_path.default.resolve(pathToCheck);
+  const existingDirectoryPath = findExistingDirectoryPathSync(resolvedInputPath);
+  const canonicalDirectoryPath = import_node_fs.default.realpathSync(existingDirectoryPath);
+  const fastPathResult = tryFastPathByInvertingPathCasingSync(canonicalDirectoryPath);
+  if (fastPathResult !== void 0) {
+    return fastPathResult;
+  }
+  return probeByExclusiveCreateSync(canonicalDirectoryPath);
+}
+async function tryFastPathByInvertingPathCasing(canonicalDirectoryPath) {
+  const parentPath = import_node_path.default.dirname(canonicalDirectoryPath);
+  const baseName = import_node_path.default.basename(canonicalDirectoryPath);
+  const invertedBaseName = invertAsciiLetterCase(baseName);
+  if (invertedBaseName === baseName) {
+    return void 0;
+  }
+  const invertedDirectoryPath = import_node_path.default.join(parentPath, invertedBaseName);
+  try {
+    await import_promises.default.access(invertedDirectoryPath);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return true;
+    }
+    return void 0;
+  }
+  const invertedCanonicalDirectoryPath = await import_promises.default.realpath(invertedDirectoryPath);
+  if (invertedCanonicalDirectoryPath === canonicalDirectoryPath) {
+    return false;
+  }
+  return void 0;
+}
+function tryFastPathByInvertingPathCasingSync(canonicalDirectoryPath) {
+  const parentPath = import_node_path.default.dirname(canonicalDirectoryPath);
+  const baseName = import_node_path.default.basename(canonicalDirectoryPath);
+  const invertedBaseName = invertAsciiLetterCase(baseName);
+  if (invertedBaseName === baseName) {
+    return void 0;
+  }
+  const invertedDirectoryPath = import_node_path.default.join(parentPath, invertedBaseName);
+  try {
+    import_node_fs.default.accessSync(invertedDirectoryPath);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return true;
+    }
+    return void 0;
+  }
+  const invertedCanonicalDirectoryPath = import_node_fs.default.realpathSync(invertedDirectoryPath);
+  if (invertedCanonicalDirectoryPath === canonicalDirectoryPath) {
+    return false;
+  }
+  return void 0;
+}
+async function probeByExclusiveCreate(directoryPath) {
+  const uniqueIdentifier = import_node_crypto.default.randomUUID();
+  const baseNameLowercase = `case-sensitivity-test-${uniqueIdentifier}`;
+  const baseNameUppercase = baseNameLowercase.toUpperCase();
+  const lowerPath = import_node_path.default.join(directoryPath, baseNameLowercase);
+  const upperPath = import_node_path.default.join(directoryPath, baseNameUppercase);
+  await import_promises.default.writeFile(lowerPath, "", { flag: "wx" });
+  try {
+    await import_promises.default.writeFile(upperPath, "", { flag: "wx" });
+    await safeUnlink(upperPath);
+    return true;
+  } catch (error) {
+    if (error.code === "EEXIST") {
+      return false;
+    }
+    throw error;
+  } finally {
+    await safeUnlink(lowerPath);
+  }
+}
+function probeByExclusiveCreateSync(directoryPath) {
+  const uniqueIdentifier = import_node_crypto.default.randomUUID();
+  const baseNameLowercase = `case-sensitivity-test-${uniqueIdentifier}`;
+  const baseNameUppercase = baseNameLowercase.toUpperCase();
+  const lowerPath = import_node_path.default.join(directoryPath, baseNameLowercase);
+  const upperPath = import_node_path.default.join(directoryPath, baseNameUppercase);
+  import_node_fs.default.writeFileSync(lowerPath, "", { flag: "wx" });
+  try {
+    import_node_fs.default.writeFileSync(upperPath, "", { flag: "wx" });
+    safeUnlinkSync(upperPath);
+    return true;
+  } catch (error) {
+    if (error.code === "EEXIST") {
+      return false;
+    }
+    throw error;
+  } finally {
+    safeUnlinkSync(lowerPath);
+  }
+}
+async function findExistingDirectoryPath(inputPath) {
+  let currentPath = inputPath;
+  while (true) {
+    try {
+      const fileStatus = await import_promises.default.stat(currentPath);
+      if (fileStatus.isDirectory()) {
+        return currentPath;
+      }
+      return import_node_path.default.dirname(await import_promises.default.realpath(currentPath));
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+    const parentPath = import_node_path.default.dirname(currentPath);
+    if (parentPath === currentPath) {
+      throw new Error(`No existing parent directory found for path: ${inputPath}`);
+    }
+    currentPath = parentPath;
+  }
+}
+function findExistingDirectoryPathSync(inputPath) {
+  let currentPath = inputPath;
+  while (true) {
+    try {
+      const fileStatus = import_node_fs.default.statSync(currentPath);
+      if (fileStatus.isDirectory()) {
+        return currentPath;
+      }
+      return import_node_path.default.dirname(import_node_fs.default.realpathSync(currentPath));
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+    const parentPath = import_node_path.default.dirname(currentPath);
+    if (parentPath === currentPath) {
+      throw new Error(`No existing parent directory found for path: ${inputPath}`);
+    }
+    currentPath = parentPath;
+  }
+}
+function invertAsciiLetterCase(text) {
+  let result = "";
+  for (const character of text) {
+    const codePoint = character.codePointAt(0);
+    if (codePoint >= 65 && codePoint <= 90) {
+      result += character.toLowerCase();
+      continue;
+    }
+    if (codePoint >= 97 && codePoint <= 122) {
+      result += character.toUpperCase();
+      continue;
+    }
+    result += character;
+  }
+  return result;
+}
+async function safeUnlink(filePath) {
+  try {
+    await import_promises.default.unlink(filePath);
+  } catch (error) {
+    if (isIgnorableUnlinkErrorCode(error.code)) {
+      return;
+    }
+    throw error;
+  }
+}
+function safeUnlinkSync(filePath) {
+  try {
+    import_node_fs.default.unlinkSync(filePath);
+  } catch (error) {
+    if (isIgnorableUnlinkErrorCode(error.code)) {
+      return;
+    }
+    throw error;
+  }
+}
+function isIgnorableUnlinkErrorCode(code) {
+  return code === "ENOENT" || code === "EPERM" || code === "EACCES" || code === "EBUSY";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isFileSystemCaseSensitive,
+  isFileSystemCaseSensitiveSync
+});

package/index.d.ts

@@ -0,0 +1,33 @@
+/**
+Detect whether the filesystem backing `path` is case-sensitive.
+
+Returns `true` for case-sensitive and `false` for case-insensitive.
+
+May throw if it needs to probe by creating files and the directory is not writable.
+
+@param path The path to check. Can be a file, directory, or non-existent path. Non-existent paths walk up to the nearest existing parent directory. Default: `process.cwd()`.
+
+@example
+```
+import {isFileSystemCaseSensitive} from '@cjser/is-filesystem-case-sensitive';
+
+await isFileSystemCaseSensitive('/some/path');
+//=> true
+```
+*/
+export function isFileSystemCaseSensitive(path?: string): Promise<boolean>;
+
+/**
+Sync variant of {@link isFileSystemCaseSensitive}.
+
+@param path The path to check. Can be a file, directory, or non-existent path. Non-existent paths walk up to the nearest existing parent directory. Default: `process.cwd()`.
+
+@example
+```
+import {isFileSystemCaseSensitiveSync} from '@cjser/is-filesystem-case-sensitive';
+
+isFileSystemCaseSensitiveSync('/some/path');
+//=> true
+```
+*/
+export function isFileSystemCaseSensitiveSync(path?: string): boolean;

package/index.js

@@ -0,0 +1,257 @@
+import process from 'node:process';
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import fsPromises from 'node:fs/promises';
+import path from 'node:path';
+
+export async function isFileSystemCaseSensitive(pathToCheck = process.cwd()) {
+	if (typeof pathToCheck !== 'string') {
+		throw new TypeError('Expected a string path');
+	}
+
+	const resolvedInputPath = path.resolve(pathToCheck);
+	const existingDirectoryPath = await findExistingDirectoryPath(resolvedInputPath);
+	const canonicalDirectoryPath = await fsPromises.realpath(existingDirectoryPath);
+
+	const fastPathResult = await tryFastPathByInvertingPathCasing(canonicalDirectoryPath);
+	if (fastPathResult !== undefined) {
+		return fastPathResult;
+	}
+
+	return probeByExclusiveCreate(canonicalDirectoryPath);
+}
+
+export function isFileSystemCaseSensitiveSync(pathToCheck = process.cwd()) {
+	if (typeof pathToCheck !== 'string') {
+		throw new TypeError('Expected a string path');
+	}
+
+	const resolvedInputPath = path.resolve(pathToCheck);
+	const existingDirectoryPath = findExistingDirectoryPathSync(resolvedInputPath);
+	const canonicalDirectoryPath = fs.realpathSync(existingDirectoryPath);
+
+	const fastPathResult = tryFastPathByInvertingPathCasingSync(canonicalDirectoryPath);
+	if (fastPathResult !== undefined) {
+		return fastPathResult;
+	}
+
+	return probeByExclusiveCreateSync(canonicalDirectoryPath);
+}
+
+async function tryFastPathByInvertingPathCasing(canonicalDirectoryPath) {
+	const parentPath = path.dirname(canonicalDirectoryPath);
+	const baseName = path.basename(canonicalDirectoryPath);
+	const invertedBaseName = invertAsciiLetterCase(baseName);
+	if (invertedBaseName === baseName) {
+		return undefined;
+	}
+
+	const invertedDirectoryPath = path.join(parentPath, invertedBaseName);
+
+	try {
+		await fsPromises.access(invertedDirectoryPath);
+	} catch (error) {
+		if (error.code === 'ENOENT') {
+			return true;
+		}
+
+		return undefined;
+	}
+
+	const invertedCanonicalDirectoryPath = await fsPromises.realpath(invertedDirectoryPath);
+	if (invertedCanonicalDirectoryPath === canonicalDirectoryPath) {
+		return false;
+	}
+
+	return undefined;
+}
+
+function tryFastPathByInvertingPathCasingSync(canonicalDirectoryPath) {
+	const parentPath = path.dirname(canonicalDirectoryPath);
+	const baseName = path.basename(canonicalDirectoryPath);
+	const invertedBaseName = invertAsciiLetterCase(baseName);
+	if (invertedBaseName === baseName) {
+		return undefined;
+	}
+
+	const invertedDirectoryPath = path.join(parentPath, invertedBaseName);
+
+	try {
+		fs.accessSync(invertedDirectoryPath);
+	} catch (error) {
+		if (error.code === 'ENOENT') {
+			return true;
+		}
+
+		return undefined;
+	}
+
+	const invertedCanonicalDirectoryPath = fs.realpathSync(invertedDirectoryPath);
+	if (invertedCanonicalDirectoryPath === canonicalDirectoryPath) {
+		return false;
+	}
+
+	return undefined;
+}
+
+async function probeByExclusiveCreate(directoryPath) {
+	const uniqueIdentifier = crypto.randomUUID();
+	const baseNameLowercase = `case-sensitivity-test-${uniqueIdentifier}`;
+	const baseNameUppercase = baseNameLowercase.toUpperCase();
+
+	const lowerPath = path.join(directoryPath, baseNameLowercase);
+	const upperPath = path.join(directoryPath, baseNameUppercase);
+
+	await fsPromises.writeFile(lowerPath, '', {flag: 'wx'});
+
+	try {
+		await fsPromises.writeFile(upperPath, '', {flag: 'wx'});
+		await safeUnlink(upperPath);
+		return true;
+	} catch (error) {
+		if (error.code === 'EEXIST') {
+			return false;
+		}
+
+		throw error;
+	} finally {
+		await safeUnlink(lowerPath);
+	}
+}
+
+function probeByExclusiveCreateSync(directoryPath) {
+	const uniqueIdentifier = crypto.randomUUID();
+	const baseNameLowercase = `case-sensitivity-test-${uniqueIdentifier}`;
+	const baseNameUppercase = baseNameLowercase.toUpperCase();
+
+	const lowerPath = path.join(directoryPath, baseNameLowercase);
+	const upperPath = path.join(directoryPath, baseNameUppercase);
+
+	fs.writeFileSync(lowerPath, '', {flag: 'wx'});
+
+	try {
+		fs.writeFileSync(upperPath, '', {flag: 'wx'});
+		safeUnlinkSync(upperPath);
+		return true;
+	} catch (error) {
+		if (error.code === 'EEXIST') {
+			return false;
+		}
+
+		throw error;
+	} finally {
+		safeUnlinkSync(lowerPath);
+	}
+}
+
+async function findExistingDirectoryPath(inputPath) {
+	let currentPath = inputPath;
+
+	while (true) {
+		try {
+			// eslint-disable-next-line no-await-in-loop
+			const fileStatus = await fsPromises.stat(currentPath);
+
+			if (fileStatus.isDirectory()) {
+				return currentPath;
+			}
+
+			// eslint-disable-next-line no-await-in-loop
+			return path.dirname(await fsPromises.realpath(currentPath));
+		} catch (error) {
+			if (error.code !== 'ENOENT') {
+				throw error;
+			}
+		}
+
+		const parentPath = path.dirname(currentPath);
+		if (parentPath === currentPath) {
+			throw new Error(`No existing parent directory found for path: ${inputPath}`);
+		}
+
+		currentPath = parentPath;
+	}
+}
+
+function findExistingDirectoryPathSync(inputPath) {
+	let currentPath = inputPath;
+
+	while (true) {
+		try {
+			const fileStatus = fs.statSync(currentPath);
+
+			if (fileStatus.isDirectory()) {
+				return currentPath;
+			}
+
+			return path.dirname(fs.realpathSync(currentPath));
+		} catch (error) {
+			if (error.code !== 'ENOENT') {
+				throw error;
+			}
+		}
+
+		const parentPath = path.dirname(currentPath);
+		if (parentPath === currentPath) {
+			throw new Error(`No existing parent directory found for path: ${inputPath}`);
+		}
+
+		currentPath = parentPath;
+	}
+}
+
+function invertAsciiLetterCase(text) {
+	let result = '';
+
+	for (const character of text) {
+		const codePoint = character.codePointAt(0);
+
+		if (codePoint >= 65 && codePoint <= 90) {
+			result += character.toLowerCase();
+			continue;
+		}
+
+		if (codePoint >= 97 && codePoint <= 122) {
+			result += character.toUpperCase();
+			continue;
+		}
+
+		result += character;
+	}
+
+	return result;
+}
+
+async function safeUnlink(filePath) {
+	try {
+		await fsPromises.unlink(filePath);
+	} catch (error) {
+		if (isIgnorableUnlinkErrorCode(error.code)) {
+			return;
+		}
+
+		throw error;
+	}
+}
+
+function safeUnlinkSync(filePath) {
+	try {
+		fs.unlinkSync(filePath);
+	} catch (error) {
+		if (isIgnorableUnlinkErrorCode(error.code)) {
+			return;
+		}
+
+		throw error;
+	}
+}
+
+function isIgnorableUnlinkErrorCode(code) {
+	/*
+	Best-effort cleanup. Probe files are non-essential, so cleanup failures should not hide the main result.
+	*/
+	return code === 'ENOENT'
+		|| code === 'EPERM'
+		|| code === 'EACCES'
+		|| code === 'EBUSY';
+}

package/license

@@ -0,0 +1,9 @@
+MIT License
+
+Copyright (c) Sindre Sorhus <sindresorhus@gmail.com> (https://sindresorhus.com)
+
+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/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@cjser/is-filesystem-case-sensitive",
+  "version": "0.1.0-cjser.2",
+  "description": "Detect whether the filesystem backing a path is case-sensitive",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://code.moenext.com/3rdeye/cjser.git"
+  },
+  "funding": "https://github.com/sponsors/sindresorhus",
+  "author": {
+    "name": "Sindre Sorhus",
+    "email": "sindresorhus@gmail.com",
+    "url": "https://sindresorhus.com"
+  },
+  "type": "module",
+  "exports": {
+    "types": "./index.d.ts",
+    "require": "./dist-cjser/index.cjs",
+    "default": "./index.js"
+  },
+  "sideEffects": false,
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "test": "xo && node --test test.js && tsc index.d.ts"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "dist-cjser"
+  ],
+  "keywords": [
+    "filesystem",
+    "fs",
+    "case",
+    "sensitive",
+    "insensitive",
+    "path",
+    "detect",
+    "check",
+    "mount",
+    "volume"
+  ],
+  "devDependencies": {
+    "typescript": "^6.0.2",
+    "xo": "^2.0.2"
+  },
+  "xo": {
+    "rules": {
+      "@stylistic/curly-newline": "off"
+    }
+  },
+  "types": "./index.d.ts",
+  "main": "./dist-cjser/index.cjs",
+  "cjser": {
+    "sourceVersion": "0.1.0",
+    "cjserVersion": 2,
+    "original": {
+      "name": "is-filesystem-case-sensitive",
+      "version": "0.1.0",
+      "exports": {
+        "types": "./index.d.ts",
+        "default": "./index.js"
+      },
+      "repository": "sindresorhus/is-filesystem-case-sensitive",
+      "files": [
+        "index.js",
+        "index.d.ts"
+      ],
+      "scripts": {
+        "test": "xo && node --test test.js && tsc index.d.ts"
+      }
+    }
+  }
+}

package/readme.md

@@ -0,0 +1,46 @@
+# is-filesystem-case-sensitive
+
+> Detect whether the filesystem backing a path is case-sensitive
+
+Mount-point aware. No OS heuristics.
+
+## Install
+
+```sh
+npm install is-filesystem-case-sensitive
+```
+
+## Usage
+
+```js
+import {isFileSystemCaseSensitive} from 'is-filesystem-case-sensitive';
+
+await isFileSystemCaseSensitive('/some/path');
+//=> true/false
+```
+
+## API
+
+May create and delete a temporary file in the target directory.
+
+### isFileSystemCaseSensitive(path?)
+
+Returns `Promise<boolean>` — `true` if case-sensitive, `false` otherwise.
+
+### isFileSystemCaseSensitiveSync(path?)
+
+Sync version of `isFileSystemCaseSensitive`.
+
+Returns `boolean`.
+
+#### path
+
+Type: `string`\
+Default: `process.cwd()`
+
+The path to check. Can be a file, directory, or non-existent path. Non-existent paths walk up to the nearest existing parent directory.
+
+## cjser
+
+This package is a CommonJS-compatible build generated by cjser for projects that still need `require()` support. The source version matches the original npm package version, with a cjser prerelease suffix for this generated build.
+Original repository: https://github.com/sindresorhus/is-filesystem-case-sensitive