houdini-svelte 1.2.41 → 1.2.42

package/build/plugin-cjs/index.js

@@ -74771,13 +74771,13 @@ async function copyFile(src2, dest) {
   }
   return null;
 }
-async function readFile(filepath) {
+async function readFile(filepath, encoding) {
   if (houdini_mode.is_testing) {
     try {
       if (filepath.includes("build/runtime")) {
-        return await import_promises.default.readFile(filepath, "utf-8");
+        return await import_promises.default.readFile(filepath, encoding ?? "utf-8");
       }
-      return import_memfs.fs.readFileSync(filepath, "utf-8").toString();
+      return import_memfs.fs.readFileSync(filepath, encoding ?? "utf-8").toString();
     } catch (e22) {
       return null;
     }
@@ -74917,11 +74917,15 @@ async function recursiveCopy(source, target, transforms, notRoot) {
           await recursiveCopy(childPath, parentDir, transforms, true);
         } else {
           const targetPath = join2(parentDir, child);
-          let original = await readFile(childPath) || "";
           if (transforms?.[childPath]) {
-            original = await transforms[childPath](original, childPath);
+            let original = await readFile(childPath) || "";
+            await writeFile(
+              targetPath,
+              await transforms[childPath](original, childPath)
+            );
+          } else {
+            await copyFile(childPath, targetPath);
           }
-          await writeFile(targetPath, original);
         }
       })
     );
@@ -140006,13 +140010,13 @@ async function copyFile2(src2, dest) {
   }
   return null;
 }
-async function readFile2(filepath) {
+async function readFile2(filepath, encoding) {
   if (houdini_mode2.is_testing) {
     try {
       if (filepath.includes("build/runtime")) {
-        return await import_promises2.default.readFile(filepath, "utf-8");
+        return await import_promises2.default.readFile(filepath, encoding ?? "utf-8");
       }
-      return import_memfs2.fs.readFileSync(filepath, "utf-8").toString();
+      return import_memfs2.fs.readFileSync(filepath, encoding ?? "utf-8").toString();
     } catch (e22) {
       return null;
     }
@@ -140152,11 +140156,15 @@ async function recursiveCopy2(source, target, transforms, notRoot) {
           await recursiveCopy2(childPath, parentDir, transforms, true);
         } else {
           const targetPath = join22(parentDir, child);
-          let original = await readFile2(childPath) || "";
           if (transforms?.[childPath]) {
-            original = await transforms[childPath](original, childPath);
+            let original = await readFile2(childPath) || "";
+            await writeFile2(
+              targetPath,
+              await transforms[childPath](original, childPath)
+            );
+          } else {
+            await copyFile2(childPath, targetPath);
           }
-          await writeFile2(targetPath, original);
         }
       })
     );

package/build/plugin-esm/index.js

@@ -74766,13 +74766,13 @@ async function copyFile(src2, dest) {
   }
   return null;
 }
-async function readFile(filepath) {
+async function readFile(filepath, encoding) {
   if (houdini_mode.is_testing) {
     try {
       if (filepath.includes("build/runtime")) {
-        return await fs.readFile(filepath, "utf-8");
+        return await fs.readFile(filepath, encoding ?? "utf-8");
       }
-      return import_memfs.fs.readFileSync(filepath, "utf-8").toString();
+      return import_memfs.fs.readFileSync(filepath, encoding ?? "utf-8").toString();
     } catch (e22) {
       return null;
     }
@@ -74912,11 +74912,15 @@ async function recursiveCopy(source, target, transforms, notRoot) {
           await recursiveCopy(childPath, parentDir, transforms, true);
         } else {
           const targetPath = join2(parentDir, child);
-          let original = await readFile(childPath) || "";
           if (transforms?.[childPath]) {
-            original = await transforms[childPath](original, childPath);
+            let original = await readFile(childPath) || "";
+            await writeFile(
+              targetPath,
+              await transforms[childPath](original, childPath)
+            );
+          } else {
+            await copyFile(childPath, targetPath);
           }
-          await writeFile(targetPath, original);
         }
       })
     );
@@ -140000,13 +140004,13 @@ async function copyFile2(src2, dest) {
   }
   return null;
 }
