@batijs/build 0.0.248 → 0.0.249

package/dist/index.js

@@ -1,20 +1,23 @@
 // src/index.ts
 import { existsSync } from "node:fs";
-import { mkdir, opendir, readFile as readFile2, writeFile } from "node:fs/promises";
+import { mkdir, opendir, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
-import { formatCode, transformAndFormat as transformAndFormat2 } from "@batijs/core";
+import "@batijs/core";
 
-// src/merge-dts.ts
+// src/operations/file.ts
+import { transformAndFormat as transformAndFormat2 } from "@batijs/core";
 import { readFile } from "node:fs/promises";
+import { relative } from "node:path";
+
+// src/operations/merge-dts.ts
 import { parseModule, transformAndFormat } from "@batijs/core";
 async function mergeDts({
-  target,
   fileContent,
+  previousContent,
   filepath,
   meta
 }) {
-  const previousCode = await readFile(target, { encoding: "utf-8" });
-  const previousAst = parseModule(previousCode);
+  const previousAst = parseModule(previousContent);
   const currentAst = parseModule(fileContent);
   for (const imp of previousAst.imports.$items) {
     currentAst.imports[imp.local] = imp;
@@ -38,49 +41,38 @@ async function mergeDts({
   return res.code;
 }
 
-// src/queue.ts
-function queue() {
-  const tasks = [];
+// src/operations/file.ts
+async function executeOperationFile(op, {
+  meta,
+  previousOperationSameDestination
+}) {
+  const code = await readFile(op.sourceAbsolute, { encoding: "utf-8" });
+  const filepath = relative(op.source, op.sourceAbsolute);
+  const result = await transformAndFormat2(code, meta, {
+    filepath
+  });
+  let fileContent = result.code;
+  if (op.sourceAbsolute.endsWith(".d.ts") && previousOperationSameDestination?.content) {
+    fileContent = await mergeDts({
+      fileContent,
+      previousContent: previousOperationSameDestination.content,
+      meta,
+      filepath
+    });
+  }
   return {
-    add(task) {
-      tasks.push(task);
-    },
-    async run() {
-      let task;
-      while (task = tasks.shift()) {
-        await task();
-      }
-    }
+    context: result.context,
+    content: fileContent ? fileContent.trimStart() : void 0
   };
 }
 
-// src/index.ts
-var reIgnoreFile = /^(chunk-|asset-|#)/gi;
+// src/operations/transform.ts
+import { parse } from "path";
+import { formatCode } from "@batijs/core";
 var isWin = process.platform === "win32";
-function toDist(filepath, source, dist) {
-  const split = filepath.split(path.sep);
-  split[split.length - 1] = split[split.length - 1].replace(/^\$\$?(.*)\.[tj]sx?$/, "$1");
-  return split.join(path.sep).replace(source, dist);
-}
-async function safeWriteFile(destination, content) {
-  const destinationDir = path.dirname(destination);
-  await mkdir(destinationDir, {
-    recursive: true
-  });
-  await writeFile(destination, content, { encoding: "utf-8" });
-}
-async function* walk(dir) {
-  if (!existsSync(dir)) return;
-  for await (const d of await opendir(dir)) {
-    const entry = path.join(dir, d.name);
-    if (d.isDirectory()) {
-      yield* walk(entry);
-    } else if (d.isFile()) yield entry;
-  }
-}
 async function transformFileAfterExec(filepath, fileContent) {
   if (fileContent === void 0 || fileContent === null) return null;
-  const parsed = path.parse(filepath);
+  const parsed = parse(filepath);
   const toTest = [parsed.base, parsed.ext, parsed.name].filter(Boolean);
   for (const ext of toTest) {
     switch (ext) {
@@ -117,6 +109,111 @@ async function importTransformer(p) {
   const f = await import(importFile);
   return f.default;
 }
+async function executeOperationTransform(op, {
+  meta,
+  previousOperationSameDestination
+}) {
+  const transformer = await importTransformer(op.sourceAbsolute);
+  const previousContent = previousOperationSameDestination?.content;
+  const fileContent = await transformFileAfterExec(
+    op.destination,
+    await transformer({
+      readfile: previousContent ? () => previousContent : void 0,
+      meta,
+      source: op.source,
+      target: op.destination
+    })
+  );
+  return {
+    content: fileContent !== null ? fileContent : void 0
+  };
+}
+
+// src/utils.ts
+function orderBy(array, getter) {
+  return array.slice().sort((a, b) => {
+    const valueA = getter(a);
+    const valueB = getter(b);
+    if (valueA < valueB) return -1;
+    if (valueA > valueB) return 1;
+    return 0;
+  });
+}
+
+// src/operations/rearranger.ts
+var OperationsRearranger = class {
+  files;
+  constructor() {
+    this.files = /* @__PURE__ */ new Map();
+  }
+  addFile(file) {
+    if (!this.files.has(file.destination)) {
+      this.files.set(file.destination, []);
+    }
+    this.files.get(file.destination).push(file);
+  }
+  *compute() {
+    for (const file of this.files.values()) {
+      if (file.filter((op) => op.important).length >= 2) {
+        throw new Error(`Error while trying to generate file: '${file[0].destination}'.
+Multiple important file is not yet supported.
+Please report this issue to https://github.com/vikejs/bati`);
+      }
+      const newOrder = orderBy(file, (op) => {
+        if (op.kind === "file" && !op.important) return 1;
+        if (op.kind === "file" && op.important) return 2;
+        if (op.kind === "transform" && !op.important) return 3;
+        if (op.kind === "transform" && op.important) return 4;
+        throw new Error("Unhandled OperationsRearranger.compute orderBy case");
+      });
+      if (file[0].sourceAbsolute.endsWith(".d.ts")) {
+        yield* newOrder.filter((op) => op.kind === "file");
+      } else {
+        const input = newOrder.filter((op) => op.kind === "file").at(-1);
+        if (input) {
+          yield input;
+        }
+      }
+      yield* newOrder.filter((op) => op.kind !== "file");
+    }
+  }
+};
+
+// src/index.ts
+var reIgnoreFile = /^(chunk-|asset-|#)/gi;
+function toDist(filepath, source, dist) {
+  const split = filepath.split(path.sep);
+  split[split.length - 1] = split[split.length - 1].replace(/^\$\$?(.*)\.[tj]sx?$/, "$1").replace(/^!(.*)$/, "$1");
+  return split.join(path.sep).replace(source, dist);
+}
+async function safeWriteFile(destination, content) {
+  const destinationDir = path.dirname(destination);
+  await mkdir(destinationDir, {
+    recursive: true
+  });
+  await writeFile(destination, content, { encoding: "utf-8" });
+}
+async function safeRmFile(destination) {
+  try {
+    await rm(destination, {
+      force: true,
+      maxRetries: 3,
+      recursive: false,
+      retryDelay: 150
+    });
+  } catch {
+    console.warn(`Failed to remove unecessary file: ${destination}`);
+  }
+}
+async function* walk(dir) {
+  if (!existsSync(dir)) return;
+  for await (const d of await opendir(dir)) {
+    const entry = path.join(dir, d.name);
+    if (d.isDirectory()) {
+      yield* walk(entry);
+    } else if (d.isFile()) yield entry;
+  }
+}
 function importToPotentialTargets(imp) {
   let subject = imp;
   const ext = path.extname(imp);
@@ -133,11 +230,8 @@ function importToPotentialTargets(imp) {
 }
 async function main(options, meta) {
   const sources = Array.isArray(options.source) ? options.source : [options.source];
-  const targets = /* @__PURE__ */ new Set();
   const allImports = /* @__PURE__ */ new Set();
-  const includeIfImported = /* @__PURE__ */ new Map();
-  const priorityQ = queue();
-  const transformAndWriteQ = queue();
+  const filesContainingIncludeIfImported = /* @__PURE__ */ new Set();
   function updateAllImports(target, imports) {
     if (!imports) return;
     for (const imp of imports.values()) {
@@ -148,21 +242,7 @@ async function main(options, meta) {
       }
     }
   }
-  async function triggerPendingTargets(target, imports) {
-    if (!imports) return;
-    for (const imp of imports.values()) {
-      const importTarget = path.resolve(path.dirname(target), imp);
-      const importTargets = importToPotentialTargets(importTarget);
-      for (const imp2 of importTargets) {
-        if (includeIfImported.has(imp2)) {
-          const fn = includeIfImported.get(imp2);
-          includeIfImported.delete(imp2);
-          await fn();
-          break;
-        }
-      }
-    }
-  }
+  const rearranger = new OperationsRearranger();
   for (const source of sources) {
     for await (const p of walk(source)) {
       const target = toDist(p, source, options.dist);
@@ -175,61 +255,58 @@ async function main(options, meta) {
           `Typescript file needs to be compiled before it can be executed: '${p}'.
 Please report this issue to https://github.com/vikejs/bati`
         );
-      } else if (parsed.name.startsWith("$") && parsed.ext.match(/\.jsx?$/)) {
-        transformAndWriteQ.add(async () => {
-          const transformer = await importTransformer(p);
-          const rf = () => {
-            return readFile2(target, { encoding: "utf-8" });
-          };
-          const fileContent = await transformFileAfterExec(
-            target,
-            await transformer({
-              readfile: targets.has(target) ? rf : void 0,
-              meta,
-              source,
-              target
-            })
-          );
-          if (fileContent !== null) {
-            await safeWriteFile(target, fileContent);
-            targets.add(target);
-          }
+      } else if ((parsed.name.startsWith("!$") || parsed.name.startsWith("$")) && parsed.ext.match(/\.jsx?$/)) {
+        rearranger.addFile({
+          source,
+          sourceAbsolute: p,
+          destination: target,
+          destinationAbsolute: targetAbsolute,
+          kind: "transform",
+          parsed,
+          important: parsed.name.startsWith("!")
         });
       } else {
-        priorityQ.add(async () => {
-          const code = await readFile2(p, { encoding: "utf-8" });
-          const filepath = path.relative(source, p);
-          const result = await transformAndFormat2(code, meta, {
-            filepath
-          });
-          let fileContent = result.code;
-          if (p.endsWith(".d.ts") && targets.has(target)) {
-            fileContent = await mergeDts({
-              fileContent,
-              target,
-              meta,
-              filepath
-            });
-          }
-          if (fileContent) {
-            updateAllImports(targetAbsolute, result.context?.imports);
-            if (!result.context?.flags.has("include-if-imported") || allImports.has(targetAbsolute)) {
-              await safeWriteFile(target, fileContent.trimStart());
-              await triggerPendingTargets(targetAbsolute, result.context?.imports);
-            } else {
-              includeIfImported.set(targetAbsolute, () => safeWriteFile(target, fileContent.trimStart()));
-            }
-            targets.add(target);
-          }
+        rearranger.addFile({
+          source,
+          sourceAbsolute: p,
+          destination: target,
+          destinationAbsolute: targetAbsolute,
+          kind: "file",
+          parsed,
+          important: parsed.name.startsWith("!")
         });
       }
     }
   }
-  await priorityQ.run();
-  await transformAndWriteQ.run();
-  for (const target of includeIfImported.keys()) {
-    if (allImports.has(target)) {
-      await includeIfImported.get(target)();
+  let previousOp = void 0;
+  for (const op of rearranger.compute()) {
+    if (previousOp?.destination !== op.destination) {
+      previousOp = void 0;
+    }
+    let report = {};
+    if (op.kind === "file") {
+      report = await executeOperationFile(op, {
+        meta,
+        previousOperationSameDestination: previousOp
+      });
+      updateAllImports(op.destinationAbsolute, report.context?.imports);
+    } else if (op.kind === "transform") {
+      report = await executeOperationTransform(op, {
+        meta,
+        previousOperationSameDestination: previousOp
+      });
+    }
+    if (report.content) {
+      await safeWriteFile(op.destination, report.content.trimStart());
+    }
+    previousOp = {
+      ...op,
+      ...report
+    };
+  }
+  for (const target of filesContainingIncludeIfImported) {
+    if (!allImports.has(target)) {
+      await safeRmFile(target);
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@batijs/build",
-  "version": "0.0.248",
+  "version": "0.0.249",
   "description": "",
   "type": "module",
   "keywords": [],
@@ -10,10 +10,10 @@
   "devDependencies": {
     "@types/node": "^18.19.14",
     "tsup": "^8.2.4",
-    "@batijs/compile": "0.0.248"
+    "@batijs/compile": "0.0.249"
   },
   "dependencies": {
-    "@batijs/core": "0.0.248"
+    "@batijs/core": "0.0.249"
   },
   "main": "./dist/index.js",
   "module": "./dist/index.js",