@pnpm/releasing.exportable-manifest 1000.1.7

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,15 @@
+# @pnpm/exportable-manifest
+
+> Creates an exportable manifest
+
+[![npm version](https://img.shields.io/npm/v/@pnpm/exportable-manifest.svg)](https://www.npmjs.com/package/@pnpm/exportable-manifest)
+
+## Installation
+
+```sh
+pnpm add @pnpm/exportable-manifest
+```
+
+## License
+
+MIT

package/lib/index.d.ts

@@ -0,0 +1,17 @@
+import type { Catalogs } from '@pnpm/catalogs.types';
+import type { Hooks } from '@pnpm/hooks.pnpmfile';
+import type { ProjectManifest } from '@pnpm/types';
+import { type ExportedManifest } from './transform/index.js';
+export { type ExportedManifest };
+export interface MakePublishManifestOptions {
+    catalogs: Catalogs;
+    hooks?: Hooks;
+    modulesDir?: string;
+    readmeFile?: string;
+}
+export declare function createExportableManifest(dir: string, originalManifest: ProjectManifest, opts: MakePublishManifestOptions): Promise<ExportedManifest>;
+export type PublishDependencyConverter = (depName: string, depSpec: string, dir: string, modulesDir?: string) => Promise<string> | string;
+export interface MakePublishDependenciesOpts {
+    readonly modulesDir?: string;
+    readonly convertDependencyForPublish: PublishDependencyConverter;
+}

package/lib/index.js

@@ -0,0 +1,147 @@
+import path from 'node:path';
+import { resolveFromCatalog } from '@pnpm/catalogs.resolver';
+import { PnpmError } from '@pnpm/error';
+import { parseJsrSpecifier } from '@pnpm/resolving.jsr-specifier-parser';
+import { tryReadProjectManifest } from '@pnpm/workspace.project-manifest-reader';
+import { pMapValues } from 'p-map-values';
+import { omit } from 'ramda';
+import { overridePublishConfig } from './overridePublishConfig.js';
+import { transform } from './transform/index.js';
+export {};
+const PREPUBLISH_SCRIPTS = [
+    'prepublishOnly',
+    'prepack',
+    'prepare',
+    'postpack',
+    'publish',
+    'postpublish',
+];
+export async function createExportableManifest(dir, originalManifest, opts) {
+    let publishManifest = omit(['scripts', 'packageManager', 'pnpm'], originalManifest);
+    if (originalManifest.scripts != null) {
+        publishManifest.scripts = omit(PREPUBLISH_SCRIPTS, originalManifest.scripts);
+    }
+    const catalogResolver = resolveFromCatalog.bind(null, opts.catalogs);
+    const replaceCatalogProtocol = resolveCatalogProtocol.bind(null, catalogResolver);
+    const convertDependencyForPublish = combineConverters(replaceWorkspaceProtocol, replaceCatalogProtocol, replaceJsrProtocol);
+    await Promise.all(['dependencies', 'devDependencies', 'optionalDependencies'].map(async (depsField) => {
+        const deps = await makePublishDependencies(dir, originalManifest[depsField], {
+            modulesDir: opts?.modulesDir,
+            convertDependencyForPublish,
+        });
+        if (deps != null) {
+            publishManifest[depsField] = deps;
+        }
+    }));
+    const peerDependencies = originalManifest.peerDependencies;
+    if (peerDependencies) {
+        const convertPeersForPublish = combineConverters(replaceWorkspaceProtocolPeerDependency, replaceCatalogProtocol, replaceJsrProtocol);
+        publishManifest.peerDependencies = await makePublishDependencies(dir, peerDependencies, {
+            modulesDir: opts?.modulesDir,
+            convertDependencyForPublish: convertPeersForPublish,
+        });
+    }
+    overridePublishConfig(publishManifest);
+    if (opts?.readmeFile) {
+        publishManifest.readme ??= opts.readmeFile;
+    }
+    for (const hook of opts?.hooks?.beforePacking ?? []) {
+        // eslint-disable-next-line no-await-in-loop
+        publishManifest = await hook(publishManifest, dir) ?? publishManifest;
+    }
+    return transform(publishManifest);
+}
+function combineConverters(...converters) {
+    return async (depName, depSpec, dir, modulesDir) => {
+        let bareSpecifier = depSpec;
+        for (const converter of converters) {
+            // eslint-disable-next-line no-await-in-loop
+            bareSpecifier = await converter(depName, bareSpecifier, dir, modulesDir);
+        }
+        return bareSpecifier;
+    };
+}
+async function makePublishDependencies(dir, dependencies, { modulesDir, convertDependencyForPublish }) {
+    if (dependencies == null)
+        return dependencies;
+    const publishDependencies = await pMapValues(async (depSpec, depName) => convertDependencyForPublish(depName, depSpec, dir, modulesDir), dependencies);
+    return publishDependencies;
+}
+async function readAndCheckManifest(depName, dependencyDir) {
+    const { manifest } = await tryReadProjectManifest(dependencyDir);
+    if (!manifest?.name || !manifest?.version) {
+        throw new PnpmError('CANNOT_RESOLVE_WORKSPACE_PROTOCOL', `Cannot resolve workspace protocol of dependency "${depName}" ` +
+            'because this dependency is not installed. Try running "pnpm install".');
+    }
+    return manifest;
+}
+function resolveCatalogProtocol(catalogResolver, alias, bareSpecifier) {
+    const result = catalogResolver({ alias, bareSpecifier });
+    switch (result.type) {
+        case 'found': return result.resolution.specifier;
+        case 'unused': return bareSpecifier;
+        case 'misconfiguration': throw result.error;
+    }
+}
+async function replaceWorkspaceProtocol(depName, depSpec, dir, modulesDir) {
+    if (!depSpec.startsWith('workspace:')) {
+        return depSpec;
+    }
+    // Dependencies with bare "*", "^", "~" versions, or no version (workspace:)
+    const versionAliasSpecParts = /^workspace:(?:(.+)@)?([\^~*])?$/.exec(depSpec);
+    if (versionAliasSpecParts != null) {
+        modulesDir = modulesDir ?? path.join(dir, 'node_modules');
+        const manifest = await readAndCheckManifest(depName, path.join(modulesDir, depName));
+        const specifierSuffix = versionAliasSpecParts[2];
+        const semverRangeToken = specifierSuffix === '^' || specifierSuffix === '~' ? specifierSuffix : '';
+        if (depName !== manifest.name) {
+            return `npm:${manifest.name}@${semverRangeToken}${manifest.version}`;
+        }
+        return `${semverRangeToken}${manifest.version}`;
+    }
+    if (depSpec.startsWith('workspace:./') || depSpec.startsWith('workspace:../')) {
+        const manifest = await readAndCheckManifest(depName, path.join(dir, depSpec.slice(10)));
+        if (manifest.name === depName)
+            return `${manifest.version}`;
+        return `npm:${manifest.name}@${manifest.version}`;
+    }
+    depSpec = depSpec.slice(10);
+    if (depSpec.includes('@')) {
+        return `npm:${depSpec}`;
+    }
+    return depSpec;
+}
+async function replaceWorkspaceProtocolPeerDependency(depName, depSpec, dir, modulesDir) {
+    if (!depSpec.includes('workspace:')) {
+        return depSpec;
+    }
+    // Dependencies with bare "*", "^", "~",">=",">","<=", "<", version
+    const workspaceSemverRegex = /workspace:([\^~*]|>=|>|<=|<)?((\d+|[xX*])(\.(\d+|[xX*])){0,2})?/;
+    const versionAliasSpecParts = workspaceSemverRegex.exec(depSpec);
+    if (versionAliasSpecParts != null) {
+        const [, semverRangGroup = '', version] = versionAliasSpecParts;
+        if (version) {
+            return depSpec.replace('workspace:', '');
+        }
+        modulesDir = modulesDir ?? path.join(dir, 'node_modules');
+        const manifest = await readAndCheckManifest(depName, path.join(modulesDir, depName));
+        const semverRangeToken = semverRangGroup !== '*' ? semverRangGroup : '';
+        return depSpec.replace(workspaceSemverRegex, `${semverRangeToken}${manifest.version}`);
+    }
+    return depSpec.replace('workspace:', '');
+}
+async function replaceJsrProtocol(depName, depSpec) {
+    const spec = parseJsrSpecifier(depSpec, depName);
+    if (spec == null) {
+        return depSpec;
+    }
+    return createNpmAliasedSpecifier(spec.npmPkgName, spec.versionSelector);
+}
+function createNpmAliasedSpecifier(npmPkgName, versionSelector) {
+    const npmPkgSpecifier = `npm:${npmPkgName}`;
+    if (!versionSelector) {
+        return npmPkgSpecifier;
+    }
+    return `${npmPkgSpecifier}@${versionSelector}`;
+}
+//# sourceMappingURL=index.js.map

package/lib/overridePublishConfig.d.ts

@@ -0,0 +1,2 @@
+import type { ProjectManifest } from '@pnpm/types';
+export declare function overridePublishConfig(publishManifest: ProjectManifest): void;

package/lib/overridePublishConfig.js

@@ -0,0 +1,42 @@
+import { isEmpty } from 'ramda';
+// property keys that are copied from publishConfig into the manifest
+const PUBLISH_CONFIG_WHITELIST = new Set([
+    // manifest fields that may make sense to overwrite
+    'bin',
+    'engines',
+    'type',
+    'imports',
+    // https://github.com/stereobooster/package.json#package-bundlers
+    'main',
+    'module',
+    'typings',
+    'types',
+    'exports',
+    'browser',
+    'esnext',
+    'es2015',
+    'unpkg',
+    'umd:main',
+    // These are useful to hide in order to avoid warnings during local development
+    'os',
+    'cpu',
+    'libc',
+    // https://www.typescriptlang.org/docs/handbook/declaration-files/publishing.html#version-selection-with-typesversions
+    'typesVersions',
+]);
+export function overridePublishConfig(publishManifest) {
+    const { publishConfig } = publishManifest;
+    if (!publishConfig)
+        return;
+    for (const key in publishConfig) {
+        if (!PUBLISH_CONFIG_WHITELIST.has(key))
+            continue;
+        const value = publishConfig[key];
+        publishManifest[key] = value; // eslint-disable-line @typescript-eslint/no-explicit-any
+        delete publishConfig[key];
+    }
+    if (isEmpty(publishConfig)) {
+        delete publishManifest.publishConfig;
+    }
+}
+//# sourceMappingURL=overridePublishConfig.js.map

package/lib/transform/bin.d.ts

@@ -0,0 +1,16 @@
+import { PnpmError } from '@pnpm/error';
+import type { ProjectManifest } from '@pnpm/types';
+import type { ExportedManifest } from './index.js';
+type Input = Pick<ProjectManifest, 'bin'> & Pick<ExportedManifest, 'name'>;
+type Output<Manifest extends Input> = Omit<Manifest, 'bin'> & Pick<ExportedManifest, 'bin'>;
+export declare function transformBin<Manifest extends Input>(manifest: Manifest): Output<Manifest>;
+/**
+ * The property `"bin"` of a `package.json` could be either an object or a string.
+ * This function normalizes either forms into an object.
+ */
+export declare function normalizeBinObject(pkgName: string, bin: string | Record<string, string>): Record<string, string>;
+export declare class InvalidScopedPackageNameError extends PnpmError {
+    readonly invalidName: string;
+    constructor(invalidName: string);
+}
+export {};

package/lib/transform/bin.js

@@ -0,0 +1,37 @@
+import { PnpmError } from '@pnpm/error';
+export function transformBin(manifest) {
+    if (manifest.bin == null || typeof manifest.bin === 'object')
+        return manifest;
+    const { bin, ...rest } = manifest;
+    return {
+        ...rest,
+        bin: normalizeBinObject(manifest.name, bin),
+    };
+}
+/**
+ * The property `"bin"` of a `package.json` could be either an object or a string.
+ * This function normalizes either forms into an object.
+ */
+export function normalizeBinObject(pkgName, bin) {
+    if (typeof bin === 'object')
+        return bin;
+    const binName = normalizeBinName(pkgName);
+    return { [binName]: bin };
+}
+function normalizeBinName(name) {
+    if (name[0] !== '@')
+        return name;
+    const slashIndex = name.indexOf('/');
+    if (slashIndex < 0) {
+        throw new InvalidScopedPackageNameError(name);
+    }
+    return name.slice(slashIndex + 1);
+}
+export class InvalidScopedPackageNameError extends PnpmError {
+    invalidName;
+    constructor(invalidName) {
+        super('INVALID_SCOPED_PACKAGE_NAME', `The name ${JSON.stringify(invalidName)} is not a valid scoped package name`);
+        this.invalidName = invalidName;
+    }
+}
+//# sourceMappingURL=bin.js.map

package/lib/transform/engines.d.ts

@@ -0,0 +1,12 @@
+import { PnpmError } from '@pnpm/error';
+import type { ProjectManifest } from '@pnpm/types';
+import type { ExportedManifest } from './index.js';
+type EnginesField = 'engines' | 'devEngines';
+type Input = Pick<ProjectManifest, EnginesField>;
+type Omitted<Manifest extends Input> = Omit<Manifest, EnginesField>;
+type Output<Manifest extends Input> = Omitted<Manifest> & Pick<ExportedManifest, EnginesField>;
+export declare function transformEngines<Manifest extends Input>(manifest: Manifest): Output<Manifest>;
+export declare class DevEnginesRuntimeConflictError extends PnpmError {
+    constructor();
+}
+export {};

package/lib/transform/engines.js

@@ -0,0 +1,23 @@
+import { PnpmError } from '@pnpm/error';
+export function transformEngines(manifest) {
+    if (!manifest.engines?.runtime)
+        return manifest;
+    if (manifest.engines.runtime && manifest.devEngines?.runtime) {
+        throw new DevEnginesRuntimeConflictError();
+    }
+    const { engines: { runtime, ...engines }, ...rest } = manifest;
+    return {
+        ...rest,
+        engines,
+        devEngines: {
+            ...rest.devEngines,
+            runtime,
+        },
+    };
+}
+export class DevEnginesRuntimeConflictError extends PnpmError {
+    constructor() {
+        super('DEV_ENGINES_RUNTIME_CONFLICT', '.devEngines.runtime and .engines.runtime were both defined');
+    }
+}
+//# sourceMappingURL=engines.js.map

package/lib/transform/index.d.ts

@@ -0,0 +1,5 @@
+import type { PackageJSON as ExportedManifest } from '@npm/types';
+import type { ProjectManifest } from '@pnpm/types';
+export { type ExportedManifest };
+export type Transform = (manifest: ProjectManifest) => ExportedManifest;
+export declare const transform: Transform;

package/lib/transform/index.js

@@ -0,0 +1,8 @@
+import { pipe } from 'ramda';
+import { transformBin } from './bin.js';
+import { transformEngines } from './engines.js';
+import { transformPeerDependenciesMeta } from './peerDependenciesMeta.js';
+import { transformRequiredFields } from './requiredFields.js';
+export {};
+export const transform = pipe(transformRequiredFields, transformBin, transformEngines, transformPeerDependenciesMeta);
+//# sourceMappingURL=index.js.map

package/lib/transform/peerDependenciesMeta.d.ts

@@ -0,0 +1,7 @@
+import type { ProjectManifest } from '@pnpm/types';
+import type { ExportedManifest } from './index.js';
+type Input = Pick<ProjectManifest, 'peerDependenciesMeta'>;
+type Omitted<Manifest extends Input> = Omit<Manifest, 'peerDependenciesMeta'>;
+type Output<Manifest extends Input> = Omitted<Manifest> & Pick<ExportedManifest, 'peerDependenciesMeta'>;
+export declare function transformPeerDependenciesMeta<Manifest extends Input>(manifest: Manifest): Output<Manifest>;
+export {};

package/lib/transform/peerDependenciesMeta.js

@@ -0,0 +1,18 @@
+export function transformPeerDependenciesMeta(manifest) {
+    if (!manifest.peerDependenciesMeta)
+        return manifest;
+    const inputPeerDepsMeta = manifest.peerDependenciesMeta;
+    const outputPeerDepsMeta = {};
+    for (const key in inputPeerDepsMeta) {
+        const { optional, ...rest } = inputPeerDepsMeta[key];
+        outputPeerDepsMeta[key] = {
+            ...rest,
+            optional: optional ?? false,
+        };
+    }
+    return {
+        ...manifest,
+        peerDependenciesMeta: outputPeerDepsMeta,
+    };
+}
+//# sourceMappingURL=peerDependenciesMeta.js.map

package/lib/transform/requiredFields.d.ts

@@ -0,0 +1,12 @@
+import { PnpmError } from '@pnpm/error';
+import type { ProjectManifest } from '@pnpm/types';
+import type { ExportedManifest } from './index.js';
+type RequiredField = 'name' | 'version';
+type Input = Pick<ProjectManifest, RequiredField>;
+type Output<Manifest extends Input> = Omit<Manifest, RequiredField> & Pick<ExportedManifest, RequiredField>;
+export declare function transformRequiredFields<Manifest extends Input>(manifest: Manifest): Output<Manifest>;
+export declare class MissingRequiredFieldError<Field extends RequiredField> extends PnpmError {
+    readonly field: Field;
+    constructor(field: Field);
+}
+export {};

package/lib/transform/requiredFields.js

@@ -0,0 +1,16 @@
+import { PnpmError } from '@pnpm/error';
+export function transformRequiredFields(manifest) {
+    if (!manifest.name)
+        throw new MissingRequiredFieldError('name');
+    if (!manifest.version)
+        throw new MissingRequiredFieldError('version');
+    return manifest;
+}
+export class MissingRequiredFieldError extends PnpmError {
+    field;
+    constructor(field) {
+        super('MISSING_REQUIRED_FIELD', `Missing required field ${JSON.stringify(field)}`);
+        this.field = field;
+    }
+}
+//# sourceMappingURL=requiredFields.js.map

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@pnpm/releasing.exportable-manifest",
+  "version": "1000.1.7",
+  "description": "Creates an exportable manifest",
+  "keywords": [
+    "pnpm",
+    "pnpm11"
+  ],
+  "license": "MIT",
+  "funding": "https://opencollective.com/pnpm",
+  "repository": "https://github.com/pnpm/pnpm/tree/main/releasing/exportable-manifest",
+  "homepage": "https://github.com/pnpm/pnpm/tree/main/releasing/exportable-manifest#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": {
+    "@npm/types": "^2.1.0",
+    "p-map-values": "^0.1.0",
+    "ramda": "npm:@pnpm/ramda@0.28.1",
+    "@pnpm/bins.resolver": "1000.0.11",
+    "@pnpm/catalogs.resolver": "1000.0.5",
+    "@pnpm/workspace.project-manifest-reader": "1001.1.4",
+    "@pnpm/error": "1000.0.5",
+    "@pnpm/resolving.jsr-specifier-parser": "1000.0.3",
+    "@pnpm/types": "1000.9.0"
+  },
+  "devDependencies": {
+    "@types/cross-spawn": "^6.0.6",
+    "@types/ramda": "0.29.12",
+    "cross-spawn": "^7.0.6",
+    "write-yaml-file": "^6.0.0",
+    "@pnpm/catalogs.config": "1000.0.5",
+    "@pnpm/hooks.pnpmfile": "1002.1.3",
+    "@pnpm/catalogs.types": "1000.0.0",
+    "@pnpm/releasing.exportable-manifest": "1000.1.7",
+    "@pnpm/prepare": "1000.0.4"
+  },
+  "engines": {
+    "node": ">=22.13"
+  },
+  "jest": {
+    "preset": "@pnpm/jest-config"
+  },
+  "scripts": {
+    "lint": "eslint \"src/**/*.ts\" \"test/**/*.ts\"",
+    "test": "pnpm run compile && pnpm run _test",
+    "compile": "tsgo --build && pnpm run lint --fix",
+    "_test": "cross-env NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules --disable-warning=ExperimentalWarning --disable-warning=DEP0169\" jest"
+  }
+}