package-management 0.0.2 → 0.0.3

package/dist/index.cjs

@@ -1,6 +1,9 @@
 'use strict';
 
+const ErrorStackParser = require('error-stack-parser');
 const path = require('pathe');
+const process = require('node:process');
+const path$1 = require('node:path');
 const node_fs = require('node:fs');
 const execa = require('execa');
 const asyncCacheFn = require('async-cache-fn');
@@ -10,8 +13,8 @@ const mlly = require('mlly');
 const globby = require('globby');
 const gitignoreParser = require('parse-gitignore');
 const WST = require('workspace-tools');
-const process = require('node:process');
-const path$1 = require('node:path');
+const utils = require('pathe/utils');
+const os = require('node:os');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 
@@ -27,11 +30,13 @@ function _interopNamespaceCompat(e) {
   return n;
 }
 
+const ErrorStackParser__default = /*#__PURE__*/_interopDefaultCompat(ErrorStackParser);
 const path__default$1 = /*#__PURE__*/_interopDefaultCompat(path);
-const gitignoreParser__default = /*#__PURE__*/_interopDefaultCompat(gitignoreParser);
-const WST__namespace = /*#__PURE__*/_interopNamespaceCompat(WST);
 const process__default = /*#__PURE__*/_interopDefaultCompat(process);
 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 toArray = (data) => Array.isArray(data) ? data : [data];
 const entriesOf = (o) => Object.entries(o);
@@ -59,6 +64,115 @@ const invariant = (predicate, message) => {
     throw new Error(message);
   }
 };
