npm - @gregorlohaus/tdir - Versions diffs - 0.1.3 → 0.1.5 - Mend

@gregorlohaus/tdir 0.1.3 → 0.1.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/README.md CHANGED Viewed

@@ -142,7 +142,7 @@ Pass a string to choose a custom JSON path inside the output directory:
 render("./output", context, { reverseMap: "meta/reverse-map.json" })
 ```
-The map contains a flat lookup from rendered strings to template tokens plus per-file occurrences with path/range context:
+The map contains a flat lookup from rendered strings to template tokens, per-file occurrences with path/range context, inline conditional blocks, and template files skipped by path conditionals:
 ```json
 {
@@ -160,10 +160,27 @@ The map contains a flat lookup from rendered strings to template tokens plus per
           "outputPath": "web/index.html",
           "templatePath": "<@if(context.web)>web/index.html",
           "range": { "start": 16, "end": 21 }
+        },
+        {
+          "kind": "conditional",
+          "result": "<head><@var(context.header.title)></head>",
+          "token": "<@if(context.header.show)><head><@var(context.header.title)></head><@endif>",
+          "outputPath": "web/index.html",
+          "templatePath": "<@if(context.web)>web/index.html",
+          "range": { "start": 9, "end": 53 },
+          "activeRange": { "start": 27, "end": 71 }
         }
       ]
     }
   ],
+  "skipped": [
+    {
+      "kind": "file",
+      "templatePath": "<@if(context.docs)>docs/readme.md",
+      "encoding": "utf8",
+      "content": "# Docs"
+    }
+  ],
   "tokens": {
     "Hello": ["<@var(context.header.title)>"]
   }