-async function readFile2(filepath) {
+async function readFile2(filepath, encoding) {
   if (houdini_mode2.is_testing) {
     try {
       if (filepath.includes("build/runtime")) {
-        return await fs3.readFile(filepath, "utf-8");
+        return await fs3.readFile(filepath, encoding ?? "utf-8");
       }
-      return import_memfs2.fs.readFileSync(filepath, "utf-8").toString();
+      return import_memfs2.fs.readFileSync(filepath, encoding ?? "utf-8").toString();
     } catch (e22) {
       return null;
     }
@@ -140146,11 +140150,15 @@ async function recursiveCopy2(source, target, transforms, notRoot) {
           await recursiveCopy2(childPath, parentDir, transforms, true);
         } else {
           const targetPath = join22(parentDir, child);
-          let original = await readFile2(childPath) || "";
           if (transforms?.[childPath]) {
-            original = await transforms[childPath](original, childPath);
+            let original = await readFile2(childPath) || "";
+            await writeFile2(
+              targetPath,
+              await transforms[childPath](original, childPath)
+            );
+          } else {
+            await copyFile2(childPath, targetPath);
           }
-          await writeFile2(targetPath, original);
         }
       })
     );

package/build/preprocess-cjs/index.js

@@ -77512,13 +77512,13 @@ async function copyFile(src2, dest) {
   }
   return null;
 }
-async function readFile(filepath) {
+async function readFile(filepath, encoding) {
   if (houdini_mode.is_testing) {
     try {
       if (filepath.includes("build/runtime")) {
-        return await import_promises.default.readFile(filepath, "utf-8");
+        return await import_promises.default.readFile(filepath, encoding ?? "utf-8");
       }
-      return import_memfs.fs.readFileSync(filepath, "utf-8").toString();
+      return import_memfs.fs.readFileSync(filepath, encoding ?? "utf-8").toString();
     } catch (e22) {
       return null;
     }
@@ -77658,11 +77658,15 @@ async function recursiveCopy(source, target, transforms, notRoot) {
           await recursiveCopy(childPath, parentDir, transforms, true);
         } else {
           const targetPath = join2(parentDir, child);
-          let original = await readFile(childPath) || "";
           if (transforms?.[childPath]) {
-            original = await transforms[childPath](original, childPath);
+            let original = await readFile(childPath) || "";
+            await writeFile(
+              targetPath,
+              await transforms[childPath](original, childPath)
+            );
+          } else {
+            await copyFile(childPath, targetPath);
           }
-          await writeFile(targetPath, original);
         }
       })
     );
@@ -171812,13 +171816,13 @@ async function copyFile2(src2, dest) {
   }
   return null;
 }
-async function readFile2(filepath) {
+async function readFile2(filepath, encoding) {
   if (houdini_mode2.is_testing) {
     try {
       if (filepath.includes("build/runtime")) {
-        return await import_promises2.default.readFile(filepath, "utf-8");
+        return await import_promises2.default.readFile(filepath, encoding ?? "utf-8");
       }
-      return import_memfs2.fs.readFileSync(filepath, "utf-8").toString();
+      return import_memfs2.fs.readFileSync(filepath, encoding ?? "utf-8").toString();
     } catch (e22) {
       return null;
     }
@@ -171958,11 +171962,15 @@ async function recursiveCopy2(source, target, transforms, notRoot) {
           await recursiveCopy2(childPath, parentDir, transforms, true);
         } else {
           const targetPath = join22(parentDir, child);
-          let original = await readFile2(childPath) || "";
           if (transforms?.[childPath]) {
-            original = await transforms[childPath](original, childPath);
+            let original = await readFile2(childPath) || "";
+            await writeFile2(
+              targetPath,
+              await transforms[childPath](original, childPath)
+            );
+          } else {
+            await copyFile2(childPath, targetPath);
           }
-          await writeFile2(targetPath, original);
         }
       })
     );

package/build/preprocess-esm/index.js

@@ -77509,13 +77509,13 @@ async function copyFile(src2, dest) {
   }
   return null;
 }
