@pnpm/resolving.local-resolver 1002.1.4

package/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2016 Rico Sta. Cruz and other contributors
+Copyright (c) 2016-2026 Zoltan Kochan and other contributors
+
+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/README.md

@@ -0,0 +1,38 @@
+# @pnpm/local-resolver
+
+> Resolver for local packages
+
+<!--@shields('npm')-->
+[![npm version](https://img.shields.io/npm/v/@pnpm/local-resolver.svg)](https://www.npmjs.com/package/@pnpm/local-resolver)
+<!--/@-->
+
+## Installation
+
+```
+pnpm add @pnpm/local-resolver
+```
+
+## Usage
+
+```js
+'use strict'
+const resolveFromLocal = require('@pnpm/local-resolver').default
+
+resolveFromLocal({bareSpecifier: './example-package'}, {prefix: process.cwd()})
+  .then(resolveResult => console.log(resolveResult))
+//> { id: 'link:example-package',
+//    normalizedBareSpecifier: 'link:example-package',
+//    package:
+//     { name: 'foo',
+//       version: '1.0.0',
+//       readme: '# foo\n',
+//       readmeFilename: 'README.md',
+//       description: '',
+//       _id: 'foo@1.0.0' },
+//    resolution: { directory: 'example-package', type: 'directory' }
+//    resolvedVia: 'local-filesystem' }
+```
+
+## License
+
+MIT

package/lib/index.d.ts

@@ -0,0 +1,24 @@
+import type { DirectoryResolution, Resolution, ResolveResult, TarballResolution } from '@pnpm/resolving.resolver-base';
+import type { DependencyManifest, PkgResolutionId } from '@pnpm/types';
+import { type WantedLocalDependency } from './parseBareSpecifier.js';
+export { type WantedLocalDependency };
+export interface LocalResolveResult extends ResolveResult {
+    manifest?: DependencyManifest;
+    normalizedBareSpecifier?: string;
+    resolution: DirectoryResolution | TarballResolution;
+    resolvedVia: 'local-filesystem';
+}
+/**
+ * Resolves a package hosted on the local filesystem
+ */
+export declare function resolveFromLocal(ctx: {
+    preserveAbsolutePaths?: boolean;
+}, wantedDependency: WantedLocalDependency, opts: {
+    lockfileDir?: string;
+    projectDir: string;
+    currentPkg?: {
+        id: PkgResolutionId;
+        resolution: DirectoryResolution | TarballResolution | Resolution;
+    };
+    update?: false | 'compatible' | 'latest';
+}): Promise<LocalResolveResult | null>;

package/lib/index.js

@@ -0,0 +1,85 @@
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { getTarballIntegrity } from '@pnpm/crypto.hash';
+import { PnpmError } from '@pnpm/error';
+import { logger } from '@pnpm/logger';
+import { readProjectManifestOnly } from '@pnpm/workspace.project-manifest-reader';
+import { parseBareSpecifier } from './parseBareSpecifier.js';
+export {};
+/**
+ * Resolves a package hosted on the local filesystem
+ */
+export async function resolveFromLocal(ctx, wantedDependency, opts) {
+    const preserveAbsolutePaths = ctx.preserveAbsolutePaths ?? false;
+    const spec = parseBareSpecifier(wantedDependency, opts.projectDir, opts.lockfileDir ?? opts.projectDir, { preserveAbsolutePaths });
+    if (spec == null)
+        return null;
+    if (spec.type === 'file') {
+        const integrity = await getTarballIntegrity(spec.fetchSpec);
+        return {
+            id: spec.id,
+            normalizedBareSpecifier: spec.normalizedBareSpecifier,
+            resolution: {
+                integrity,
+                tarball: spec.id,
+            },
+            resolvedVia: 'local-filesystem',
+        };
+    }
+    // Skip resolution if we have a current package and not updating
+    if (opts.currentPkg?.resolution && spec.type === 'directory' && !opts.update) {
+        return {
+            id: opts.currentPkg.id,
+            resolution: opts.currentPkg.resolution,
+            resolvedVia: 'local-filesystem',
+        };
+    }
+    let localDependencyManifest;
+    try {
+        localDependencyManifest = await readProjectManifestOnly(spec.fetchSpec);
+    }
+    catch (internalErr) { // eslint-disable-line
+        if (!existsSync(spec.fetchSpec)) {
+            if (spec.id.startsWith('file:')) {
+                throw new PnpmError('LINKED_PKG_DIR_NOT_FOUND', `Could not install from "${spec.fetchSpec}" as it does not exist.`);
+            }
+            logger.warn({
+                message: `Installing a dependency from a non-existent directory: ${spec.fetchSpec}`,
+                prefix: opts.projectDir,
+            });
+            localDependencyManifest = {
+                name: path.basename(spec.fetchSpec),
+                version: '0.0.0',
+            };
+        }
+        else {
+            switch (internalErr.code) {
+                case 'ENOTDIR': {
+                    throw new PnpmError('NOT_PACKAGE_DIRECTORY', `Could not install from "${spec.fetchSpec}" as it is not a directory.`);
+                }
+                case 'ERR_PNPM_NO_IMPORTER_MANIFEST_FOUND':
+                case 'ENOENT': {
+                    localDependencyManifest = {
+                        name: path.basename(spec.fetchSpec),
+                        version: '0.0.0',
+                    };
+                    break;
+                }
+                default: {
+                    throw internalErr;
+                }
+            }
+        }
+    }
+    return {
+        id: spec.id,
+        manifest: localDependencyManifest,
+        normalizedBareSpecifier: spec.normalizedBareSpecifier,
+        resolution: {
+            directory: spec.dependencyPath,
+            type: 'directory',
+        },
+        resolvedVia: 'local-filesystem',
+    };
+}
+//# sourceMappingURL=index.js.map

package/lib/parseBareSpecifier.d.ts

@@ -0,0 +1,15 @@
+import type { PkgResolutionId } from '@pnpm/resolving.resolver-base';
+export interface LocalPackageSpec {
+    dependencyPath: string;
+    fetchSpec: string;
+    id: PkgResolutionId;
+    type: 'directory' | 'file';
+    normalizedBareSpecifier: string;
+}
+export interface WantedLocalDependency {
+    bareSpecifier: string;
+    injected?: boolean;
+}
+export declare function parseBareSpecifier(wd: WantedLocalDependency, projectDir: string, lockfileDir: string, opts: {
+    preserveAbsolutePaths: boolean;
+}): LocalPackageSpec | null;

package/lib/parseBareSpecifier.js

@@ -0,0 +1,105 @@
+import os from 'node:os';
+import path from 'node:path';
+import { PnpmError } from '@pnpm/error';
+import normalize from 'normalize-path';
+// @ts-expect-error
+const isWindows = process.platform === 'win32' || global['FAKE_WINDOWS'];
+const isFilespec = isWindows ? /^(?:[./\\]|~\/|[a-z]:)/i : /^(?:[./]|~\/|[a-z]:)/i;
+const isFilename = /\.(?:tgz|tar.gz|tar)$/i;
+const isAbsolutePath = /^\/|^[A-Z]:/i;
+class PathIsUnsupportedProtocolError extends PnpmError {
+    bareSpecifier;
+    protocol;
+    constructor(bareSpecifier, protocol) {
+        super('PATH_IS_UNSUPPORTED_PROTOCOL', 'Local dependencies via `path:` protocol are not supported. ' +
+            'Use the `link:` protocol for folder dependencies and `file:` for local tarballs');
+        this.bareSpecifier = bareSpecifier;
+        this.protocol = protocol;
+    }
+}
+export function parseBareSpecifier(wd, projectDir, lockfileDir, opts) {
+    if (wd.bareSpecifier.startsWith('link:') || wd.bareSpecifier.startsWith('workspace:')) {
+        return fromLocal(wd, projectDir, lockfileDir, 'directory', opts);
+    }
+    if (wd.bareSpecifier.endsWith('.tgz') ||
+        wd.bareSpecifier.endsWith('.tar.gz') ||
+        wd.bareSpecifier.endsWith('.tar') ||
+        wd.bareSpecifier.includes(path.sep) ||
+        wd.bareSpecifier.startsWith('file:') ||
+        isFilespec.test(wd.bareSpecifier)) {
+        const type = isFilename.test(wd.bareSpecifier) ? 'file' : 'directory';
+        return fromLocal(wd, projectDir, lockfileDir, type, opts);
+    }
+    if (wd.bareSpecifier.startsWith('path:')) {
+        throw new PathIsUnsupportedProtocolError(wd.bareSpecifier, 'path:');
+    }
+    return null;
+}
+function fromLocal({ bareSpecifier, injected }, projectDir, lockfileDir, type, opts) {
+    const spec = bareSpecifier.replace(/\\/g, '/')
+        .replace(/^(?:file|link|workspace):\/*([A-Z]:)/i, '$1') // drive name paths on windows
+        .replace(/^(?:file|link|workspace):(?:\/*([~./]))?/, '$1');
+    let protocol;
+    if (bareSpecifier.startsWith('file:')) {
+        protocol = 'file:';
+    }
+    else if (bareSpecifier.startsWith('link:')) {
+        protocol = 'link:';
+    }
+    else {
+        protocol = type === 'directory' && !injected ? 'link:' : 'file:';
+    }
+    let fetchSpec;
+    let normalizedBareSpecifier;
+    if (/^~\//.test(spec)) {
+        // this is needed for windows and for file:~/foo/bar
+        fetchSpec = resolvePath(os.homedir(), spec.slice(2));
+        normalizedBareSpecifier = `${protocol}${spec}`;
+    }
+    else {
+        fetchSpec = resolvePath(projectDir, spec);
+        if (isAbsolute(spec)) {
+            normalizedBareSpecifier = `${protocol}${spec}`;
+        }
+        else {
+            normalizedBareSpecifier = `${protocol}${path.relative(projectDir, fetchSpec)}`;
+        }
+    }
+    function normalizeRelativeOrAbsolute(relativeTo, fromPath) {
+        let specPath;
+        if (opts.preserveAbsolutePaths && isAbsolute(spec)) {
+            specPath = path.resolve(fromPath);
+        }
+        else {
+            specPath = path.relative(relativeTo, fromPath);
+        }
+        return normalize(specPath);
+    }
+    injected = protocol === 'file:';
+    const dependencyPath = injected
+        ? normalizeRelativeOrAbsolute(lockfileDir, fetchSpec)
+        : normalize(path.resolve(fetchSpec));
+    const id = (!injected && (type === 'directory' || projectDir === lockfileDir)
+        ? `${protocol}${normalizeRelativeOrAbsolute(projectDir, fetchSpec)}`
+        : `${protocol}${normalizeRelativeOrAbsolute(lockfileDir, fetchSpec)}`);
+    return {
+        dependencyPath,
+        fetchSpec,
+        id,
+        normalizedBareSpecifier,
+        type,
+    };
+}
+function resolvePath(where, spec) {
+    if (isAbsolutePath.test(spec))
+        return spec;
+    return path.resolve(where, spec);
+}
+function isAbsolute(dir) {
+    if (dir[0] === '/')
+        return true;
+    if (/^[A-Z]:/i.test(dir))
+        return true;
+    return false;
+}
+//# sourceMappingURL=parseBareSpecifier.js.map

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@pnpm/resolving.local-resolver",
+  "version": "1002.1.4",
+  "description": "Resolver for local packages",
+  "keywords": [
+    "pnpm",
+    "pnpm11",
+    "npm",
+    "resolver"
+  ],
+  "license": "MIT",
+  "funding": "https://opencollective.com/pnpm",
+  "repository": "https://github.com/pnpm/pnpm/tree/main/resolving/local-resolver",
+  "homepage": "https://github.com/pnpm/pnpm/tree/main/resolving/local-resolver#readme",
+  "bugs": {
+    "url": "https://github.com/pnpm/pnpm/issues"
+  },
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": "./lib/index.js"
+  },
+  "files": [
+    "lib",
+    "!*.map"
+  ],
+  "dependencies": {
+    "normalize-path": "^3.0.0",
+    "@pnpm/crypto.hash": "1000.2.1",
+    "@pnpm/error": "1000.0.5",
+    "@pnpm/types": "1000.9.0",
+    "@pnpm/resolving.resolver-base": "1005.1.0",
+    "@pnpm/workspace.project-manifest-reader": "1001.1.4"
+  },
+  "peerDependencies": {
+    "@pnpm/logger": ">=1001.0.0 <1002.0.0"
+  },
+  "devDependencies": {
+    "@jest/globals": "30.0.5",
+    "@types/normalize-path": "^3.0.2",
+    "@pnpm/resolving.local-resolver": "1002.1.4",
+    "@pnpm/logger": "1001.0.1"
+  },
+  "engines": {
+    "node": ">=22.13"
+  },
+  "jest": {
+    "preset": "@pnpm/jest-config"
+  },
+  "scripts": {
+    "lint": "eslint \"src/**/*.ts\" \"test/**/*.ts\"",
+    "_test": "cross-env NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules --disable-warning=ExperimentalWarning --disable-warning=DEP0169\" jest",
+    "test": "pnpm run compile && pnpm run _test",
+    "fix": "tslint -c tslint.json src/**/*.ts test/**/*.ts --fix",
+    "compile": "tsgo --build && pnpm run lint --fix"
+  }
+}