@inlang/paraglide-js 2.0.0-beta.15 → 2.0.0-beta.17

package/dist/services/file-handling/write-output.js

@@ -1,31 +1,45 @@
 import path from "node:path";
 import crypto from "node:crypto";
-let previousOutputHash;
-export async function writeOutput(outputDirectory, output, fs) {
+export async function writeOutput(args) {
+    const currentOutputHashes = hashOutput(args.output, args.directory);
     // if the output hasn't changed, don't write it
-    const currentOutputHash = hashOutput(output, outputDirectory);
-    if (currentOutputHash === previousOutputHash)
+    const changedFiles = new Set();
+    for (const [filePath, hash] of Object.entries(currentOutputHashes)) {
+        if (args.previousOutputHashes?.[filePath] !== hash) {
+            changedFiles.add(filePath);
+        }
+    }
+    if (changedFiles.size === 0) {
         return;
-    // clear the output directory
-    await fs.rm(outputDirectory, { recursive: true, force: true });
-    await fs.mkdir(outputDirectory, { recursive: true });
+    }
+    // disabled because of https://github.com/opral/inlang-paraglide-js/issues/350
+    // // clear the output directory
+    // await args.fs.rm(args.outputDirectory, { recursive: true, force: true });
+    await args.fs.mkdir(args.directory, { recursive: true });
     //Create missing directories inside the output directory
-    await Promise.allSettled(Object.keys(output).map(async (filePath) => {
-        const fullPath = path.resolve(outputDirectory, filePath);
+    await Promise.allSettled(Object.keys(args.output).map(async (filePath) => {
+        const fullPath = path.resolve(args.directory, filePath);
         const directory = path.dirname(fullPath);
-        await fs.mkdir(directory, { recursive: true });
+        await args.fs.mkdir(directory, { recursive: true });
     }));
     //Write files
-    await Promise.allSettled(Object.entries(output).map(async ([filePath, fileContent]) => {
-        const fullPath = path.resolve(outputDirectory, filePath);
-        await fs.writeFile(fullPath, fileContent);
+    await Promise.allSettled(Object.entries(args.output).map(async ([filePath, fileContent]) => {
+        if (!changedFiles.has(filePath)) {
+            return;
+        }
+        const fullPath = path.resolve(args.directory, filePath);
+        await args.fs.writeFile(fullPath, fileContent);
     }));
-    //Only update the previousOutputHash if the write was successful
-    previousOutputHash = currentOutputHash;
+    //Only update the previousOutputHashes if the write was successful
+    return currentOutputHashes;
 }
 function hashOutput(output, outputDirectory) {
-    const hash = crypto.createHash("sha256");
-    hash.update(JSON.stringify(output));
-    hash.update(outputDirectory);
-    return hash.digest("hex");
+    const hashes = {};
+    for (const [filePath, fileContent] of Object.entries(output)) {
+        const hash = crypto.createHash("sha256");
+        hash.update(fileContent);
+        hash.update(path.resolve(outputDirectory, filePath));
+        hashes[filePath] = hash.digest("hex");
+    }
+    return hashes;
 }

package/dist/services/file-handling/write-output.test.js

@@ -6,26 +6,38 @@ beforeEach(() => {
 it("should write the output to a non-existing directory", async () => {
     const { writeOutput } = await import("./write-output.js");
     const fs = mockFs({});
-    await writeOutput("/output", { "test.txt": "test" }, fs);
+    await writeOutput({
+        directory: "/output",
+        output: { "test.txt": "test" },
+        fs,
+    });
     expect(await fs.readFile("/output/test.txt", { encoding: "utf-8" })).toBe("test");
 });
-it("should clear & overwrite output that's already there", async () => {
+it.skip("should clear & overwrite output that's already there", async () => {
     const { writeOutput } = await import("./write-output.js");
     const fs = mockFs({
         "/output/test.txt": "old",
         "/output/other.txt": "other",
     });
-    await writeOutput("/output", { "test.txt": "new" }, fs);
+    await writeOutput({
+        directory: "/output",
+        output: { "test.txt": "new" },
+        fs,
+    });
     expect(await fs.readFile("/output/test.txt", { encoding: "utf-8" })).toBe("new");
     await expect(async () => await fs.readFile("/output/other.txt", { encoding: "utf-8" })).rejects.toBeDefined();
 });
 it("should create any missing directories", async () => {
     const { writeOutput } = await import("./write-output.js");
     const fs = mockFs({});
-    await writeOutput("/output/messages", {
-        "de/test.txt": "de",
-        "en/test.txt": "en",
-    }, fs);
+    await writeOutput({
+        directory: "/output/messages",
+        output: {
+            "de/test.txt": "de",
+            "en/test.txt": "en",
+        },
+        fs,
+    });
     expect(await fs.readFile("/output/messages/de/test.txt", { encoding: "utf-8" })).toBe("de");
     expect(await fs.readFile("/output/messages/en/test.txt", { encoding: "utf-8" })).toBe("en");
 });
@@ -34,8 +46,17 @@ it("should only write once if the output hasn't changed", async () => {
     const fs = mockFs({});
     // @ts-expect-error - spy
     fs.writeFile = vi.spyOn(fs, "writeFile");
-    await writeOutput("/output", { "test.txt": "test" }, fs);
-    await writeOutput("/output", { "test.txt": "test" }, fs);
+    const hashes = await writeOutput({
+        directory: "/output",
+        output: { "test.txt": "test" },
+        fs,
+    });
+    await writeOutput({
+        directory: "/output",
+        output: { "test.txt": "test" },
+        fs,
+        previousOutputHashes: hashes,
+    });
     expect(await fs.readFile("/output/test.txt", { encoding: "utf-8" })).toBe("test");
     expect(fs.writeFile).toHaveBeenCalledTimes(1);
 });
@@ -44,11 +65,39 @@ it("should write again if the output has changed", async () => {
     const fs = mockFs({});
     // @ts-expect-error - spy
     fs.writeFile = vi.spyOn(fs, "writeFile");
-    await writeOutput("/output", { "test.txt": "test" }, fs);
-    await writeOutput("/output", { "test.txt": "test2" }, fs);
+    const hashes = await writeOutput({
+        directory: "/output",
+        output: { "test.txt": "test" },
+        fs,
+    });
+    await writeOutput({
+        directory: "/output",
+        output: { "test.txt": "test2" },
+        fs,
+        previousOutputHashes: hashes,
+    });
     expect(await fs.readFile("/output/test.txt", { encoding: "utf-8" })).toBe("test2");
     expect(fs.writeFile).toHaveBeenCalledTimes(2);
 });
+it("should write files if output has partially changed", async () => {
+    const { writeOutput } = await import("./write-output.js");
+    const fs = mockFs({});
+    // @ts-expect-error - spy
+    fs.writeFile = vi.spyOn(fs, "writeFile");
+    const hashes = await writeOutput({
+        directory: "/output",
+        output: { "file1.txt": "test", "file2.txt": "test" },
+        fs,
+    });
+    await writeOutput({
+        directory: "/output",
+        output: { "file1.txt": "test", "file2.txt": "test2" },
+        fs,
+        previousOutputHashes: hashes,
+    });
+    expect(fs.writeFile).toHaveBeenCalledWith("/output/file2.txt", "test2");
+    expect(fs.writeFile).toHaveBeenCalledTimes(3);
+});
 const mockFs = (files) => {
     const _memfs = memfs.createFsFromVolume(memfs.Volume.fromJSON(files));
     return _memfs.promises;

package/dist/urlpattern-polyfill/index.d.ts

@@ -0,0 +1,2 @@
+export * from "urlpattern-polyfill";
+//# sourceMappingURL=index.d.ts.map

package/dist/urlpattern-polyfill/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/urlpattern-polyfill/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC"}

package/dist/urlpattern-polyfill/index.js

@@ -0,0 +1 @@
+export * from "urlpattern-polyfill";

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@inlang/paraglide-js",
   "type": "module",
-  "version": "2.0.0-beta.15",
+  "version": "2.0.0-beta.17",
   "license": "MIT",
   "publishConfig": {
     "access": "public",
@@ -20,13 +20,20 @@
     "./dist",
     "./bin"
   ],
+  "exports": {
+    ".": "./dist/index.js",
+    "./path-to-regexp": "./dist/path-to-regexp/index.js"
+  },
+  "_comment": "Required for tree-shaking https://webpack.js.org/guides/tree-shaking/#mark-the-file-as-side-effect-free",
+  "sideEffects": false,
   "dependencies": {
     "commander": "11.1.0",
     "consola": "3.4.0",
     "json5": "2.2.3",
+    "path-to-regexp": "^8.2.0",
     "unplugin": "^2.1.2",
-    "@inlang/sdk": "2.1.2",
-    "@inlang/recommend-sherlock": "0.2.1"
+    "@inlang/recommend-sherlock": "0.2.1",
+    "@inlang/sdk": "2.2.0"
   },
   "devDependencies": {
     "@eslint/js": "^9.18.0",
@@ -38,14 +45,11 @@
     "memfs": "4.17.0",
     "prettier": "^3.4.2",
     "rolldown": "1.0.0-beta.1",
-    "typescript-eslint": "^8.20.0",
     "typescript": "^5.7.3",
+    "typescript-eslint": "^8.20.0",
     "vitest": "2.1.8",
     "@inlang/plugin-message-format": "3.1.1",
-    "@opral/tsconfig": "1.0.0"
-  },
-  "exports": {
-    ".": "./dist/index.js"
+    "@opral/tsconfig": "1.1.0"
   },
   "keywords": [
     "inlang",