+function getArrayItemAtOffset(arr, index, offset = 0) {
+  if (!index || !arr)
+    return void 0;
+  return arr[index + offset];
+}
+function isMatching(a, b) {
+  if (!a || !b)
+    return false;
+  return a === b;
+}
+
+function findCallerStackFrame(options) {
+  return findErrorStackFrame(options, (frame) => frame.isParentOfRootFunction);
+}
+function findErrorStackFrame(options, find) {
+  return getErrorStackFrames(options, find)[0];
+}
+function getErrorStackFrames(options, filter) {
+  const { error, rootFunctionName, startFrom = "top" } = options;
+  const frames = startFrom === "bottom" ? ErrorStackParser__default.parse(error).reverse() : ErrorStackParser__default.parse(error);
+  const { parsedFrames } = frames.reduce(
+    (acc, frame, index) => {
+      const parsed = parseFrame({
+        frame,
+        index,
+        rootFunctionName,
+        frames
+      });
+      const isValid = filter ? filter(parsed) : true;
+      if (isValid) {
+        acc.parsedFrames.push(parsed);
+      }
+      return acc;
+    },
+    { parsedFrames: [] }
+  );
+  return parsedFrames ?? [];
+}
+function parseFrame(options) {
+  const { frame, frames, index, rootFunctionName, cwd, debug } = options ?? {};
+  const functionName = parseFunctionName(frame.functionName);
+  const isRootFunction = isMatching(functionName, rootFunctionName);
+  const beforeFrameFunctionName = parseFunctionName(
+    getArrayItemAtOffset(frames, index, -1)?.functionName
+  );
+  const isParentOfRootFunction = isMatching(
+    beforeFrameFunctionName,
+    rootFunctionName
+  );
+  const fileData = frame.fileName ? getFilePathData({ filepath: frame.fileName, cwd }) : void 0;
+  const { isFileInCwd: isFrameInScope, ...restFileData } = fileData ?? {};
+  const data = {
+    ...restFileData,
+    functionName,
+    source: frame.source,
+    sourceFunctionName: frame.functionName,
+    isFrameInScope,
+    place: placeFormatter(index, frames?.length),
+    isRootFunction,
+    isParentOfRootFunction,
+    rootFunctionName
+  };
+  debug && console.log(data);
+  return data;
+}
+function getFilePathData({
+  filepath,
+  cwd
+}) {
+  const workingDir = cwd ?? process__default.cwd();
+  const filePath = path.normalize(filepath);
+  const fileBasename = path.basename(filePath);
+  const dirPath = path.dirname(filePath);
+  const dirBasename = path.basename(dirPath);
+  const relativeFilePath = path.relative(workingDir, filePath);
+  const relativeDirPath = path.dirname(relativeFilePath);
+  const isFileInCwd = filePath.startsWith(workingDir);
+  return {
+    filePath,
+    dirPath,
+    relativeFilePath,
+    relativeDirPath,
+    fileBasename,
+    dirBasename,
+    isFileInCwd
+  };
+}
+function parseFunctionName(functionName) {
+  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;
+  return [index, total].join("/");
+}
+
+const _filename = (options) => {
+  const { filePath } = findCallerStackFrame({ error: new Error(), ...options }) ?? {};
+  return filePath;
+};
+const _dirname = (options) => {
+  const { dirPath } = findCallerStackFrame({ error: new Error(), ...options }) ?? {};
+  return dirPath;
+};
 
 async function resolveModule(module) {
   const resolved = await module;
@@ -681,8 +795,191 @@ function isPackageDependency(packageName) {
   return toArray(packageName).every((name) => isDependencyInPackageJson(name));
 }
 
+function definePathAliases(aliasDefinitions) {
+  const aliasMap = getAliasMap(aliasDefinitions);
+  function getFilePath(options, aliases) {
+    return getAliasedFilePath(
+      { ...aliasMap, ...aliases },
+      options
+    );
+  }
+  return {
+    aliasDefinitions,
+    aliasMap,
+    getFilePath
+  };
+}
+function getAliasedFilePath(aliasMap, options) {
+  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;
+  }
+}
+function resolveRelativePathTo(to, from, options) {
+  const pathFrom = resolvePathTo(from, options);
+  const pathTo = resolvePathTo(to, options);
+  return path__default$1.relative(pathFrom, pathTo);
+}
+function resolvePathTo(pathTo, { cwd, checkExistence, glob, aliasMap }) {
+  const normalized = normalizePathTo(pathTo, { cwd, aliasMap });
+  if (glob) {
+    const globPaths = globby.globbySync(normalized, { cwd });
+    if (!globPaths[0])
+      throw new Error(`No paths found for glob: ${normalized}`);
+    return globPaths[0];
+  }
+  if (!glob && checkExistence && !node_fs.existsSync(normalized))
+    throw new Error(`Path does not exist: ${normalized}`);
+  return normalized;
+}
+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 }])
+    });
+  }
+  return pathTo;
+}
+function executeMapFn(map, key, args) {
+  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;
+}
+function getAliasMap(aliasDefs) {
+  return Object.fromEntries(
+    Object.entries(aliasDefs).flatMap(([alias, v]) => {
+      const { resolve, subpaths = [] } = v;
+      return [
+        [alias, resolve],
+        ...subpaths.map(({ to }) => {
+          const subpathAlias = path__default$1.join(alias, to);
+          return [
+            subpathAlias,
+            (opts) => utils.resolveAlias(subpathAlias, { [alias]: resolve(opts) })
+          ];
+        })
+      ];
+    })
+  );
+}
+function isNotNull(value) {
+  return value !== null && value !== void 0;
+}
+
+const predefinedPathAliases = {
+  "<workspace_folder>": {
+    resolve: (opts) => getWorkspaceFolder(opts),
+    subpaths: [
+      {
+        to: "node_modules"
+      },
+      {
+        to: "node_modules/.bin"
+      }
+    ]
+  },
+  "<workspace_folder?>": {
+    resolve: (opts) => getWorkspaceFolder(opts),
+    subpaths: [
+      {
+        to: "node_modules"
+      },
+      {
+        to: "node_modules/.bin"
+      }
+    ]
+  },
+  "<package_folder>": {
+    resolve: (opts) => getPackageFolder(opts),
+    subpaths: [
+      {
+        to: "node_modules"
+      },
+      {
+        to: "node_modules/.bin"
+      },
+      {
+        to: "src"
+      }
+    ]
+  },
+  "<gitroot_folder>": {
+    resolve: (opts) => getGitRootFolder(opts),
+    subpaths: [
+      {
+        to: "node_modules"
+      },
+      {
+        to: "node_modules/.bin"
+      },
+      {
+        to: ".vscode"
+      }
+    ]
+  },
+  "<user_home>": {
+    resolve: () => os__default.homedir(),
+    subpaths: []
+  },
+  "<user_tmpdir>": {
+    resolve: () => os__default.tmpdir(),
+    subpaths: []
+  },
+  "<cwd>": {
+    resolve: () => process__default.cwd(),
+    subpaths: []
+  },
+  "<current_file>": {
+    // resolve: () => fileURLToPath(import.meta.url),
+    resolve: () => _filename({ rootFunctionName: "getFilePath" }) ?? "",
+    subpaths: []
+  },
+  "<current_folder>": {
+    // resolve: () => fileURLToPath(import.meta.url),
+    resolve: () => _dirname({ rootFunctionName: "getFilePath" }) ?? "",
+    subpaths: []
+  }
+};
+
+const getPath = definePathAliases(predefinedPathAliases).getFilePath;
+getPath(["<workspace_folder>/node_modules/.bin"]);
+
+function getFolderByPackageName(name, options) {
+  const infoMap = getWorkspacePackageInfoMap({ ...options, includeRoot: true });
+  const info = infoMap?.[name];
+  return info?.dirpath;
+}
+
+function getGitRootFolder(options) {
+  const output = execa.execaSync(`git rev-parse --show-toplevel`, {
+    ...options,
+    reject: false
+  });
+  if (!output.stdout) {
+    console.warn(`Directory "${output.cwd}" is not in a git repository`);
+    return void 0;
+  }
+  return path__default$1.normalize(output.stdout);
+}
+
+exports._dirname = _dirname;
+exports._filename = _filename;
 exports.definePackage = definePackage;
 exports.definePackageManagerClient = definePackageManagerClient;
+exports.definePathAliases = definePathAliases;
 exports.detectGlobalPackageManagers = detectGlobalPackageManagers;
 exports.detectLockfilePackageManagers = detectLockfilePackageManagers;
 exports.detectPackageManagers = detectPackageManagers;
@@ -690,11 +987,19 @@ exports.filterPackageManagers = filterPackageManagers;
 exports.findPackageManager = findPackageManager;
 exports.findPackageManagerSafely = findPackageManagerSafely;
 exports.findResolvedModulePath = findResolvedModulePath;
+exports.getAliasMap = getAliasMap;
+exports.getFolderByPackageName = getFolderByPackageName;
+exports.getGitRootFolder = getGitRootFolder;
+exports.getPackageFolder = getPackageFolder;
+exports.getPath = getPath;
+exports.getWorkspaceFolder = getWorkspaceFolder;
 exports.importMap = importMap;
 exports.importer = importer;
 exports.isPackageDependency = isPackageDependency;
 exports.isPackageModuleFound = isPackageModuleFound;
 exports.packageManagerConfigs = packageManagerConfigs;
+exports.predefinedPathAliases = predefinedPathAliases;
 exports.resolveModule = resolveModule;
 exports.resolveModulePath = resolveModulePath;
 exports.resolvePackageModulePath = resolvePackageModulePath;
+exports.workspace = workspace;