package-management 0.0.9 → 0.0.11

package/dist/index.cjs

@@ -4,9 +4,10 @@ const ErrorStackParser = require('error-stack-parser');
 const path = require('pathe');
 const process = require('node:process');
 const path$1 = require('node:path');
+const node_url = require('node:url');
 const node_fs = require('node:fs');
-const execa = require('execa');
 const asyncCacheFn = require('async-cache-fn');
+const execa = require('execa');
 const findUp = require('find-up');
 const promises = require('node:fs/promises');
 const mlly = require('mlly');
@@ -16,6 +17,10 @@ const WST = require('workspace-tools');
 const utils = require('pathe/utils');
 const os = require('node:os');
 const jsoncParser = require('jsonc-parser');
+const util = require('@arktype/util');
+const unstorage = require('unstorage');
+const defineMemoryDriver = require('unstorage/drivers/memory');
+const defineFsLiteDriver = require('unstorage/drivers/fs-lite');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 
@@ -38,16 +43,17 @@ const path__default = /*#__PURE__*/_interopDefaultCompat(path$1);
 const gitignoreParser__default = /*#__PURE__*/_interopDefaultCompat(gitignoreParser);
 const WST__namespace = /*#__PURE__*/_interopNamespaceCompat(WST);
 const os__default = /*#__PURE__*/_interopDefaultCompat(os);
+const defineMemoryDriver__default = /*#__PURE__*/_interopDefaultCompat(defineMemoryDriver);
+const defineFsLiteDriver__default = /*#__PURE__*/_interopDefaultCompat(defineFsLiteDriver);
 
 const toArray = (data) => Array.isArray(data) ? data : [data];
 const entriesOf = (o) => Object.entries(o);
 const fromEntries = (entries) => Object.fromEntries(entries);
 const notFalsy = (value) => [false, null, void 0].every((v) => v !== value);
 const select = (obj, selection, mode) => {
-  if (!selection)
-    return obj;
+  if (!selection) return obj;
   const filtered = entriesOf(obj).filter(([key]) => {
-    return mode === "omit" ? !selection[key] : selection[key];
+    return selection[key];
   });
   return fromEntries(filtered);
 };
@@ -66,15 +72,36 @@ const invariant = (predicate, message) => {
   }
 };
 function getArrayItemAtOffset(arr, index, offset = 0) {
-  if (!index || !arr)
-    return void 0;
+  if (arr === void 0 || index === void 0) return void 0;
   return arr[index + offset];
 }
 function isMatching(a, b) {
-  if (!a || !b)
-    return false;
+  if (!a || !b) return false;
   return a === b;
 }
