@pnpm/workspace.injected-deps-syncer 1100.0.26 → 1100.0.28

package/CHANGELOG.md

@@ -1,5 +1,32 @@
 # @pnpm/workspace.injected-deps-syncer
 
+## 1100.0.28
+
+### 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/bins.linker@1100.0.22
+  - @pnpm/error@1100.1.0
+  - @pnpm/fetching.directory-fetcher@1100.0.25
+  - @pnpm/installing.modules-yaml@1100.0.12
+  - @pnpm/pkg-manifest.reader@1100.0.12
+  - @pnpm/types@1101.6.0
+  - @pnpm/workspace.projects-reader@1101.0.19
+
+## 1100.0.27
+
+### Patch Changes
+
+- Updated dependencies:
+  - @pnpm/bins.linker@1100.0.21
+  - @pnpm/fetching.directory-fetcher@1100.0.24
+  - @pnpm/installing.modules-yaml@1100.0.11
+  - @pnpm/pkg-manifest.reader@1100.0.11
+  - @pnpm/types@1101.5.0
+  - @pnpm/workspace.projects-reader@1101.0.18
+
 ## 1100.0.26
 
 ### Patch Changes

package/lib/DirPatcher.d.ts

@@ -0,0 +1,66 @@
+import fs from 'node:fs';
+export declare const DIR: unique symbol;
+export type File = number;
+export type Dir = typeof DIR;
+export type Value = File | Dir;
+export type InodeMap = Record<string, Value>;
+export interface DiffItemBase {
+    path: string;
+    oldValue?: Value;
+    newValue?: Value;
+}
+export interface AddedItem extends DiffItemBase {
+    path: string;
+    oldValue?: undefined;
+    newValue: Value;
+}
+export interface RemovedItem extends DiffItemBase {
+    path: string;
+    oldValue: Value;
+    newValue?: undefined;
+}
+export interface ModifiedItem extends DiffItemBase {
+    path: string;
+    oldValue: Value;
+    newValue: Value;
+}
+export interface DirDiff {
+    added: AddedItem[];
+    removed: RemovedItem[];
+    modified: ModifiedItem[];
+}
+/**
+ * Get the difference between 2 files tree.
+ *
+ * The arrays in the resulting object are sorted in such a way that every directory paths are placed before
+ * the files it contains. This way, it would allow optimization for operations upon this diff.
+ * Note that when performing removal of removed files according to this diff, the `removed` array should be reversed first.
+ */
+export declare function diffDir(oldIndex: InodeMap, newIndex: InodeMap): DirDiff;
+/**
+ * Apply a patch on a directory.
+ *
+ * The {@link optimizedDirPatch} is assumed to be already optimized (i.e. `removed` is already reversed).
+ */
+export declare function applyPatch(optimizedDirPatch: DirDiff, sourceDir: string, targetDir: string): Promise<void>;
+export type ExtendFilesMapStats = Pick<fs.Stats, 'ino' | 'isFile' | 'isDirectory'>;
+export interface ExtendFilesMapOptions {
+    /** Map relative path of each file to their real path */
+    filesMap: Map<string, string>;
+    /** Map relative path of each file to their stats */
+    filesStats?: Record<string, ExtendFilesMapStats | null>;
+}
+/**
+ * Convert a pair of a files index map, which is a map from relative path of each file to their real paths,
+ * and an optional file stats map, which is a map from relative path of each file to their stats,
+ * into an inodes map, which is a map from relative path of every file and directory to their inode type.
+ */
+export declare function extendFilesMap({ filesMap, filesStats }: ExtendFilesMapOptions): Promise<InodeMap>;
+export declare class DirPatcher {
+    private readonly sourceDir;
+    private readonly targetDir;
+    private readonly patch;
+    private constructor();
+    static fromMultipleTargets(sourceDir: string, targetDirs: string[]): Promise<DirPatcher[]>;
+    apply(): Promise<void>;
+}

package/lib/DirPatcher.js