-async function readFile(filepath) {
+async function readFile(filepath, encoding) {
   if (houdini_mode.is_testing) {
     try {
       if (filepath.includes("build/runtime")) {
-        return await fs.readFile(filepath, "utf-8");
+        return await fs.readFile(filepath, encoding ?? "utf-8");
       }
-      return import_memfs.fs.readFileSync(filepath, "utf-8").toString();
+      return import_memfs.fs.readFileSync(filepath, encoding ?? "utf-8").toString();
     } catch (e22) {
       return null;
     }
@@ -77655,11 +77655,15 @@ async function recursiveCopy(source, target, transforms, notRoot) {
           await recursiveCopy(childPath, parentDir, transforms, true);
         } else {
           const targetPath = join2(parentDir, child);
-          let original = await readFile(childPath) || "";
           if (transforms?.[childPath]) {
-            original = await transforms[childPath](original, childPath);
+            let original = await readFile(childPath) || "";
+            await writeFile(
+              targetPath,
+              await transforms[childPath](original, childPath)
+            );
+          } else {
+            await copyFile(childPath, targetPath);
           }
-          await writeFile(targetPath, original);
         }
       })
     );
@@ -171808,13 +171812,13 @@ async function copyFile2(src2, dest) {
   }
   return null;
 }
-async function readFile2(filepath) {
+async function readFile2(filepath, encoding) {
   if (houdini_mode2.is_testing) {
     try {
       if (filepath.includes("build/runtime")) {
-        return await fs3.readFile(filepath, "utf-8");
+        return await fs3.readFile(filepath, encoding ?? "utf-8");
       }
-      return import_memfs2.fs.readFileSync(filepath, "utf-8").toString();
+      return import_memfs2.fs.readFileSync(filepath, encoding ?? "utf-8").toString();
     } catch (e22) {
       return null;
     }
@@ -171954,11 +171958,15 @@ async function recursiveCopy2(source, target, transforms, notRoot) {
           await recursiveCopy2(childPath, parentDir, transforms, true);
         } else {
           const targetPath = join22(parentDir, child);
-          let original = await readFile2(childPath) || "";
           if (transforms?.[childPath]) {
-            original = await transforms[childPath](original, childPath);
+            let original = await readFile2(childPath) || "";
+            await writeFile2(
+              targetPath,
+              await transforms[childPath](original, childPath)
+            );
+          } else {
+            await copyFile2(childPath, targetPath);
           }
-          await writeFile2(targetPath, original);
         }
       })
     );

package/build/test-cjs/index.js

@@ -74774,13 +74774,13 @@ async function copyFile(src2, dest) {
   }
   return null;
 }
-async function readFile(filepath) {
+async function readFile(filepath, encoding) {
   if (houdini_mode.is_testing) {
     try {
       if (filepath.includes("build/runtime")) {
-        return await import_promises.default.readFile(filepath, "utf-8");
+        return await import_promises.default.readFile(filepath, encoding ?? "utf-8");
       }
-      return import_memfs.fs.readFileSync(filepath, "utf-8").toString();
+      return import_memfs.fs.readFileSync(filepath, encoding ?? "utf-8").toString();
     } catch (e22) {
       return null;
     }
@@ -74920,11 +74920,15 @@ async function recursiveCopy(source, target, transforms, notRoot) {
           await recursiveCopy(childPath, parentDir, transforms, true);
         } else {
           const targetPath = join2(parentDir, child);
-          let original = await readFile(childPath) || "";
           if (transforms?.[childPath]) {
-            original = await transforms[childPath](original, childPath);
+            let original = await readFile(childPath) || "";
+            await writeFile(
+              targetPath,
+              await transforms[childPath](original, childPath)
+            );
+          } else {
+            await copyFile(childPath, targetPath);
           }
-          await writeFile(targetPath, original);
         }
       })
     );
@@ -132407,13 +132411,13 @@ async function copyFile2(src2, dest) {
   }
   return null;
 }
-async function readFile2(filepath) {
+async function readFile2(filepath, encoding) {
   if (houdini_mode2.is_testing) {
     try {
       if (filepath.includes("build/runtime")) {
-        return await import_promises2.default.readFile(filepath, "utf-8");
+        return await import_promises2.default.readFile(filepath, encoding ?? "utf-8");
       }
-      return import_memfs2.fs.readFileSync(filepath, "utf-8").toString();
+      return import_memfs2.fs.readFileSync(filepath, encoding ?? "utf-8").toString();
     } catch (e3) {
       return null;
     }
@@ -132553,11 +132557,15 @@ async function recursiveCopy2(source, target, transforms, notRoot) {
           await recursiveCopy2(childPath, parentDir, transforms, true);
         } else {
           const targetPath = join3(parentDir, child);
-          let original = await readFile2(childPath) || "";
           if (transforms?.[childPath]) {
-            original = await transforms[childPath](original, childPath);
+            let original = await readFile2(childPath) || "";
+            await writeFile2(
+              targetPath,
+              await transforms[childPath](original, childPath)
+            );
+          } else {
+            await copyFile2(childPath, targetPath);
           }
-          await writeFile2(targetPath, original);
         }
       })
     );
