@gregorlohaus/tdir 0.1.4 → 0.1.6

package/README.md

@@ -208,8 +208,31 @@ tdir reverse ./output ./templates --map meta/reverse-map.json
 bunx @gregorlohaus/tdir reverse ./output ./templates --map meta/reverse-map.json
 ```
 
+New files created in the rendered directory are ignored by default. Include them explicitly with one or more glob patterns:
+
+```sh
+tdir reverse ./output ./templates --include "components/**"
+tdir reverse ./output ./templates --include "components/**/*.ts" --include "pages/*.html"
+```
+
+Programmatically, pass the same globs to `reverseDir`:
+
+```ts
+reverseDir("./output", "./templates", {
+  include: ["components/**/*.ts", "pages/*.html"]
+})
+```
+
 The command writes files at their original template paths, restores recorded `<@var(...)>` tokens, wraps edited inline conditional output back in the original conditional block, and restores template files that were skipped by path conditionals.
 
+The template output directory may be inside the rendered directory, for example:
+
+```sh
+tdir reverse ./ ./reversed --include "components/**"
+```
+
+When the template output directory is inside the rendered directory, reverse snapshots included files before writing and excludes the output directory from include glob matching.
+
 ## Unmatched directives
 
 A `<@if>` without a matching `<@endif>` throws when the renderer is initialized:

package/dist/cli.js

@@ -6,6 +6,7 @@ import {
   existsSync,
   mkdirSync,
   readFileSync,
+  readdirSync,
   statSync,
   writeFileSync
 } from "node:fs";
@@ -39,6 +40,45 @@ function readManifest(mapPath) {
   }
   return manifest;
 }
+function normalizePath(path) {
+  return path.split("\\").join("/");
+}
+function escapeRegExp(text) {
+  return text.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+}
+function globToRegExp(glob) {
+  let source = "^";
+  const pattern = normalizePath(glob);
+  for (let i = 0;i < pattern.length; i++) {
+    const char = pattern[i];
+    const next = pattern[i + 1];
+    if (char === "*" && next === "*") {
+      if (pattern[i + 2] === "/") {
+        source += "(?:.*/)?";
+        i += 2;
+      } else {
+        source += ".*";
+        i += 1;
+      }
+    } else if (char === "*") {
+      source += "[^/]*";
+    } else if (char === "?") {
+      source += "[^/]";
+    } else {
+      source += escapeRegExp(char);
+    }
+  }
+  return new RegExp(`${source}$`);
+}
+function getIncludeMatchers(include) {
+  if (!include)
+    return [];
+  return (Array.isArray(include) ? include : [include]).map(globToRegExp);
+}
+function matchesAny(path, matchers) {
+  const normalized = normalizePath(path);
+  return matchers.some((matcher) => matcher.test(normalized));
+}
 function replaceAtRange(content, token) {
   if (!token.range)
     return null;
@@ -159,11 +199,106 @@ function writeSkippedTemplate(templateRoot, skipped) {
   writeFileSync(templatePath, content);
   return 1;
 }
+function dirnamePath(path) {
+  const normalized = normalizePath(path);
+  const index = normalized.lastIndexOf("/");
+  return index === -1 ? "" : normalized.slice(0, index);
+}
+function basenamePath(path) {
+  const normalized = normalizePath(path);
+  const index = normalized.lastIndexOf("/");
+  return index === -1 ? normalized : normalized.slice(index + 1);
+}
+function joinPath(...parts) {
+  return parts.filter((part) => part !== "").join("/");
+}
+function buildDirectoryMap(manifest) {
+  const mappings = new Map([["", ""]]);
+  function addMapping(outputDir, templateDir) {
+    const outputParts = normalizePath(outputDir).split("/").filter(Boolean);
+    const templateParts = normalizePath(templateDir).split("/").filter(Boolean);
+    for (let i = 1;i <= outputParts.length; i++) {
+      if (i <= templateParts.length) {
+        mappings.set(outputParts.slice(0, i).join("/"), templateParts.slice(0, i).join("/"));
+      }
+    }
+    mappings.set(normalizePath(outputDir), normalizePath(templateDir));
+  }
+  for (const file of manifest.files) {
+    const output = normalizePath(file.outputPath);
+    const template = normalizePath(file.templatePath);
+    addMapping(dirnamePath(output), dirnamePath(template));
+    if (file.tokens.some((token) => token.kind === "path"))
+      addMapping(output, template);
+  }
+  for (const skipped of manifest.skipped ?? []) {
+    if (skipped.kind === "directory")
+      continue;
+    addMapping(dirnamePath(skipped.templatePath), dirnamePath(skipped.templatePath));
+  }
+  return mappings;
+}
+function inferTemplatePath(outputPath, directoryMap) {
+  const normalized = normalizePath(outputPath);
+  const outputDir = dirnamePath(normalized);
+  let bestOutputDir = "";
+  let bestTemplateDir = "";
+  for (const [mappedOutputDir, mappedTemplateDir] of directoryMap) {
+    if (mappedOutputDir.length >= bestOutputDir.length && (outputDir === mappedOutputDir || outputDir.startsWith(`${mappedOutputDir}/`))) {
+      bestOutputDir = mappedOutputDir;
+      bestTemplateDir = mappedTemplateDir;
+    }
+  }
+  const suffix = bestOutputDir === "" ? outputDir : outputDir.slice(bestOutputDir.length).replace(/^\//, "");
+  return joinPath(bestTemplateDir, suffix, basenamePath(normalized));
+}
+function walkFiles(root, excludedRoots = []) {
+  const files = [];
+  const pending = [root];
+  while (pending.length > 0) {
+    const current = pending.pop();
+    for (const entry of readdirSync(current).sort()) {
+      const path = resolvePath(current, entry);
+      if (excludedRoots.some((excluded) => isInsidePath(excluded, path)))
+        continue;
+      const stat = statSync(path);
+      if (stat.isDirectory()) {
+        pending.push(path);
+      } else if (stat.isFile()) {
+        files.push(normalizePath(relative(root, path)));
+      }
+    }
+  }
+  return files;
+}
+function copyIncludedRenderedFiles(renderedRoot, templateRoot, includedOutputPaths, directoryMap) {
+  let filesWritten = 0;
+  for (const outputPath of includedOutputPaths) {
+    const renderedPath = resolveInside(renderedRoot, outputPath);
+    const templatePath = resolveInside(templateRoot, inferTemplatePath(outputPath, directoryMap));
+    mkdirSync(dirname(templatePath), { recursive: true });
+    copyFileSync(renderedPath, templatePath);
+    filesWritten += 1;
+  }
+  return filesWritten;
+}
+function getIncludedRenderedFiles(renderedRoot, templateRoot, mapPath, manifest, include) {
+  const matchers = getIncludeMatchers(include);
+  if (matchers.length === 0)
+    return [];
+  const mappedOutputPaths = new Set(manifest.files.map((file) => normalizePath(file.outputPath)));
+  const mapRelativePath = normalizePath(relative(renderedRoot, mapPath));
+  return walkFiles(renderedRoot, [templateRoot]).filter((outputPath) => {
+    return outputPath !== mapRelativePath && !mappedOutputPaths.has(outputPath) && matchesAny(outputPath, matchers);
+  });
+}
 function reverseDir(renderedDir, templateDir, options = {}) {
   const renderedRoot = resolvePath(renderedDir);
   const templateRoot = resolvePath(templateDir);
   const mapPath = options.mapPath ? resolvePath(renderedRoot, options.mapPath) : resolvePath(renderedRoot, ".tdir-map.json");
   const manifest = readManifest(mapPath);
+  const directoryMap = buildDirectoryMap(manifest);
+  const includedOutputPaths = getIncludedRenderedFiles(renderedRoot, templateRoot, mapPath, manifest, options.include);
   const warnings = [];
   let filesWritten = 0;
   for (const file of manifest.files) {
@@ -198,6 +333,7 @@ function reverseDir(renderedDir, templateDir, options = {}) {
   for (const skipped of manifest.skipped ?? []) {
     filesWritten += writeSkippedTemplate(templateRoot, skipped);
   }
+  filesWritten += copyIncludedRenderedFiles(renderedRoot, templateRoot, includedOutputPaths, directoryMap);
   return { filesWritten, warnings };
 }
 
@@ -206,7 +342,7 @@ function printHelp() {
   console.log(`tdir
 
 Usage:
