package-management 0.0.2 → 0.0.4

package/dist/index.mjs

@@ -1,6 +1,9 @@
-import path$1, { normalize } from 'pathe';
-import { readFileSync } from 'node:fs';
-import { execa } from 'execa';
+import ErrorStackParser from 'error-stack-parser';
+import path$1, { normalize, basename, dirname, relative } from 'pathe';
+import process from 'node:process';
+import path from 'node:path';
+import { readFileSync, existsSync } from 'node:fs';
+import { execa, execaSync } from 'execa';
 import { asyncCacheFn } from 'async-cache-fn';
 import { findUp } from 'find-up';
 import { readFile } from 'node:fs/promises';
@@ -8,8 +11,8 @@ import { resolvePathSync } from 'mlly';
 import { globbySync } from 'globby';
 import gitignoreParser from 'parse-gitignore';
 import * as WST from 'workspace-tools';
-import process from 'node:process';
-import path from 'node:path';
+import { resolveAlias } from 'pathe/utils';
+import os from 'node:os';
 
 const toArray = (data) => Array.isArray(data) ? data : [data];
 const entriesOf = (o) => Object.entries(o);
@@ -37,6 +40,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.parse(error).reverse() : ErrorStackParser.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.cwd();
+  const filePath = normalize(filepath);
+  const fileBasename = basename(filePath);
+  const dirPath = dirname(filePath);
+  const dirBasename = basename(dirPath);
+  const relativeFilePath = relative(workingDir, filePath);
+  const relativeDirPath = 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;
@@ -659,4 +771,184 @@ function isPackageDependency(packageName) {
   return toArray(packageName).every((name) => isDependencyInPackageJson(name));
 }
 
-export { definePackage, definePackageManagerClient, detectGlobalPackageManagers, detectLockfilePackageManagers, detectPackageManagers, filterPackageManagers, findPackageManager, findPackageManagerSafely, findResolvedModulePath, importMap, importer, isPackageDependency, isPackageModuleFound, packageManagerConfigs, resolveModule, resolveModulePath, resolvePackageModulePath };
+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$1.relative(pathFrom, pathTo);
+}
+function resolvePathTo(pathTo, { cwd, checkExistence, glob, aliasMap }) {
+  const normalized = normalizePathTo(pathTo, { cwd, aliasMap });
+  if (glob) {
+    const globPaths = globbySync(normalized, { cwd });
+    if (!globPaths[0])
+      throw new Error(`No paths found for glob: ${normalized}`);
+    return globPaths[0];
+  }
+  if (!glob && checkExistence && !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$1.join(...pathTo.filter(isNotNull));
+    return 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$1.join(alias, to);
+          return [
+            subpathAlias,
+            (opts) => 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.homedir(),
+    subpaths: []
+  },
+  "<user_tmpdir>": {
+    resolve: () => os.tmpdir(),
+    subpaths: []
+  },
+  "<cwd>": {
+    resolve: () => process.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 = 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$1.normalize(output.stdout);
+}
+
+export { _dirname, _filename, definePackage, definePackageManagerClient, definePathAliases, detectGlobalPackageManagers, detectLockfilePackageManagers, detectPackageManagers, filterPackageManagers, findDependencyInPackageJson, findPackageManager, findPackageManagerSafely, findResolvedModulePath, getAliasMap, getFolderByPackageName, getGitRootFolder, getPackageFolder, getPath, getWorkspaceFolder, importMap, importer, isDependencyInPackageJson, isPackageDependency, isPackageModuleFound, packageManagerConfigs, predefinedPathAliases, project, resolveModule, resolveModulePath, resolvePackageModulePath, workspace };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "package-management",
   "description": "Simple type-safe utilities for programatically installing and importing packages",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "type": "module",
   "private": false,
   "files": [