@@ -196760,13 +196768,13 @@ async function copyFile3(src2, dest) {
   }
   return null;
 }
-async function readFile3(filepath) {
+async function readFile3(filepath, encoding) {
   if (houdini_mode3.is_testing) {
     try {
       if (filepath.includes("build/runtime")) {
-        return await import_promises3.default.readFile(filepath, "utf-8");
+        return await import_promises3.default.readFile(filepath, encoding ?? "utf-8");
       }
-      return import_memfs3.fs.readFileSync(filepath, "utf-8").toString();
+      return import_memfs3.fs.readFileSync(filepath, encoding ?? "utf-8").toString();
     } catch (e3) {
       return null;
     }
@@ -196906,11 +196914,15 @@ async function recursiveCopy3(source, target, transforms, notRoot) {
           await recursiveCopy3(childPath, parentDir, transforms, true);
         } else {
           const targetPath = join4(parentDir, child);
-          let original = await readFile3(childPath) || "";
           if (transforms?.[childPath]) {
-            original = await transforms[childPath](original, childPath);
+            let original = await readFile3(childPath) || "";
+            await writeFile3(
+              targetPath,
+              await transforms[childPath](original, childPath)
+            );
+          } else {
+            await copyFile3(childPath, targetPath);
           }
-          await writeFile3(targetPath, original);
         }
       })
     );
@@ -262094,13 +262106,13 @@ async function copyFile4(src2, dest) {
   }
   return null;
 }
-async function readFile4(filepath) {
+async function readFile4(filepath, encoding) {
   if (houdini_mode4.is_testing) {
     try {
       if (filepath.includes("build/runtime")) {
-        return await import_promises4.default.readFile(filepath, "utf-8");
+        return await import_promises4.default.readFile(filepath, encoding ?? "utf-8");
       }
-      return import_memfs4.fs.readFileSync(filepath, "utf-8").toString();
+      return import_memfs4.fs.readFileSync(filepath, encoding ?? "utf-8").toString();
     } catch (e22) {
       return null;
     }
@@ -262240,11 +262252,15 @@ async function recursiveCopy4(source, target, transforms, notRoot) {
           await recursiveCopy4(childPath, parentDir, transforms, true);
         } else {
           const targetPath = join24(parentDir, child);
-          let original = await readFile4(childPath) || "";
           if (transforms?.[childPath]) {
-            original = await transforms[childPath](original, childPath);
+            let original = await readFile4(childPath) || "";
+            await writeFile4(
+              targetPath,
+              await transforms[childPath](original, childPath)
+            );
+          } else {
+            await copyFile4(childPath, targetPath);
           }
-          await writeFile4(targetPath, original);
         }
       })
     );

package/build/test-esm/index.js

@@ -74766,13 +74766,13 @@ async function copyFile(src2, dest) {
   }
   return null;
 }
-async function readFile(filepath) {
+async function readFile(filepath, encoding) {
   if (houdini_mode.is_testing) {
     try {
       if (filepath.includes("build/runtime")) {
-        return await fs.readFile(filepath, "utf-8");
+        return await fs.readFile(filepath, encoding ?? "utf-8");
       }
-      return import_memfs.fs.readFileSync(filepath, "utf-8").toString();
+      return import_memfs.fs.readFileSync(filepath, encoding ?? "utf-8").toString();
     } catch (e22) {
       return null;
     }
@@ -74912,11 +74912,15 @@ async function recursiveCopy(source, target, transforms, notRoot) {
           await recursiveCopy(childPath, parentDir, transforms, true);
         } else {
           const targetPath = join2(parentDir, child);
-          let original = await readFile(childPath) || "";
           if (transforms?.[childPath]) {
-            original = await transforms[childPath](original, childPath);
+            let original = await readFile(childPath) || "";
+            await writeFile(
+              targetPath,
+              await transforms[childPath](original, childPath)
+            );
+          } else {
+            await copyFile(childPath, targetPath);
           }
-          await writeFile(targetPath, original);
         }
       })
     );