-  tdir reverse <rendered-dir> <template-dir> [--map <path>]
+  tdir reverse <rendered-dir> <template-dir> [--map <path>] [--include <glob>...]
 
 Commands:
   reverse   Rebuild template files from a rendered directory and reverse map
@@ -214,16 +350,18 @@ Commands:
 Options:
   --map     Reverse map path. Defaults to <rendered-dir>/.tdir-map.json.
             Relative paths are resolved from <rendered-dir>.
+  --include Include new rendered files matching a glob. Can be repeated.
   --help    Show this help message.
 `);
 }
 function parseReverseArgs(args) {
   const positional = [];
+  const include = [];
   let mapPath;
   for (let i = 0;i < args.length; i++) {
     const arg = args[i];
     if (arg === "--help" || arg === "-h") {
-      return { help: true, positional, mapPath };
+      return { help: true, positional, mapPath, include };
     }
     if (arg === "--map") {
       const value = args[++i];
@@ -232,9 +370,16 @@ function parseReverseArgs(args) {
       mapPath = value;
       continue;
     }
+    if (arg === "--include") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("Missing value for --include");
+      include.push(value);
+      continue;
+    }
     positional.push(arg);
   }
-  return { help: false, positional, mapPath };
+  return { help: false, positional, mapPath, include };
 }
 function main(argv) {
   const [command, ...args] = argv;
@@ -252,9 +397,12 @@ function main(argv) {
   }
   const [renderedDir, templateDir] = parsed.positional;
   if (!renderedDir || !templateDir || parsed.positional.length > 2) {
-    throw new Error("Usage: tdir reverse <rendered-dir> <template-dir> [--map <path>]");
+    throw new Error("Usage: tdir reverse <rendered-dir> <template-dir> [--map <path>] [--include <glob>...]");
   }
-  const result = reverseDir(renderedDir, templateDir, { mapPath: parsed.mapPath });
+  const result = reverseDir(renderedDir, templateDir, {
+    mapPath: parsed.mapPath,
+    include: parsed.include
+  });
   console.log(`Wrote ${result.filesWritten} file${result.filesWritten === 1 ? "" : "s"}`);
   for (const warning of result.warnings) {
     console.warn(`Warning: ${warning.outputPath}: ${warning.message}`);

package/dist/index.js

@@ -492,6 +492,7 @@ import {
   existsSync,
   mkdirSync as mkdirSync2,
   readFileSync as readFileSync3,
+  readdirSync as readdirSync3,
   statSync as statSync3,
   writeFileSync as writeFileSync2
 } from "node:fs";
@@ -525,6 +526,45 @@ function readManifest(mapPath) {
   }
   return manifest;
 }
+function normalizePath(path) {
+  return path.split("\\").join("/");
+}
+function escapeRegExp(text) {
+  return text.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+}
+function globToRegExp(glob) {
+  let source = "^";
+  const pattern = normalizePath(glob);
+  for (let i = 0;i < pattern.length; i++) {
+    const char = pattern[i];
+    const next = pattern[i + 1];
+    if (char === "*" && next === "*") {
+      if (pattern[i + 2] === "/") {
+        source += "(?:.*/)?";
+        i += 2;
+      } else {
+        source += ".*";
+        i += 1;
+      }
+    } else if (char === "*") {
+      source += "[^/]*";
+    } else if (char === "?") {
+      source += "[^/]";
+    } else {
+      source += escapeRegExp(char);
+    }
+  }
+  return new RegExp(`${source}$`);
+}
+function getIncludeMatchers(include) {
+  if (!include)
+    return [];
+  return (Array.isArray(include) ? include : [include]).map(globToRegExp);
+}
+function matchesAny(path, matchers) {
+  const normalized = normalizePath(path);
+  return matchers.some((matcher) => matcher.test(normalized));
+}
 function replaceAtRange(content, token) {
   if (!token.range)
     return null;
@@ -645,11 +685,106 @@ function writeSkippedTemplate(templateRoot, skipped) {
   writeFileSync2(templatePath, content);
   return 1;
 }
+function dirnamePath(path) {
+  const normalized = normalizePath(path);
+  const index = normalized.lastIndexOf("/");
+  return index === -1 ? "" : normalized.slice(0, index);
+}
+function basenamePath(path) {
+  const normalized = normalizePath(path);
+  const index = normalized.lastIndexOf("/");
+  return index === -1 ? normalized : normalized.slice(index + 1);
+}
+function joinPath(...parts) {
+  return parts.filter((part) => part !== "").join("/");
+}
+function buildDirectoryMap(manifest) {
+  const mappings = new Map([["", ""]]);
+  function addMapping(outputDir, templateDir) {
+    const outputParts = normalizePath(outputDir).split("/").filter(Boolean);
+    const templateParts = normalizePath(templateDir).split("/").filter(Boolean);
+    for (let i = 1;i <= outputParts.length; i++) {
+      if (i <= templateParts.length) {
+        mappings.set(outputParts.slice(0, i).join("/"), templateParts.slice(0, i).join("/"));
+      }
+    }
+    mappings.set(normalizePath(outputDir), normalizePath(templateDir));
+  }
+  for (const file of manifest.files) {
+    const output = normalizePath(file.outputPath);
+    const template = normalizePath(file.templatePath);
+    addMapping(dirnamePath(output), dirnamePath(template));
+    if (file.tokens.some((token) => token.kind === "path"))
+      addMapping(output, template);
+  }
+  for (const skipped of manifest.skipped ?? []) {
+    if (skipped.kind === "directory")
+      continue;
+    addMapping(dirnamePath(skipped.templatePath), dirnamePath(skipped.templatePath));
+  }
+  return mappings;
+}
+function inferTemplatePath(outputPath, directoryMap) {
+  const normalized = normalizePath(outputPath);
+  const outputDir = dirnamePath(normalized);
+  let bestOutputDir = "";
+  let bestTemplateDir = "";
+  for (const [mappedOutputDir, mappedTemplateDir] of directoryMap) {
+    if (mappedOutputDir.length >= bestOutputDir.length && (outputDir === mappedOutputDir || outputDir.startsWith(`${mappedOutputDir}/`))) {
+      bestOutputDir = mappedOutputDir;
+      bestTemplateDir = mappedTemplateDir;
+    }
+  }
+  const suffix = bestOutputDir === "" ? outputDir : outputDir.slice(bestOutputDir.length).replace(/^\//, "");
+  return joinPath(bestTemplateDir, suffix, basenamePath(normalized));
+}
+function walkFiles(root, excludedRoots = []) {
+  const files = [];
+  const pending = [root];
+  while (pending.length > 0) {
+    const current = pending.pop();
+    for (const entry of readdirSync3(current).sort()) {
+      const path = resolvePath2(current, entry);
+      if (excludedRoots.some((excluded) => isInsidePath2(excluded, path)))
+        continue;
+      const stat = statSync3(path);
+      if (stat.isDirectory()) {
+        pending.push(path);
+      } else if (stat.isFile()) {
+        files.push(normalizePath(relative2(root, path)));
+      }
+    }
+  }
+  return files;
+}
+function copyIncludedRenderedFiles(renderedRoot, templateRoot, includedOutputPaths, directoryMap) {
+  let filesWritten = 0;
+  for (const outputPath of includedOutputPaths) {
+    const renderedPath = resolveInside(renderedRoot, outputPath);
+    const templatePath = resolveInside(templateRoot, inferTemplatePath(outputPath, directoryMap));
+    mkdirSync2(dirname2(templatePath), { recursive: true });
+    copyFileSync2(renderedPath, templatePath);
+    filesWritten += 1;
+  }
+  return filesWritten;
+}
+function getIncludedRenderedFiles(renderedRoot, templateRoot, mapPath, manifest, include) {
+  const matchers = getIncludeMatchers(include);
+  if (matchers.length === 0)
+    return [];
+  const mappedOutputPaths = new Set(manifest.files.map((file) => normalizePath(file.outputPath)));
+  const mapRelativePath = normalizePath(relative2(renderedRoot, mapPath));
+  return walkFiles(renderedRoot, [templateRoot]).filter((outputPath) => {
+    return outputPath !== mapRelativePath && !mappedOutputPaths.has(outputPath) && matchesAny(outputPath, matchers);
+  });
+}
 function reverseDir(renderedDir, templateDir, options = {}) {
   const renderedRoot = resolvePath2(renderedDir);
   const templateRoot = resolvePath2(templateDir);
   const mapPath = options.mapPath ? resolvePath2(renderedRoot, options.mapPath) : resolvePath2(renderedRoot, ".tdir-map.json");
   const manifest = readManifest(mapPath);
+  const directoryMap = buildDirectoryMap(manifest);
+  const includedOutputPaths = getIncludedRenderedFiles(renderedRoot, templateRoot, mapPath, manifest, options.include);
   const warnings = [];
   let filesWritten = 0;
   for (const file of manifest.files) {
@@ -684,6 +819,7 @@ function reverseDir(renderedDir, templateDir, options = {}) {
   for (const skipped of manifest.skipped ?? []) {
     filesWritten += writeSkippedTemplate(templateRoot, skipped);
   }
+  filesWritten += copyIncludedRenderedFiles(renderedRoot, templateRoot, includedOutputPaths, directoryMap);
   return { filesWritten, warnings };
 }
 

package/dist/reverse.d.ts

@@ -1,5 +1,6 @@
 export type ReverseOptions = {
     mapPath?: string;
+    include?: string | string[];
 };
 export type ReverseWarning = {
     outputPath: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gregorlohaus/tdir",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "license": "MIT",
   "type": "module",
   "main": "./dist/index.js",