@@ -191,7 +208,22 @@ tdir reverse ./output ./templates --map meta/reverse-map.json
 bunx @gregorlohaus/tdir reverse ./output ./templates --map meta/reverse-map.json
 ```
-The command writes files at their original template paths and restores recorded `<@var(...)>` tokens in file contents and file paths. It does not infer conditional blocks that were removed during rendering; keep the original template structure when those blocks need to be preserved.
+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.
 ## Unmatched directives

package/dist/cli.js CHANGED Viewed

@@ -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;
@@ -55,10 +95,66 @@ function replaceFirst(content, token) {
     return null;
   return `${content.slice(0, index)}${token.token}${content.slice(index + token.result.length)}`;
 }
+function applyActiveBranch(token, branchContent) {
+  if (!token.activeRange)
+    return token.token;
+  return [
+    token.token.slice(0, token.activeRange.start),
+    branchContent,
+    token.token.slice(token.activeRange.end)
+  ].join("");
+}
+function findPrefixEnd(content, before) {
+  if (before === "")
+    return 0;
+  let candidate = before;
+  while (candidate.length >= 8) {
+    const index = content.indexOf(candidate);
+    if (index !== -1)
+      return index + candidate.length;
+    candidate = candidate.slice(-Math.max(1, Math.floor(candidate.length / 2)));
+  }
+  return -1;
+}
+function findSuffixStart(content, after, from) {
+  if (after === "")
+    return content.length;
+  let candidate = after;
+  while (candidate.length >= 8) {
+    const index = content.indexOf(candidate, from);
+    if (index !== -1)
+      return index;
+    candidate = candidate.slice(0, Math.floor(candidate.length / 2));
+  }
+  return -1;
+}
+function replaceConditional(content, token) {
+  const exactIndex = content.indexOf(token.result);
+  if (exactIndex !== -1) {
+    return [
+      content.slice(0, exactIndex),
+      token.token,
+      content.slice(exactIndex + token.result.length)
+    ].join("");
+  }
+  if (token.before === undefined || token.after === undefined)
+    return null;
+  const branchStart = findPrefixEnd(content, token.before);
+  if (branchStart === -1)
+    return null;
+  const afterIndex = findSuffixStart(content, token.after, branchStart);
+  if (afterIndex === -1)
+    return null;
+  return [
+    content.slice(0, branchStart),
+    applyActiveBranch(token, content.slice(branchStart, afterIndex)),
+    content.slice(afterIndex)
+  ].join("");
+}
 function reverseContent(content, file, warnings) {
-  const tokens = file.tokens.filter((token) => token.kind === "content").sort((a, b) => (b.range?.start ?? -1) - (a.range?.start ?? -1));
+  const contentTokens = file.tokens.filter((token) => token.kind === "content").sort((a, b) => (b.range?.start ?? -1) - (a.range?.start ?? -1));
   let reversed = content;
-  for (const token of tokens) {
+  for (const token of contentTokens) {
     const rangeResult = replaceAtRange(reversed, token);
     if (rangeResult !== null) {
       reversed = rangeResult;
@@ -76,8 +172,122 @@ function reverseContent(content, file, warnings) {
       message: "Rendered value was not found; token was not restored"
     });
   }
+  const conditionalTokens = file.tokens.filter((token) => token.kind === "conditional").sort((a, b) => (b.range?.start ?? -1) - (a.range?.start ?? -1));
+  for (const token of conditionalTokens) {
+    const result = replaceConditional(reversed, token);
+    if (result !== null) {
+      reversed = result;
+      continue;
+    }
+    warnings.push({
+      outputPath: file.outputPath,
+      token: token.token,
+      result: token.result,
+      message: "Rendered conditional block was not found; block was not restored"
+    });
+  }
   return reversed;
 }
+function writeSkippedTemplate(templateRoot, skipped) {
+  const templatePath = resolveInside(templateRoot, skipped.templatePath);
+  if (skipped.kind === "directory") {
+    mkdirSync(templatePath, { recursive: true });
+    return 0;
+  }
+  mkdirSync(dirname(templatePath), { recursive: true });
+  const content = skipped.encoding === "base64" ? Buffer.from(skipped.content ?? "", "base64") : skipped.content ?? "";
+  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, current = root) {
+  const files = [];
+  for (const entry of readdirSync(current).sort()) {
+    const path = resolvePath(current, entry);
+    const stat = statSync(path);
+    if (stat.isDirectory()) {
+      files.push(...walkFiles(root, path));
+    } else if (stat.isFile()) {
+      files.push(normalizePath(relative(root, path)));
+    }
+  }
+  return files;
+}
+function copyIncludedRenderedFiles(renderedRoot, templateRoot, mapPath, manifest, include) {
+  const matchers = getIncludeMatchers(include);
+  if (matchers.length === 0)
+    return 0;
+  const mappedOutputPaths = new Set(manifest.files.map((file) => normalizePath(file.outputPath)));
+  const mapRelativePath = normalizePath(relative(renderedRoot, mapPath));
+  const directoryMap = buildDirectoryMap(manifest);
+  let filesWritten = 0;
+  for (const outputPath of walkFiles(renderedRoot)) {
+    if (outputPath === mapRelativePath)
+      continue;
+    if (mappedOutputPaths.has(outputPath))
+      continue;
+    if (!matchesAny(outputPath, matchers))
+      continue;
+    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 reverseDir(renderedDir, templateDir, options = {}) {
   const renderedRoot = resolvePath(renderedDir);
   const templateRoot = resolvePath(templateDir);
@@ -114,6 +324,10 @@ function reverseDir(renderedDir, templateDir, options = {}) {
     writeFileSync(templatePath, reverseContent(content.toString("utf-8"), file, warnings));
     filesWritten += 1;
   }
+  for (const skipped of manifest.skipped ?? []) {
+    filesWritten += writeSkippedTemplate(templateRoot, skipped);
+  }
+  filesWritten += copyIncludedRenderedFiles(renderedRoot, templateRoot, mapPath, manifest, options.include);
   return { filesWritten, warnings };
 }
@@ -122,7 +336,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
@@ -130,16 +344,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];
@@ -148,9 +364,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;
@@ -168,9 +391,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.d.ts CHANGED Viewed

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { type RenderOptions } from "./render";
-export type { RenderOptions, ReverseMapFile, ReverseMapManifest, ReverseMapToken } from "./render";
+export type { RenderOptions, ReverseMapFile, ReverseMapManifest, ReverseMapStoredTemplate, ReverseMapToken } from "./render";
 export { reverseDir, type ReverseOptions, type ReverseResult, type ReverseWarning } from "./reverse";
 interface Stringable {
     toString: () => string;

package/dist/index.js CHANGED Viewed

@@ -175,7 +175,7 @@ function resolveOutputPath(destRoot, outputName) {
   return outputPath;
 }
 function createReverseMapManifest() {
-  return { version: 1, files: [], tokens: {} };
+  return { version: 1, files: [], skipped: [], tokens: {} };
 }
 function addReverseMapToken(state, file, token) {
   if (!state?.manifest || !file)
@@ -231,69 +231,131 @@ function isUtf8Text2(buffer) {
     return false;
   }
 }
-function processIfBlocks(content, context) {
-  let result = "";
-  let pos = 0;
-  const stack = [];
-  const re = new RegExp(DIRECTIVE_RE2.source, "g");
-  let match;
-  function isEmitting() {
-    return stack.every((f) => f.active);
-  }
-  while ((match = re.exec(content)) !== null) {
-    const directive = match[1];
-    const condPath = match[2];
-    if (directive === "if") {
-      if (isEmitting())
-        result += content.slice(pos, match.index);
-      const truthy = evalCondition(condPath, context);
-      stack.push({ matched: truthy, active: truthy, sawElse: false });
-      pos = re.lastIndex;
-    } else if (directive === "elseif") {
-      if (stack.length === 0)
-        throw new Error("Unexpected <@elseif> without <@if>");
-      const top = stack[stack.length - 1];
-      if (top.sawElse)
-        throw new Error("Unexpected <@elseif> after <@else>");
-      if (isEmitting())
-        result += content.slice(pos, match.index);
-      if (top.matched) {
-        top.active = false;
-      } else {
-        const truthy = evalCondition(condPath, context);
-        top.matched = truthy;
-        top.active = truthy;
-      }
-      pos = re.lastIndex;
-    } else if (directive === "else") {
-      if (stack.length === 0)
-        throw new Error("Unexpected <@else> without <@if>");
-      const top = stack[stack.length - 1];
-      if (top.sawElse)
-        throw new Error("Unexpected duplicate <@else>");
-      if (isEmitting())
-        result += content.slice(pos, match.index);
-      top.active = !top.matched;
-      top.matched = true;
-      top.sawElse = true;
-      pos = re.lastIndex;
-    } else if (directive === "endif") {
-      if (stack.length === 0)
-        throw new Error("Unexpected <@endif> without <@if>");
-      if (isEmitting())
-        result += content.slice(pos, match.index);
-      stack.pop();
-      pos = re.lastIndex;
+function getDirectiveTokens(content) {
+  return Array.from(content.matchAll(DIRECTIVE_RE2), (match) => ({
+    type: match[1],
+    condition: match[2],
+    index: match.index,
+    end: match.index + match[0].length
+  }));
+}
+function parseNodes(content, tokens, tokenIndex, pos, stopTypes) {
+  const nodes = [];
+  while (tokenIndex < tokens.length) {
+    const token = tokens[tokenIndex];
+    if (stopTypes.includes(token.type)) {
+      if (token.index > pos)
+        nodes.push({ type: "text", text: content.slice(pos, token.index) });
+      return { nodes, pos: token.index, tokenIndex, stop: token };
+    }
+    if (token.type !== "if") {
+      throw new Error(`Unexpected <@${token.type}> without <@if>`);
+    }
+    if (token.index > pos)
+      nodes.push({ type: "text", text: content.slice(pos, token.index) });
+    const parsed = parseIfNode(content, tokens, tokenIndex);
+    nodes.push(parsed.node);
+    tokenIndex = parsed.tokenIndex;
+    pos = parsed.pos;
+  }
+  if (pos < content.length)
+    nodes.push({ type: "text", text: content.slice(pos) });
+  return { nodes, pos: content.length, tokenIndex };
+}
+function parseIfNode(content, tokens, tokenIndex) {
+  const firstToken = tokens[tokenIndex];
+  const sourceStart = firstToken.index;
+  const branches = [];
+  let branchType = "if";
+  let branchCondition = firstToken.condition;
+  let branchContentStart = firstToken.end;
+  tokenIndex += 1;
+  while (true) {
+    const parsed = parseNodes(content, tokens, tokenIndex, branchContentStart, ["elseif", "else", "endif"]);
+    if (!parsed.stop)
+      throw new Error("Unmatched <@if> without <@endif>");
+    branches.push({
+      type: branchType,
+      condition: branchCondition,
+      nodes: parsed.nodes,
+      contentStart: branchContentStart,
+      contentEnd: parsed.pos
+    });
+    if (parsed.stop.type === "endif") {
+      const sourceEnd = parsed.stop.end;
+      return {
+        node: {
+          type: "if",
+          sourceStart,
+          sourceEnd,
+          source: content.slice(sourceStart, sourceEnd),
+          branches
+        },
+        pos: sourceEnd,
+        tokenIndex: parsed.tokenIndex + 1
+      };
     }
+    branchType = parsed.stop.type;
+    branchCondition = parsed.stop.condition;
+    branchContentStart = parsed.stop.end;
+    tokenIndex = parsed.tokenIndex + 1;
   }
-  if (stack.length > 0) {
-    throw new Error("Unmatched <@if> without <@endif>");
+}
+function getActiveBranch(node, context) {
+  for (const branch of node.branches) {
+    if (branch.type === "else" || evalCondition(branch.condition, context))
+      return branch;
+  }
+  return;
+}
+function renderNodes(nodes, context, conditionalTokens, outputStart = 0) {
+  let result = "";
+  for (const node of nodes) {
+    if (node.type === "text") {
+      result += node.text;
+      continue;
+    }
+    const activeBranch = getActiveBranch(node, context);
+    const start = outputStart + result.length;
+    const renderedBranch = activeBranch ? renderNodes(activeBranch.nodes, context, conditionalTokens, start) : "";
+    result += renderedBranch;
+    conditionalTokens.push({
+      result: renderedBranch,
+      token: node.source,
+      range: { start, end: start + renderedBranch.length },
+      activeRange: activeBranch ? {
+        start: activeBranch.contentStart - node.sourceStart,
+        end: activeBranch.contentEnd - node.sourceStart
+      } : { start: node.source.length, end: node.source.length }
+    });
   }
-  result += content.slice(pos);
   return result;
 }
+function processIfBlocksWithMap(content, context) {
+  const tokens = getDirectiveTokens(content);
+  const parsed = parseNodes(content, tokens, 0, 0, []);
+  const conditionalTokens = [];
+  return {
+    content: renderNodes(parsed.nodes, context, conditionalTokens),
+    conditionalTokens
+  };
+}
 function renderContentWithMap(content, context, state, file) {
-  const processed = processIfBlocks(content, context);
+  const processedResult = processIfBlocksWithMap(content, context);
+  const processed = processedResult.content;
+  for (const token of processedResult.conditionalTokens) {
+    addReverseMapToken(state, file, {
+      kind: "conditional",
+      result: token.result,
+      token: token.token,
+      outputPath: file?.outputPath ?? "",
+      templatePath: file?.templatePath ?? "",
+      range: token.range,
+      activeRange: token.activeRange,
+      before: processed.slice(0, token.range.start),
+      after: processed.slice(token.range.end)
+    });
+  }
   let result = "";
   let pos = 0;
   for (const match of processed.matchAll(VAR_RE2)) {
@@ -350,6 +412,37 @@ function validateOutputPaths(srcDir, destDir, context) {
     }
   }
 }
+function storeSkippedTemplate(srcPath, state) {
+  if (!state.manifest)
+    return;
+  const stat = statSync2(srcPath);
+  const templatePath = relative(state.sourceRoot, srcPath);
+  if (stat.isDirectory()) {
+    state.manifest.skipped.push({ kind: "directory", templatePath });
+    for (const entry of readdirSync2(srcPath).sort()) {
+      storeSkippedTemplate(resolvePath(srcPath, entry), state);
+    }
+    return;
+  }
+  if (!stat.isFile())
+    return;
+  const content = readFileSync2(srcPath);
+  if (isUtf8Text2(content)) {
+    state.manifest.skipped.push({
+      kind: "file",
+      templatePath,
+      encoding: "utf8",
+      content: content.toString("utf-8")
+    });
+  } else {
+    state.manifest.skipped.push({
+      kind: "file",
+      templatePath,
+      encoding: "base64",
+      content: content.toString("base64")
+    });
+  }
+}
 function renderDirInner(srcDir, destDir, context, state) {
   mkdirSync(destDir, { recursive: true });
   const entries = readdirSync2(srcDir).sort();
@@ -363,8 +456,10 @@ function renderDirInner(srcDir, destDir, context, state) {
       tokens: []
     };
     const outputName = getOutputName(entry, context, state, tempFile);
-    if (outputName === null)
+    if (outputName === null) {
+      storeSkippedTemplate(srcPath, state);
       continue;
+    }
     const destPath = resolveOutputPath(destDir, outputName);
     const outputPath = relative(state.destRoot, destPath);
     tempFile.outputPath = outputPath;
@@ -385,8 +480,8 @@ function renderDirInner(srcDir, destDir, context, state) {
       } else {
         copyFileSync(srcPath, destPath);
       }
-      if (tempFile.tokens.length > 0)
-        state.manifest?.files.push(tempFile);
+      if (state.manifest)
+        state.manifest.files.push(tempFile);
     }
   }
 }
@@ -397,6 +492,7 @@ import {
   existsSync,
   mkdirSync as mkdirSync2,
   readFileSync as readFileSync3,
+  readdirSync as readdirSync3,
   statSync as statSync3,
   writeFileSync as writeFileSync2
 } from "node:fs";
@@ -430,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;
@@ -446,10 +581,66 @@ function replaceFirst(content, token) {
     return null;
   return `${content.slice(0, index)}${token.token}${content.slice(index + token.result.length)}`;
 }
+function applyActiveBranch(token, branchContent) {
+  if (!token.activeRange)
+    return token.token;
+  return [
+    token.token.slice(0, token.activeRange.start),
+    branchContent,
+    token.token.slice(token.activeRange.end)
+  ].join("");
+}
+function findPrefixEnd(content, before) {
+  if (before === "")
+    return 0;
+  let candidate = before;
+  while (candidate.length >= 8) {
+    const index = content.indexOf(candidate);
+    if (index !== -1)
+      return index + candidate.length;
+    candidate = candidate.slice(-Math.max(1, Math.floor(candidate.length / 2)));
+  }
+  return -1;
+}
+function findSuffixStart(content, after, from) {
+  if (after === "")
+    return content.length;
+  let candidate = after;
+  while (candidate.length >= 8) {
+    const index = content.indexOf(candidate, from);
+    if (index !== -1)
+      return index;
+    candidate = candidate.slice(0, Math.floor(candidate.length / 2));
+  }
+  return -1;
+}
+function replaceConditional(content, token) {
+  const exactIndex = content.indexOf(token.result);
+  if (exactIndex !== -1) {
+    return [
+      content.slice(0, exactIndex),
+      token.token,
+      content.slice(exactIndex + token.result.length)
+    ].join("");
+  }
+  if (token.before === undefined || token.after === undefined)
+    return null;
+  const branchStart = findPrefixEnd(content, token.before);
+  if (branchStart === -1)
+    return null;
+  const afterIndex = findSuffixStart(content, token.after, branchStart);
+  if (afterIndex === -1)
+    return null;
+  return [
+    content.slice(0, branchStart),
+    applyActiveBranch(token, content.slice(branchStart, afterIndex)),
+    content.slice(afterIndex)
+  ].join("");
+}
 function reverseContent(content, file, warnings) {
-  const tokens = file.tokens.filter((token) => token.kind === "content").sort((a, b) => (b.range?.start ?? -1) - (a.range?.start ?? -1));
+  const contentTokens = file.tokens.filter((token) => token.kind === "content").sort((a, b) => (b.range?.start ?? -1) - (a.range?.start ?? -1));
   let reversed = content;
-  for (const token of tokens) {
+  for (const token of contentTokens) {
     const rangeResult = replaceAtRange(reversed, token);
     if (rangeResult !== null) {
       reversed = rangeResult;
@@ -467,8 +658,122 @@ function reverseContent(content, file, warnings) {
       message: "Rendered value was not found; token was not restored"
     });
   }
+  const conditionalTokens = file.tokens.filter((token) => token.kind === "conditional").sort((a, b) => (b.range?.start ?? -1) - (a.range?.start ?? -1));
+  for (const token of conditionalTokens) {
+    const result = replaceConditional(reversed, token);
+    if (result !== null) {
+      reversed = result;
+      continue;
+    }
+    warnings.push({
+      outputPath: file.outputPath,
+      token: token.token,
+      result: token.result,
+      message: "Rendered conditional block was not found; block was not restored"
+    });
+  }
   return reversed;
 }
+function writeSkippedTemplate(templateRoot, skipped) {
+  const templatePath = resolveInside(templateRoot, skipped.templatePath);
+  if (skipped.kind === "directory") {
+    mkdirSync2(templatePath, { recursive: true });
+    return 0;
+  }
+  mkdirSync2(dirname2(templatePath), { recursive: true });
+  const content = skipped.encoding === "base64" ? Buffer.from(skipped.content ?? "", "base64") : skipped.content ?? "";
+  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, current = root) {
+  const files = [];
+  for (const entry of readdirSync3(current).sort()) {
+    const path = resolvePath2(current, entry);
+    const stat = statSync3(path);
+    if (stat.isDirectory()) {
+      files.push(...walkFiles(root, path));
+    } else if (stat.isFile()) {
+      files.push(normalizePath(relative2(root, path)));
+    }
+  }
+  return files;
+}
+function copyIncludedRenderedFiles(renderedRoot, templateRoot, mapPath, manifest, include) {
+  const matchers = getIncludeMatchers(include);
+  if (matchers.length === 0)
+    return 0;
+  const mappedOutputPaths = new Set(manifest.files.map((file) => normalizePath(file.outputPath)));
+  const mapRelativePath = normalizePath(relative2(renderedRoot, mapPath));
+  const directoryMap = buildDirectoryMap(manifest);
+  let filesWritten = 0;
+  for (const outputPath of walkFiles(renderedRoot)) {
+    if (outputPath === mapRelativePath)
+      continue;
+    if (mappedOutputPaths.has(outputPath))
+      continue;
+    if (!matchesAny(outputPath, matchers))
+      continue;
+    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 reverseDir(renderedDir, templateDir, options = {}) {
   const renderedRoot = resolvePath2(renderedDir);
   const templateRoot = resolvePath2(templateDir);
@@ -505,6 +810,10 @@ function reverseDir(renderedDir, templateDir, options = {}) {
     writeFileSync2(templatePath, reverseContent(content.toString("utf-8"), file, warnings));
     filesWritten += 1;
   }
+  for (const skipped of manifest.skipped ?? []) {
+    filesWritten += writeSkippedTemplate(templateRoot, skipped);
+  }
+  filesWritten += copyIncludedRenderedFiles(renderedRoot, templateRoot, mapPath, manifest, options.include);
   return { filesWritten, warnings };
 }

package/dist/render.d.ts CHANGED Viewed

@@ -1,5 +1,5 @@
 export type ReverseMapToken = {
-    kind: "path" | "content";
+    kind: "path" | "content" | "conditional";
     result: string;
     token: string;
     contextPath?: string;
@@ -9,15 +9,28 @@ export type ReverseMapToken = {
         start: number;
         end: number;
     };
+    activeRange?: {
+        start: number;
+        end: number;
+    };
+    before?: string;
+    after?: string;
 };
 export type ReverseMapFile = {
     outputPath: string;
     templatePath: string;
     tokens: ReverseMapToken[];
 };
+export type ReverseMapStoredTemplate = {
+    kind: "directory" | "file";
+    templatePath: string;
+    encoding?: "utf8" | "base64";
+    content?: string;
+};
 export type ReverseMapManifest = {
     version: 1;
     files: ReverseMapFile[];
+    skipped: ReverseMapStoredTemplate[];
     tokens: Record<string, string[]>;
 };
 export type RenderOptions = {

package/dist/reverse.d.ts CHANGED Viewed

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

package/package.json CHANGED Viewed

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