+function checkResult(cb, options) {
+  try {
+    return buildSingleProp({
+      key: options?.keys?.data ?? "data",
+      value: cb()
+    });
+  } catch (error) {
+    return buildSingleProp({
+      key: "error",
+      value: error
+    });
+  }
+}
+function isPropertyKey(input) {
+  return typeof input === "string" || typeof input === "number" || typeof input === "symbol";
+}
+function buildSingleProp(entry) {
+  const [key, value] = Array.isArray(entry) ? entry : [entry.key, entry.value];
+  if (!isPropertyKey(key)) {
+    return {};
+  }
+  return { [key]: value };
+}
 
 function findCallerStackFrame(options) {
   return findErrorStackFrame(options, (frame) => frame.isParentOfRootFunction);
@@ -135,7 +162,7 @@ function getFilePathData({
   cwd
 }) {
   const workingDir = cwd ?? process__default.cwd();
-  const filePath = path.normalize(filepath);
+  const filePath = path.normalize(toFilePath(filepath));
   const fileBasename = path.basename(filePath);
   const dirPath = path.dirname(filePath);
   const dirBasename = path.basename(dirPath);
@@ -152,17 +179,18 @@ function getFilePathData({
     isFileInCwd
   };
 }
+function toFilePath(fileName) {
+  return fileName.startsWith("file:") ? node_url.fileURLToPath(fileName) : fileName;
+}
 function parseFunctionName(functionName) {
-  if (!functionName)
-    return void 0;
+  if (!functionName) return void 0;
   return removeStart(functionName, "Module.");
 }
 function removeStart(input, value) {
   return input.startsWith(value) ? input.slice(value.length) : input;
 }
 function placeFormatter(index, total) {
-  if (!index || !total)
-    return void 0;
+  if (index === void 0 || !total) return void 0;
   return [index, total].join("/");
 }
 
@@ -196,8 +224,7 @@ function resolvePackageModulePath(name, options) {
 function findResolvedModulePath(paths, options) {
   for (const path of paths) {
     const resolvedPath = resolveModulePath(path, options);
-    if (resolvedPath === void 0)
-      continue;
+    if (resolvedPath === void 0) continue;
     return resolvedPath;
   }
 }
@@ -251,8 +278,7 @@ function isDependencyInPackageJson(options, packageJson) {
 }
 function findDependencyInPackageJson(option, packageJson) {
   const { name, type } = typeof option === "string" ? { name: option, type: void 0 } : option;
-  if (!packageJson)
-    return void 0;
+  if (!packageJson) return void 0;
   const allowedTypes = typeof type === "string" ? {
     [type]: true
   } : type ?? {
@@ -263,8 +289,7 @@ function findDependencyInPackageJson(option, packageJson) {
   const matches = allowedDependencyTypes.map((type2) => {
     return getPackageJsonDependencyItem({ name, type: type2 }, packageJson);
   }).filter(notFalsy);
-  if (matches.length === 0)
-    return void 0;
+  if (matches.length === 0) return void 0;
   return {
     firstMatch: matches[0],
     matches
@@ -274,12 +299,10 @@ function getPackageJsonDependencyItem({
   name,
   type
 }, packageJson) {
-  if (!packageJson)
-    return void 0;
+  if (!packageJson) return void 0;
   const dependencyMap = getPackageJsonDependencyMap(type, packageJson);
   const version = dependencyMap?.[name];
-  if (version === void 0)
-    return void 0;
+  if (version === void 0) return void 0;
   return {
     name,
     version,
@@ -301,7 +324,7 @@ function getWorkspaceFolder(options) {
     fallbackToGitRoot = true,
     throwIfNotFound = true
   } = options ?? {};
-  const getFolder = fallbackToGitRoot ? WST__namespace.findProjectRoot : WST__namespace.getWorkspaceRoot;
+  const getFolder = fallbackToGitRoot ? WST__namespace.findProjectRoot : WST__namespace.getWorkspaceManagerRoot;
   const folder = getFolder(cwd);
   if (folder === void 0 && throwIfNotFound) {
     throw new Error(`Could not find workspace folder`);
@@ -344,17 +367,15 @@ function getWorkspaceProjectInfo(options) {
 
 function getWorkspacePackageInfoList(options) {
   const { workspaceDir, resolveWstList } = common(options);
-  const wstList = WST__namespace.getWorkspaces(workspaceDir);
+  const wstList = WST__namespace.getWorkspaceInfos(workspaceDir);
   return resolveWstList(wstList);
 }
 function common(options) {
   const { cwd, includeRoot: includeWorkspace } = options ?? {};
   const workspaceDir = getWorkspaceFolder({ cwd });
   function resolveWstList(list) {
-    if (!workspaceDir)
-      return [];
-    if (includeWorkspace)
-      return [getWorkspaceProjectInfo(), ...list];
+    if (!workspaceDir || !list) return [];
+    if (includeWorkspace) return [getWorkspaceProjectInfo(), ...list];
     return list;
   }
   return {
@@ -375,6 +396,21 @@ function getProjectInfoByName(name, options) {
   return getWorkspacePackageInfoMap({ cwd })[name];
 }
 
+function getGitRootFolder(options) {
+  const { cwd = process__default.cwd(), throwIfNotFound = true } = options ?? {};
+  const { stdout } = execa.execaSync("git", ["rev-parse", "--show-toplevel"], {
+    cwd,
+    reject: false
+  });
+  if (!stdout) {
+    if (throwIfNotFound) {
+      throw new Error(`Directory "${cwd}" is not in a git repository`);
+    }
+    return void 0;
+  }
+  return path__default$1.normalize(stdout);
+}
+
 function getProjectInfo(folder, options) {
   if (isWorkspaceFolderTypeOption(folder)) {
     return getWorkspaceProjectInfo(
@@ -385,7 +421,7 @@ function getProjectInfo(folder, options) {
     return getPackageInfo(options);
   }
   if (folder === "<gitroot_folder>") {
-    return getPackageInfo(options);
+    return readPackageInfo({ packageDir: getGitRootFolder(options) });
   }
   return getProjectInfoByName(folder.packageName, options);
 }
@@ -400,9 +436,6 @@ function parseWorkspaceFolderTypeOptions(option, defaultOptions) {
   }
   return { ...defaultOptions, ...option["<workspace_folder>"] };
 }
-getProjectInfo({
-  "<workspace_folder>": {}
-});
 
 const project = (...args) => {
   const [source, projectOptions] = args;
@@ -412,7 +445,9 @@ const project = (...args) => {
     detectPackageManagers,
     detectLockfilePackageManagers,
     detectGlobalPackageManagers,
-    filterPackageManagers
+    globalVersions,
+    filterPackageManagers,
+    mapPackageManagers
   } = definePackageManagerClient({ cwd: projectDir });
   return {
     packageJson,
@@ -423,6 +458,8 @@ const project = (...args) => {
     detectPackageManagers,
     detectGlobalPackageManagers,
     detectLockfilePackageManagers,
+    globalVersions,
+    mapPackageManagers,
     tsconfig: tsconfig(projectDir ?? ""),
     gitignore: gitignore(path__default$1.join(projectDir ?? "", ".gitignore")),
     filterPackageManagers,
@@ -497,11 +534,9 @@ function resolveImportOption(option) {
   return option;
 }
 async function installImport(packageName, options, installer) {
-  if (!packageName)
-    return;
+  if (!packageName) return;
   const { checkExists } = options ?? {};
-  if (checkExists && isPackageDependency(packageName))
-    return;
+  if (checkExists && isPackageDependency(packageName)) return;
   const installerFn = installer ?? (await workspace.getProject("<package_folder>").findPackageManager()).installPackage;
   await installerFn(packageName, options);
 }
@@ -533,9 +568,7 @@ function definePackageManager(config, options) {
         preferOffline: true,
         cwd: defaultCwd,
         ...options2
-      },
-      "pick"
-    );
+      });
     const packageNames = toArray(packageName);
     try {
       await $$({
@@ -544,25 +577,32 @@ function definePackageManager(config, options) {
         cwd: defaultCwd,
         ...options2
       });
-    } catch (e) {
-      throw new Error(`Failed to install: ${packageNames.join(", ")}`);
+    } catch (error) {
+      throw new Error(`Failed to install: ${packageNames.join(", ")}`, {
+        cause: error
+      });
     }
   };
   const uninstallPackage = async (packageName, options2) => {
     const uninstall = agentArgs.uninstall;
-    await Promise.all(
-      toArray(packageName).map(async (name) => {
-        try {
-          await $$({
-            command,
-            args: [uninstall.command, name],
-            cwd: defaultCwd,
-            ...options2
-          });
-        } catch (e) {
-        }
-      })
+    const cwd = options2?.cwd ?? defaultCwd;
+    const { packageJson } = getPackageInfo({ cwd });
+    const installed = toArray(packageName).filter(
+      (name) => isDependencyInPackageJson(name, packageJson)
     );
+    if (installed.length === 0) return;
+    try {
+      await $$({
+        command,
+        args: [uninstall.command, ...installed],
+        cwd,
+        ...options2
+      });
+    } catch (error) {
+      throw new Error(`Failed to uninstall: ${installed.join(", ")}`, {
+        cause: error
+      });
+    }
   };
   return {
     id: config.id,
@@ -574,8 +614,7 @@ function definePackageManager(config, options) {
     }),
     readLockfile: asyncCacheFn.asyncCacheFn(async (...args) => {
       const lockfilePath = await findLockfilePath.noCache(...args);
-      if (!lockfilePath)
-        return void 0;
+      if (!lockfilePath) return void 0;
       return promises.readFile(lockfilePath, "utf8");
     }),
     globalVersion: asyncCacheFn.asyncCacheFn(async (...args) => {
@@ -609,7 +648,10 @@ async function $$(options) {
   return execa.execa(command, args.filter(notFalsy), {
     cwd,
     ...shellOptions,
-    stdio: silent ? "ignore" : "inherit"
+    // `pipe` keeps output off the console while still capturing it: a failed
+    // command can report why it failed, and `globalVersion` can read stdout.
+    // `ignore` discards the reason along with the output.
+    stdio: silent ? "pipe" : "inherit"
   });
 }
 
@@ -718,18 +760,24 @@ const yarn = definePackageManagerConfig({
 });
 
 async function findPackageManager(packageManagers, options) {
-  const { ...rest } = options ?? {};
-  const packageManager = await findPackageManagerSafely(packageManagers, rest);
+  const packageManager = await findPackageManagerSafely(
+    packageManagers,
+    options
+  );
   invariant(packageManager, "No package manager found");
   return packageManager;
 }
 async function findPackageManagerSafely(packageManagers, options) {
-  const lockfilePm = (await detectLockfilePackageManagers(packageManagers, options))[0];
-  if (lockfilePm) {
-    return lockfilePm;
-  }
-  const globalPm = (await detectGlobalPackageManagers(packageManagers, options))[0];
-  return globalPm;
+  const [fromLockfile] = await detectLockfilePackageManagers(
+    packageManagers,
+    options
+  );
+  if (fromLockfile) return fromLockfile;
+  const [fromGlobal] = await detectGlobalPackageManagers(
+    packageManagers,
+    options
+  );
+  return fromGlobal;
 }
 async function detectPackageManagers(packageManagers, options) {
   return [
@@ -740,29 +788,47 @@ async function detectPackageManagers(packageManagers, options) {
 async function detectLockfilePackageManagers(packageManagers, options) {
   return filterPackageManagers(
     packageManagers,
-    (e) => e.hasLockfile(options),
+    (packageManager) => packageManager.hasLockfile(options),
     options
   );
 }
 async function detectGlobalPackageManagers(packageManagers, options) {
   return filterPackageManagers(
     packageManagers,
-    async (e) => Boolean(e.globalVersion(options)),
+    // Without the `await`, `Boolean` receives a pending promise and is always
+    // `true`, so every package manager passes the filter regardless of whether
+    // it is actually installed.
+    async (packageManager) => Boolean(await packageManager.globalVersion(options)),
     options
   );
 }
+async function getGlobalVersions(packageManagers, options) {
+  const entries = await mapPackageManagers(
+    packageManagers,
+    async (packageManager) => [packageManager.id, await packageManager.globalVersion(options)],
+    options
+  );
+  return Object.fromEntries(entries);
+}
+async function mapPackageManagers(packageManagers, mapFn, options) {
+  return Promise.all(
+    selectAllowedPackageManagers(packageManagers, options).map(
+      (packageManager) => mapFn(packageManager)
+    )
+  );
+}
 async function filterPackageManagers(packageManagers, filterFn, options) {
-  const allowedPackageManagers = packageManagers.filter(({ id }) => {
-    if (!options?.allowed)
-      return true;
-    return id in options.allowed;
-  });
-  return (await Promise.all(
-    allowedPackageManagers.map(async (pm) => {
-      const valid = await filterFn(pm);
-      return valid ? pm : void 0;
-    })
-  )).filter(notFalsy);
+  const matches = await mapPackageManagers(
+    packageManagers,
+    async (packageManager) => await filterFn(packageManager) ? packageManager : void 0,
+    options
+  );
+  return matches.filter(notFalsy);
+}
+function selectAllowedPackageManagers(packageManagers, options) {
+  return packageManagers.filter(
+    ({ id }) => options?.allowed ? id in options.allowed : true
+  );
 }
 
 const packageManagerConfigs = [pnpm, yarn, bun, npm];
@@ -787,7 +853,11 @@ function definePackageManagerClient(options) {
     detectGlobalPackageManagers: asyncCacheFn.asyncCacheFn(
       async (options2) => detectGlobalPackageManagers(configs, options2)
     ),
-    filterPackageManagers: async (filterFn, options2) => filterPackageManagers(configs, filterFn, options2)
+    globalVersions: asyncCacheFn.asyncCacheFn(
+      async (options2) => getGlobalVersions(configs, options2)
+    ),
+    filterPackageManagers: async (filterFn, options2) => filterPackageManagers(configs, filterFn, options2),
+    mapPackageManagers: async (mapFn, options2) => mapPackageManagers(configs, mapFn, options2)
   };
 }
 
@@ -810,17 +880,13 @@ function definePathAliases(aliasDefinitions) {
   };
 }
 function getAliasedFilePath(aliasMap, options) {
+  const { to, startingFrom, cwd, checkExistence, glob } = typeof options === "string" || Array.isArray(options) ? { to: options } : options;
+  const resolveOptions = { cwd, checkExistence, glob, aliasMap };
   try {
-    if (typeof options === "string" || Array.isArray(options)) {
-      return resolvePathTo(options, { aliasMap });
-    }
-    const opts = { ...options, aliasMap };
-    if (opts.startingFrom) {
-      return resolveRelativePathTo(opts.to, opts.startingFrom, opts);
-    }
-    return resolvePathTo(opts.to, opts);
-  } catch (e) {
-    return void 0;
+    return startingFrom ? resolveRelativePathTo(to, startingFrom, resolveOptions) : resolvePathTo(to, resolveOptions);
+  } catch (error) {
+    if (checkExistence || glob) return void 0;
+    throw error;
   }
 }
 function resolveRelativePathTo(to, from, options) {
@@ -842,18 +908,20 @@ function resolvePathTo(pathTo, { cwd, checkExistence, glob, aliasMap }) {
 }
 function normalizePathTo(pathTo, options) {
   const { cwd, aliasMap } = options ?? {};
-  if (Array.isArray(pathTo)) {
-    const [baseDir] = pathTo;
-    const aliasedPath = path__default$1.join(...pathTo.filter(isNotNull));
-    return utils.resolveAlias(aliasedPath, {
-      [baseDir]: executeMapFn(aliasMap, baseDir, [{ cwd }])
-    });
+  const aliasedPath = Array.isArray(pathTo) ? path__default$1.join(...pathTo.filter(isNotNull)) : pathTo;
+  const baseDir = Array.isArray(pathTo) ? pathTo[0] : findAliasToken(aliasedPath, aliasMap);
+  if (baseDir === void 0) return aliasedPath;
+  const baseDirPath = executeMapFn(aliasMap, baseDir, [{ cwd }]);
+  if (typeof baseDirPath !== "string" || baseDirPath.length === 0) {
+    throw new Error(`Path alias resolved to no location: ${baseDir}`);
   }
-  return pathTo;
+  return utils.resolveAlias(aliasedPath, { [baseDir]: baseDirPath });
+}
+function findAliasToken(pathTo, aliasMap) {
+  return Object.keys(aliasMap ?? {}).filter((alias) => pathTo === alias || pathTo.startsWith(`${alias}/`)).sort((a, b) => b.length - a.length)[0];
 }
 function executeMapFn(map, key, args) {
-  if (!map || !key || !(key in map))
-    return void 0;
+  if (!map || !key || !(key in map)) return void 0;
   const fnArgs = Array.isArray(args) ? args : [args];
   const resolver = map?.[key];
   return typeof resolver === "function" ? resolver?.(...fnArgs) : resolver;
@@ -892,7 +960,7 @@ const predefinedPathAliases = {
     ]
   },
   "<workspace_folder?>": {
-    resolve: (opts) => getWorkspaceFolder(opts),
+    resolve: (opts) => getWorkspaceFolder({ ...opts, fallbackToGitRoot: false }),
     subpaths: [
       {
         to: "node_modules"
@@ -962,48 +1030,232 @@ function getFolderByPackageName(name, options) {
   return info?.dirpath;
 }
 
-function getGitRootFolder(options) {
-  const output = execa.execaSync(`git rev-parse --show-toplevel`, {
-    ...options,
-    reject: false
+const jsonSourceResolvers = {
+  data: (json) => {
+    return {
+      text: () => JSON.stringify(json),
+      data: () => json
+    };
+  },
+  text: (text) => {
+    return {
+      text: () => text,
+      data: () => JSON.parse(text)
+    };
+  },
+  filepath: (filepath) => {
+    const text = node_fs.readFileSync(filepath, "utf-8");
+    return {
+      text: () => text,
+      data: () => JSON.parse(text)
+    };
+  }
+};
+function resolveJsonSource(source, as) {
+  const [sourceType, sourceData] = Object.entries(source).find(([_, selected]) => selected !== void 0) ?? [];
+  if (!sourceType || !(sourceType in jsonSourceResolvers) || !sourceData) {
+    throw new Error("Invalid source data");
+  }
+  const sourceTypeResolvers = jsonSourceResolvers[sourceType](
+    sourceData
+  );
+  const resolved = util.morph(sourceTypeResolvers, (key, v) => {
+    try {
+      const value = v();
+      return !as || key === as ? [key, value] : [];
+    } catch (e) {
+      throw new Error(`Failed to resolve ${key} from ${sourceType}`);
+    }
   });
-  if (!output.stdout) {
-    console.warn(`Directory "${output.cwd}" is not in a git repository`);
-    return void 0;
+  if (as) {
+    return resolved[as];
   }
-  return path__default$1.normalize(output.stdout);
+  return resolved;
 }
 
-function modifyJSONCFileSync({
-  edits,
-  filepath,
-  autoCommit = true
-}) {
-  const jsoncContent = node_fs.readFileSync(filepath, "utf-8");
-  const modifiers = Array.isArray(edits) ? edits : [edits];
-  const editResult = modifiers.flatMap(
-    (edit) => jsoncParser.modify(jsoncContent, edit.paths, edit.update, {
-      formattingOptions: { tabSize: 0, insertSpaces: false }
+function resolveEditPath(path, options) {
+  const { pathSeparator = "." } = {};
+  const arr = toArray(path);
+  return arr.map((path2) => {
+    if (typeof path2 === "string") {
+      return pathSeparator === false ? path2 : path2.split(pathSeparator);
+    }
+    return path2;
+  }).flat();
+}
+function parseJSONCEdits(edits) {
+  if (Array.isArray(edits)) {
+    return edits.map(({ path, ...edit }) => ({
+      path: resolveEditPath(path),
+      ...edit
+    }));
+  }
+  return Object.entries(edits).map(
+    ([path, value]) => ({
+      path: resolveEditPath(path),
+      ...value
     })
   );
-  const updatedFileContent = jsoncParser.applyEdits(jsoncContent, editResult);
-  const commit = () => node_fs.writeFileSync(filepath, updatedFileContent);
-  if (autoCommit) {
-    commit();
-  }
-  return {
-    updatedFileContent,
-    commit
+}
+function modifyJSON({
+  json,
+  edits,
+  defaultEditOptions
+}) {
+  return checkResult(() => {
+    const text = resolveJsonSource(json, "text");
+    const jsoncEdits = parseJSONCEdits(edits);
+    const editResult = jsoncEdits.flatMap(
+      (edit) => jsoncParser.modify(text, edit.path, edit.value, {
+        ...defaultEditOptions,
+        ...edit.options
+      })
+    );
+    const updated = jsoncParser.applyEdits(text, editResult);
+    return resolveJsonSource({ text: updated });
+  });
+}
+function modifyJSONFile(filepath, edits, options) {
+  return checkResult(() => {
+    const { autoCommit = true, defaultEditOptions } = options || {};
+    const { data: json, error } = modifyJSON({
+      json: { filepath },
+      edits,
+      defaultEditOptions
+    });
+    if (error) {
+      throw error;
+    }
+    const commit = () => node_fs.writeFileSync(filepath, json.text);
+    if (autoCommit) {
+      commit();
+      return json;
+    }
+    return {
+      json,
+      commit
+    };
+  });
+}
+
+function isStorageValue(input) {
+  return input === null || typeof input === "string" || typeof input === "number" || typeof input === "boolean" || typeof input === "object";
+}
+
+const storage = unstorage.createStorage({ driver: defineMemoryDriver__default() });
+const tempFileSystem = defineFileSystemStorage({
+  base: path.join(os__default.tmpdir(), ".package-manager")
+});
+function defineFileSystemEntries(definition) {
+  const fileSystemEntries = Object.entries(definition).map(([k, v]) => {
+    if (v instanceof Function) {
+      const {
+        file,
+        options,
+        serialize = (input) => JSON.stringify(input),
+        deserialize = (input) => {
+          try {
+            return JSON.parse(input);
+          } catch {
+            return input;
+          }
+        }
+      } = v();
+      return {
+        key: k,
+        value: serialize(file),
+        options,
+        serialize,
+        deserialize
+      };
+    }
+    if (isStorageValue(v)) {
+      return {
+        key: k,
+        value: JSON.stringify(v)
+      };
+    }
+    return void 0;
+  }).filter((v) => v !== void 0);
+  const resolved = {
+    definition,
+    fileSystemEntries
   };
+  return resolved;
 }
-const jsonc = (filepath) => {
-  return {
-    modify: (edits, options) => modifyJSONCFileSync({ edits, filepath, ...options })
+function defineFileSystemStorage(options) {
+  const { base: root, initial, ...storageOptions } = options;
+  let initialFileEntriesData = defineFileSystemEntries(initial ?? {});
+  const storage2 = unstorage.createStorage({
+    driver: defineFsLiteDriver__default({ base: root, ...storageOptions })
+  });
+  const fileStorage = {
+    createFile: async (key, data) => {
+      await storage2.setItem(key, data);
+      return {
+        key,
+        filepath: path.join(root, key),
+        get: async () => storage2.getItem(key),
+        update: async (data2) => storage2.setItem(key, data2)
+      };
+    },
+    async getFilePath(key) {
+      return (await this.getFile(key)).filepath;
+    },
+    getFile: async (key) => {
+      const storageData = await storage2.getItem(key);
+      return {
+        key,
+        filepath: path.join(root, key),
+        data: storageData,
+        read: async () => (await storage2.getItemRaw(key))?.toString()
+      };
+    },
+    async readFile(key) {
+      const { read } = await this.getFile(key);
+      const content = await read();
+      return content;
+    },
+    snapshotFs: async (base = root) => {
+      return unstorage.snapshot(storage2, base);
+    },
+    restoreFs: async (snapshot2) => {
+      return unstorage.restoreSnapshot(storage2, snapshot2);
+    },
+    initializeFs: async (override) => {
+      if (override) {
+        initialFileEntriesData = defineFileSystemEntries(override);
+      }
+      await storage2.clear();
+      return storage2.setItems(initialFileEntriesData.fileSystemEntries);
+    },
+    defineFileSystemEntries,
+    removeAllFiles: storage2.clear,
+    async deleteFileSystem() {
+      await this.removeAllFiles();
+      await storage2.unmount(root, true);
+      await promises.rm(root, { recursive: true, force: true });
+    },
+    storage: storage2,
+    meta: {
+      fileEntriesData: initialFileEntriesData
+    }
   };
-};
+  if (initial) {
+    return {
+      initialize: async () => {
+        await fileStorage.initializeFs(initial);
+        return fileStorage;
+      }
+    };
+  }
+  return fileStorage;
+}
 
 exports._dirname = _dirname;
 exports._filename = _filename;
+exports.defineFileSystemEntries = defineFileSystemEntries;
+exports.defineFileSystemStorage = defineFileSystemStorage;
 exports.definePackage = definePackage;
 exports.definePackageManagerClient = definePackageManagerClient;
 exports.definePathAliases = definePathAliases;
@@ -1018,6 +1270,7 @@ exports.findResolvedModulePath = findResolvedModulePath;
 exports.getAliasMap = getAliasMap;
 exports.getFolderByPackageName = getFolderByPackageName;
 exports.getGitRootFolder = getGitRootFolder;
+exports.getGlobalVersions = getGlobalVersions;
 exports.getPackageFolder = getPackageFolder;
 exports.getPath = getPath;
 exports.getWorkspaceFolder = getWorkspaceFolder;
@@ -1026,11 +1279,15 @@ exports.importer = importer;
 exports.isDependencyInPackageJson = isDependencyInPackageJson;
 exports.isPackageDependency = isPackageDependency;
 exports.isPackageModuleFound = isPackageModuleFound;
-exports.jsonc = jsonc;
+exports.mapPackageManagers = mapPackageManagers;
+exports.modifyJSON = modifyJSON;
+exports.modifyJSONFile = modifyJSONFile;
 exports.packageManagerConfigs = packageManagerConfigs;
 exports.predefinedPathAliases = predefinedPathAliases;
 exports.project = project;
 exports.resolveModule = resolveModule;
 exports.resolveModulePath = resolveModulePath;
 exports.resolvePackageModulePath = resolvePackageModulePath;
+exports.storage = storage;
+exports.tempFileSystem = tempFileSystem;
 exports.workspace = workspace;