@@ -132398,13 +132402,13 @@ async function copyFile2(src2, dest) {
   }
   return null;
 }
-async function readFile2(filepath) {
+async function readFile2(filepath, encoding) {
   if (houdini_mode2.is_testing) {
     try {
       if (filepath.includes("build/runtime")) {
-        return await fs3.readFile(filepath, "utf-8");
+        return await fs3.readFile(filepath, encoding ?? "utf-8");
       }
-      return import_memfs2.fs.readFileSync(filepath, "utf-8").toString();
+      return import_memfs2.fs.readFileSync(filepath, encoding ?? "utf-8").toString();
     } catch (e3) {
       return null;
     }
@@ -132544,11 +132548,15 @@ async function recursiveCopy2(source, target, transforms, notRoot) {
           await recursiveCopy2(childPath, parentDir, transforms, true);
         } else {
           const targetPath = join3(parentDir, child);
-          let original = await readFile2(childPath) || "";
           if (transforms?.[childPath]) {
-            original = await transforms[childPath](original, childPath);
+            let original = await readFile2(childPath) || "";
+            await writeFile2(
+              targetPath,
+              await transforms[childPath](original, childPath)
+            );
+          } else {
+            await copyFile2(childPath, targetPath);
           }
-          await writeFile2(targetPath, original);
         }
       })
     );
@@ -196750,13 +196758,13 @@ async function copyFile3(src2, dest) {
   }
   return null;
 }
-async function readFile3(filepath) {
+async function readFile3(filepath, encoding) {
   if (houdini_mode3.is_testing) {
     try {
       if (filepath.includes("build/runtime")) {
-        return await fs4.readFile(filepath, "utf-8");
+        return await fs4.readFile(filepath, encoding ?? "utf-8");
       }
-      return import_memfs3.fs.readFileSync(filepath, "utf-8").toString();
+      return import_memfs3.fs.readFileSync(filepath, encoding ?? "utf-8").toString();
     } catch (e3) {
       return null;
     }
@@ -196896,11 +196904,15 @@ async function recursiveCopy3(source, target, transforms, notRoot) {
           await recursiveCopy3(childPath, parentDir, transforms, true);
         } else {
           const targetPath = join4(parentDir, child);
-          let original = await readFile3(childPath) || "";
           if (transforms?.[childPath]) {
-            original = await transforms[childPath](original, childPath);
+            let original = await readFile3(childPath) || "";
+            await writeFile3(
+              targetPath,
+              await transforms[childPath](original, childPath)
+            );
+          } else {
+            await copyFile3(childPath, targetPath);
           }
-          await writeFile3(targetPath, original);
         }
       })
     );
@@ -262083,13 +262095,13 @@ async function copyFile4(src2, dest) {
   }
   return null;
 }
-async function readFile4(filepath) {
+async function readFile4(filepath, encoding) {
   if (houdini_mode4.is_testing) {
     try {
       if (filepath.includes("build/runtime")) {
-        return await fs5.readFile(filepath, "utf-8");
+        return await fs5.readFile(filepath, encoding ?? "utf-8");
       }
-      return import_memfs4.fs.readFileSync(filepath, "utf-8").toString();
+      return import_memfs4.fs.readFileSync(filepath, encoding ?? "utf-8").toString();
     } catch (e22) {
       return null;
     }
@@ -262229,11 +262241,15 @@ async function recursiveCopy4(source, target, transforms, notRoot) {
           await recursiveCopy4(childPath, parentDir, transforms, true);
         } else {
           const targetPath = join24(parentDir, child);
-          let original = await readFile4(childPath) || "";
           if (transforms?.[childPath]) {
-            original = await transforms[childPath](original, childPath);
+            let original = await readFile4(childPath) || "";
+            await writeFile4(
+              targetPath,
+              await transforms[childPath](original, childPath)
+            );
+          } else {
+            await copyFile4(childPath, targetPath);
           }
-          await writeFile4(targetPath, original);
         }
       })
     );

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "houdini-svelte",
-  "version": "1.2.41",
+  "version": "1.2.42",
   "description": "The svelte plugin for houdini",
   "keywords": [
     "typescript",
@@ -33,7 +33,7 @@
     "rollup": "^3.7.4",
     "svelte": "^3.57.0",
     "vite": "^4.1.1",
-    "houdini": "^1.2.41"
+    "houdini": "^1.2.42"
   },
   "files": [
     "build"