@@ -0,0 +1,141 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import util from 'node:util';
+import { PnpmError } from '@pnpm/error';
+import { fetchFromDir } from '@pnpm/fetching.directory-fetcher';
+export const DIR = Symbol('Path is a directory');
+// length comparison should place every directory before the files it contains because
+// a directory path is always shorter than any file path it contains
+const comparePaths = (a, b) => (a.split(/\\|\//).length - b.split(/\\|\//).length) || a.localeCompare(b);
+/**
+ * Get the difference between 2 files tree.
+ *
+ * The arrays in the resulting object are sorted in such a way that every directory paths are placed before
+ * the files it contains. This way, it would allow optimization for operations upon this diff.
+ * Note that when performing removal of removed files according to this diff, the `removed` array should be reversed first.
+ */
+export function diffDir(oldIndex, newIndex) {
+    const oldPaths = Object.keys(oldIndex).sort(comparePaths);
+    const newPaths = Object.keys(newIndex).sort(comparePaths);
+    const removed = oldPaths
+        .filter(path => !(path in newIndex))
+        .map(path => ({ path, oldValue: oldIndex[path] }));
+    const added = newPaths
+        .filter(path => !(path in oldIndex))
+        .map(path => ({ path, newValue: newIndex[path] }));
+    const modified = oldPaths
+        .filter(path => path in newIndex && oldIndex[path] !== newIndex[path])
+        .map(path => ({ path, oldValue: oldIndex[path], newValue: newIndex[path] }));
+    return { added, removed, modified };
+}
+/**
+ * Apply a patch on a directory.
+ *
+ * The {@link optimizedDirPatch} is assumed to be already optimized (i.e. `removed` is already reversed).
+ */
+export async function applyPatch(optimizedDirPatch, sourceDir, targetDir) {
+    async function addRecursive(sourcePath, targetPath, value) {
+        if (value === DIR) {
+            await fs.promises.mkdir(targetPath, { recursive: true });
+        }
+        else if (typeof value === 'number') {
+            fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+            await fs.promises.link(sourcePath, targetPath);
+        }
+        else {
+            const _ = value; // static type guard
+        }
+    }
+    async function removeRecursive(targetPath) {
+        try {
+            await fs.promises.rm(targetPath, { recursive: true, force: true });
+        }
+        catch (error) {
+            if (!util.types.isNativeError(error) || !('code' in error) || (error.code !== 'ENOENT')) {
+                throw error;
+            }
+        }
+    }
+    const adding = Promise.all(optimizedDirPatch.added.map(async (item) => {
+        const sourcePath = path.join(sourceDir, item.path);
+        const targetPath = path.join(targetDir, item.path);
+        await addRecursive(sourcePath, targetPath, item.newValue);
+    }));
+    const removing = Promise.all(optimizedDirPatch.removed.map(async (item) => {
+        const targetPath = path.join(targetDir, item.path);
+        await removeRecursive(targetPath);
+    }));
+    const modifying = Promise.all(optimizedDirPatch.modified.map(async (item) => {
+        const sourcePath = path.join(sourceDir, item.path);
+        const targetPath = path.join(targetDir, item.path);
+        if (item.oldValue === item.newValue)
+            return;
+        await removeRecursive(targetPath);
+        await addRecursive(sourcePath, targetPath, item.newValue);
+    }));
+    await Promise.all([adding, removing, modifying]);
+}
+/**
+ * Convert a pair of a files index map, which is a map from relative path of each file to their real paths,
+ * and an optional file stats map, which is a map from relative path of each file to their stats,
+ * into an inodes map, which is a map from relative path of every file and directory to their inode type.
+ */
+export async function extendFilesMap({ filesMap, filesStats }) {
+    const result = {
+        '.': DIR,
+    };
+    function addInodeAndAncestors(relativePath, value) {
+        if (relativePath && relativePath !== '.' && !result[relativePath]) {
+            result[relativePath] = value;
+            addInodeAndAncestors(path.dirname(relativePath), DIR);
+        }
+    }
+    await Promise.all(Array.from(filesMap.entries()).map(async ([relativePath, realPath]) => {
+        const stats = filesStats?.[relativePath] ?? await fs.promises.stat(realPath);
+        if (stats.isFile()) {
+            addInodeAndAncestors(relativePath, stats.ino);
+        }
+        else if (stats.isDirectory()) {
+            addInodeAndAncestors(relativePath, DIR);
+        }
+        else {
+            throw new PnpmError('UNSUPPORTED_INODE_TYPE', `Filesystem inode at ${realPath} is neither a file, a directory, or a symbolic link`);
+        }
+    }));
+    return result;
+}
+export class DirPatcher {
+    sourceDir;
+    targetDir;
+    patch;
+    constructor(patch, sourceDir, targetDir) {
+        this.patch = patch;
+        this.sourceDir = sourceDir;
+        this.targetDir = targetDir;
+    }
+    static async fromMultipleTargets(sourceDir, targetDirs) {
+        const fetchOptions = {
+            resolveSymlinks: false,
+        };
+        async function loadMap(dir) {
+            const fetchResult = await fetchFromDir(dir, fetchOptions);
+            return [await extendFilesMap(fetchResult), dir];
+        }
+        const [[sourceMap], targetPairs] = await Promise.all([
+            loadMap(sourceDir),
+            Promise.all(targetDirs.map(loadMap)),
+        ]);
+        return targetPairs.map(([targetMap, targetDir]) => {
+            const diff = diffDir(targetMap, sourceMap);
+            // Before reversal, every directory in `diff.removed` are placed before its files.
+            // After reversal, every file is place before its ancestors,
+            // leading to children being deleted before parents, optimizing performance.
+            diff.removed.reverse();
+            return new this(diff, sourceDir, targetDir);
+        });
+    }
+    async apply() {
+        await applyPatch(this.patch, this.sourceDir, this.targetDir);
+    }
+}
+//# sourceMappingURL=DirPatcher.js.map

package/lib/index.d.ts

@@ -0,0 +1,6 @@
+export interface SyncInjectedDepsOptions {
+    pkgName: string | undefined;
+    pkgRootDir: string;
+    workspaceDir: string | undefined;
+}
+export declare function syncInjectedDeps(opts: SyncInjectedDepsOptions): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pnpm/workspace.injected-deps-syncer",
-  "version": "1100.0.26",
+  "version": "1100.0.28",
   "description": "Update all injected replica of a workspace package",
   "keywords": [
     "pnpm",
@@ -27,14 +27,14 @@
     "!*.map"
   ],
   "dependencies": {
-    "@pnpm/bins.linker": "1100.0.20",
-    "@pnpm/error": "1100.0.1",
-    "@pnpm/fetching.directory-fetcher": "1100.0.23",
-    "@pnpm/installing.modules-yaml": "1100.0.10",
-    "@pnpm/pkg-manifest.reader": "1100.0.10",
-    "@pnpm/types": "1101.4.0",
+    "@pnpm/bins.linker": "1100.0.22",
+    "@pnpm/error": "1100.1.0",
+    "@pnpm/fetching.directory-fetcher": "1100.0.25",
+    "@pnpm/installing.modules-yaml": "1100.0.12",
+    "@pnpm/pkg-manifest.reader": "1100.0.12",
+    "@pnpm/types": "1101.6.0",
     "@pnpm/util.lex-comparator": "^4.0.1",
-    "@pnpm/workspace.projects-reader": "1101.0.17",
+    "@pnpm/workspace.projects-reader": "1101.0.19",
     "@types/normalize-path": "^3.0.2",
     "normalize-path": "^3.0.0"
   },
@@ -44,8 +44,8 @@
   "devDependencies": {
     "@jest/globals": "30.4.1",
     "@pnpm/logger": "1100.0.0",
-    "@pnpm/prepare": "1100.0.20",
-    "@pnpm/workspace.injected-deps-syncer": "1100.0.26"
+    "@pnpm/prepare": "1100.0.22",
+    "@pnpm/workspace.injected-deps-syncer": "1100.0.28"
   },
   "engines": {
     "node": ">=22.13"