@pnpm/workspace.workspace-manifest-reader 1100.1.1 → 1100.1.2

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @pnpm/workspace.read-manifest
 
+## 1100.1.2
+
+### Patch Changes
+
+- Republished every package: the tarballs published by the v11.13.1 through v11.16.0 releases were missing most of their compiled files due to a packing bug [#13164](https://github.com/pnpm/pnpm/issues/13164).
+
+- Updated dependencies:
+  - @pnpm/constants@1100.0.1
+  - @pnpm/error@1100.1.0
+  - @pnpm/types@1101.6.0
+
 ## 1100.1.1
 
 ### Patch Changes

package/lib/catalogs.d.ts

@@ -0,0 +1,18 @@
+export interface WorkspaceNamedCatalogs {
+    [catalogName: string]: WorkspaceCatalog;
+}
+export interface WorkspaceCatalog {
+    [dependencyName: string]: string;
+}
+export declare function assertValidWorkspaceManifestCatalog(manifest: {
+    packages?: readonly string[];
+    catalog?: unknown;
+}): asserts manifest is {
+    catalog?: WorkspaceCatalog;
+};
+export declare function assertValidWorkspaceManifestCatalogs(manifest: {
+    packages?: readonly string[];
+    catalogs?: unknown;
+}): asserts manifest is {
+    catalogs?: WorkspaceNamedCatalogs;
+};

package/lib/catalogs.js

@@ -0,0 +1,45 @@
+import { InvalidWorkspaceManifestError } from './errors/InvalidWorkspaceManifestError.js';
+export function assertValidWorkspaceManifestCatalog(manifest) {
+    if (manifest.catalog == null) {
+        return;
+    }
+    if (Array.isArray(manifest.catalog)) {
+        throw new InvalidWorkspaceManifestError('Expected catalog field to be an object, but found - array');
+    }
+    if (typeof manifest.catalog !== 'object') {
+        throw new InvalidWorkspaceManifestError(`Expected catalog field to be an object, but found - ${typeof manifest.catalog}`);
+    }
+    for (const [alias, specifier] of Object.entries(manifest.catalog)) {
+        if (typeof specifier !== 'string') {
+            throw new InvalidWorkspaceManifestError(`Invalid catalog entry for ${alias}. Expected string, but found: ${typeof specifier}`);
+        }
+    }
+}
+export function assertValidWorkspaceManifestCatalogs(manifest) {
+    if (manifest.catalogs == null) {
+        return;
+    }
+    if (Array.isArray(manifest.catalogs)) {
+        throw new InvalidWorkspaceManifestError('Expected catalogs field to be an object, but found - array');
+    }
+    if (typeof manifest.catalogs !== 'object') {
+        throw new InvalidWorkspaceManifestError(`Expected catalogs field to be an object, but found - ${typeof manifest.catalogs}`);
+    }
+    for (const [catalogName, catalog] of Object.entries(manifest.catalogs)) {
+        if (Array.isArray(catalog)) {
+            throw new InvalidWorkspaceManifestError(`Expected named catalog ${catalogName} to be an object, but found - array`);
+        }
+        if (catalog === null) {
+            throw new InvalidWorkspaceManifestError(`Expected named catalog ${catalogName} to be an object, but found - null`);
+        }
+        if (typeof catalog !== 'object') {
+            throw new InvalidWorkspaceManifestError(`Expected named catalog ${catalogName} to be an object, but found - ${typeof catalog}`);
+        }
+        for (const [alias, specifier] of Object.entries(catalog)) {
+            if (typeof specifier !== 'string') {
+                throw new InvalidWorkspaceManifestError(`Catalog '${catalogName}' has invalid entry '${alias}'. Expected string specifier, but found: ${typeof specifier}`);
+            }
+        }
+    }
+}
+//# sourceMappingURL=catalogs.js.map

package/lib/errors/InvalidWorkspaceManifestError.d.ts

@@ -0,0 +1,4 @@
+import { PnpmError } from '@pnpm/error';
+export declare class InvalidWorkspaceManifestError extends PnpmError {
+    constructor(message: string);
+}

package/lib/errors/InvalidWorkspaceManifestError.js

@@ -0,0 +1,7 @@
+import { PnpmError } from '@pnpm/error';
+export class InvalidWorkspaceManifestError extends PnpmError {
+    constructor(message) {
+        super('INVALID_WORKSPACE_CONFIGURATION', message);
+    }
+}
+//# sourceMappingURL=InvalidWorkspaceManifestError.js.map

package/lib/index.d.ts

@@ -0,0 +1,20 @@
+import { type GLOBAL_CONFIG_YAML_FILENAME, WORKSPACE_MANIFEST_FILENAME } from '@pnpm/constants';
+import type { PnpmSettings } from '@pnpm/types';
+import { type WorkspaceCatalog, type WorkspaceNamedCatalogs } from './catalogs.js';
+export type ConfigFileName = typeof GLOBAL_CONFIG_YAML_FILENAME | typeof WORKSPACE_MANIFEST_FILENAME;
+export interface WorkspaceManifest extends PnpmSettings {
+    packages: string[];
+    /**
+     * The default catalog. Package manifests may refer to dependencies in this
+     * definition through the `catalog:default` specifier or the `catalog:`
+     * shorthand.
+     */
+    catalog?: WorkspaceCatalog;
+    /**
+     * A dictionary of named catalogs. Package manifests may refer to dependencies
+     * in this definition through the `catalog:<name>` specifier.
+     */
+    catalogs?: WorkspaceNamedCatalogs;
+}
+export declare function readWorkspaceManifest(dir: string, cfgFileName?: ConfigFileName): Promise<WorkspaceManifest | undefined>;
+export declare function validateWorkspaceManifest(manifest: unknown): asserts manifest is WorkspaceManifest | undefined;

package/lib/versioning.d.ts

@@ -0,0 +1,7 @@
+import type { VersioningSettings } from '@pnpm/types';
+export declare function assertValidWorkspaceManifestVersioning(manifest: {
+    packages?: readonly string[];
+    versioning?: unknown;
+}): asserts manifest is {
+    versioning?: VersioningSettings;
+};

package/lib/versioning.js

@@ -0,0 +1,73 @@
+import { InvalidWorkspaceManifestError } from './errors/InvalidWorkspaceManifestError.js';
+const BUMP_TYPES = ['patch', 'minor', 'major'];
+const CHANGELOG_STORAGE_MODES = ['registry', 'repository'];
+export function assertValidWorkspaceManifestVersioning(manifest) {
+    if (manifest.versioning == null) {
+        return;
+    }
+    const versioning = assertPlainObject(manifest.versioning, 'versioning');
+    if (versioning.fixed != null) {
+        if (!Array.isArray(versioning.fixed)) {
+            throw new InvalidWorkspaceManifestError(`Expected versioning.fixed to be an array of arrays, but found - ${typeof versioning.fixed}`);
+        }
+        for (const group of versioning.fixed) {
+            if (!Array.isArray(group) || group.some((name) => typeof name !== 'string' || name === '')) {
+                throw new InvalidWorkspaceManifestError('Expected every versioning.fixed group to be an array of package names');
+            }
+        }
+    }
+    if (versioning.epics != null) {
+        if (!Array.isArray(versioning.epics)) {
+            throw new InvalidWorkspaceManifestError(`Expected versioning.epics to be an array, but found - ${typeof versioning.epics}`);
+        }
+        for (const epic of versioning.epics) {
+            const entry = assertPlainObject(epic, 'versioning.epics entry');
+            if (typeof entry.lead !== 'string' || entry.lead === '') {
+                throw new InvalidWorkspaceManifestError('Expected every versioning.epics entry to have a non-empty "lead" package reference');
+            }
+            if (!Array.isArray(entry.packages) || entry.packages.length === 0 || entry.packages.some((selector) => typeof selector !== 'string' || selector === '')) {
+                throw new InvalidWorkspaceManifestError(`Expected versioning.epics entry for "${entry.lead}" to have a non-empty "packages" array of selector strings`);
+            }
+        }
+    }
+    if (versioning.ignore != null) {
+        if (!Array.isArray(versioning.ignore) || versioning.ignore.some((name) => typeof name !== 'string' || name === '')) {
+            throw new InvalidWorkspaceManifestError('Expected versioning.ignore to be an array of package names');
+        }
+    }
+    if (versioning.maxBump != null) {
+        if (!BUMP_TYPES.includes(versioning.maxBump)) {
+            throw new InvalidWorkspaceManifestError(`Expected versioning.maxBump to be one of ${BUMP_TYPES.join(', ')}, but found - ${String(versioning.maxBump)}`);
+        }
+    }
+    if (versioning.lanes != null) {
+        const lanes = assertPlainObject(versioning.lanes, 'versioning.lanes');
+        for (const [pkgName, lane] of Object.entries(lanes)) {
+            if (typeof lane !== 'string' || lane === '') {
+                throw new InvalidWorkspaceManifestError(`Expected versioning.lanes entry for ${pkgName} to be a non-empty lane name`);
+            }
+            if (lane.toLowerCase() === 'main') {
+                throw new InvalidWorkspaceManifestError(`Invalid versioning.lanes entry for ${pkgName}: "main" is the reserved default lane. Remove the entry instead.`);
+            }
+        }
+    }
+    if (versioning.changelog != null) {
+        const changelog = assertPlainObject(versioning.changelog, 'versioning.changelog');
+        if (changelog.format != null && typeof changelog.format !== 'string') {
+            throw new InvalidWorkspaceManifestError(`Expected versioning.changelog.format to be a string, but found - ${typeof changelog.format}`);
+        }
+        if (changelog.storage != null && !CHANGELOG_STORAGE_MODES.includes(changelog.storage)) {
+            throw new InvalidWorkspaceManifestError(`Expected versioning.changelog.storage to be one of ${CHANGELOG_STORAGE_MODES.join(', ')}, but found - ${String(changelog.storage)}`);
+        }
+    }
+}
+function assertPlainObject(value, fieldName) {
+    if (Array.isArray(value)) {
+        throw new InvalidWorkspaceManifestError(`Expected ${fieldName} field to be an object, but found - array`);
+    }
+    if (typeof value !== 'object' || value === null) {
+        throw new InvalidWorkspaceManifestError(`Expected ${fieldName} field to be an object, but found - ${value === null ? 'null' : typeof value}`);
+    }
+    return value;
+}
+//# sourceMappingURL=versioning.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pnpm/workspace.workspace-manifest-reader",
-  "version": "1100.1.1",
+  "version": "1100.1.2",
   "description": "Reads a workspace manifest file",
   "keywords": [
     "pnpm",
@@ -27,14 +27,14 @@
     "!*.map"
   ],
   "dependencies": {
-    "@pnpm/constants": "1100.0.0",
-    "@pnpm/error": "1100.0.1",
-    "@pnpm/types": "1101.5.0",
+    "@pnpm/constants": "1100.0.1",
+    "@pnpm/error": "1100.1.0",
+    "@pnpm/types": "1101.6.0",
     "read-yaml-file": "^3.0.0"
   },
   "devDependencies": {
     "@jest/globals": "30.4.1",
-    "@pnpm/workspace.workspace-manifest-reader": "1100.1.1"
+    "@pnpm/workspace.workspace-manifest-reader": "1100.1.2"
   },
   "engines": {
     "node": ">=22.13"