@gregorlohaus/tdir 0.1.8 → 0.1.9

package/README.md

@@ -61,6 +61,8 @@ render("./output", {
 | `<@if(context.x)>` | Conditional block — boolean check (must end with `<@endif>`) |
 | `<@if(eq(context.x,"value"))>` | Conditional block — string equality check |
 | `<@if(neq(context.x,"value"))>` | Conditional block — string inequality check |
+| `<@if(and(context.x,eq(context.y,"value")))>` | Conditional block — all child conditions must match |
+| `<@if(or(context.x,eq(context.y,"value")))>` | Conditional block — any child condition may match |
 | `<@elseif(context.y)>` | Else-if branch (same forms as `@if`) |
 | `<@else>` | Else branch |
 | `<@endif>` | End conditional block |
@@ -74,6 +76,8 @@ render("./output", {
 | `<@if(context.x)>dirname` | Conditionally include directory/file (boolean check) |
 | `<@if(eq(context.x,"value"))>dirname` | Conditionally include by string equality |
 | `<@if(neq(context.x,"value"))>dirname` | Conditionally include by string inequality |
+| `<@if(and(context.x,eq(context.y,"value")))>dirname` | Conditionally include by combined conditions |
+| `<@if(or(context.x,eq(context.y,"value")))>dirname` | Conditionally include by alternate conditions |
 | `<@var(context.x)>` | Dynamic directory/file name |
 
 These can be combined: `<@if(context.web.create)><@var(context.web.dir)>` creates a directory named by `context.web.dir` only if `context.web.create` is true.

package/dist/index.js

@@ -5,14 +5,120 @@ import { z } from "zod";
 import { readdirSync, statSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { TextDecoder } from "node:util";
-var IF_RE = /<@(?:if|elseif)\((.+?)\)>/g;
+
+// scanner.ts
+function readCondition(text, start) {
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (let i = start;i < text.length; i++) {
+    const char = text[i];
+    if (escaped) {
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (char === '"') {
+      inString = !inString;
+      continue;
+    }
+    if (inString)
+      continue;
+    if (char === "(") {
+      depth += 1;
+      continue;
+    }
+    if (char === ")") {
+      depth -= 1;
+      if (depth === 0 && text[i + 1] === ">") {
+        return { condition: text.slice(start + 1, i), end: i + 2 };
+      }
+    }
+  }
+  return null;
+}
+function getDirectiveTokens(text) {
+  const tokens = [];
+  for (let i = 0;i < text.length; i++) {
+    if (text[i] !== "<" || text[i + 1] !== "@")
+      continue;
+    const rest = text.slice(i + 2);
+    const type = ["elseif", "endif", "else", "if"].find((name) => rest.startsWith(name));
+    if (!type)
+      continue;
+    const afterName = i + 2 + type.length;
+    if ((type === "if" || type === "elseif") && text[afterName] === "(") {
+      const parsed = readCondition(text, afterName);
+      if (!parsed)
+        continue;
+      tokens.push({ type, condition: parsed.condition, index: i, end: parsed.end });
+      i = parsed.end - 1;
+    } else if ((type === "else" || type === "endif") && text[afterName] === ">") {
+      tokens.push({ type, index: i, end: afterName + 1 });
+      i = afterName;
+    }
+  }
+  return tokens;
+}
+function splitArgs(args) {
+  const result = [];
+  let current = "";
+  let depth = 0;
+  let inString = false;
+  let escaped = false;
+  for (const char of args) {
+    if (escaped) {
+      current += char;
+      escaped = false;
+      continue;
+    }
+    if (char === "\\") {
+      current += char;
+      escaped = true;
+      continue;
+    }
+    if (char === '"') {
+      current += char;
+      inString = !inString;
+      continue;
+    }
+    if (!inString && char === "(")
+      depth += 1;
+    if (!inString && char === ")")
+      depth -= 1;
+    if (!inString && depth === 0 && char === ",") {
+      result.push(current.trim());
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  if (current.trim() !== "")
+    result.push(current.trim());
+  return result;
+}
+
+// parser.ts
 var VAR_RE = /<@var\(context\.(.+?)(?::(\w+))?\)>/g;
-var DIRECTIVE_RE = /<@(if|elseif|else|endif)(?:\((.+?)\))?>/g;
 var STRING_COMPARE_RE = /^(?:eq|neq)\(context\.(.+?),\s*"(.*)"\)$/;
 var PATH_RE = /^context\.(.+)$/;
 function extractCondition(expr, vars) {
   if (!expr)
     throw new Error("Missing condition expression");
+  for (const operator of ["and", "or"]) {
+    const prefix = `${operator}(`;
+    if (expr.startsWith(prefix) && expr.endsWith(")")) {
+      const args = splitArgs(expr.slice(prefix.length, -1));
+      if (args.length === 0)
+        throw new Error(`Invalid condition expression: ${expr}`);
+      for (const arg of args)
+        extractCondition(arg, vars);
+      return;
+    }
+  }
   const stringCompareMatch = expr.match(STRING_COMPARE_RE);
   if (stringCompareMatch) {
     vars.push({ path: stringCompareMatch[1], type: "string" });
@@ -26,8 +132,10 @@ function extractCondition(expr, vars) {
   throw new Error(`Invalid condition expression: ${expr}`);
 }
 function extractFromString(text, vars) {
-  for (const match of text.matchAll(IF_RE)) {
-    extractCondition(match[1], vars);
+  for (const token of getDirectiveTokens(text)) {
+    if (token.type === "if" || token.type === "elseif") {
+      extractCondition(token.condition, vars);
+    }
   }
   for (const match of text.matchAll(VAR_RE)) {
     vars.push({ path: match[1], type: match[2] ?? "string" });
@@ -35,9 +143,9 @@ function extractFromString(text, vars) {
 }
 function validateIfBlocks(content, vars) {
   const stack = [];
-  for (const match of content.matchAll(DIRECTIVE_RE)) {
-    const directive = match[1];
-    const condition = match[2];
+  for (const token of getDirectiveTokens(content)) {
+    const directive = token.type;
+    const condition = token.condition;
     if (directive === "if") {
       extractCondition(condition, vars);
       stack.push({ sawElse: false });
@@ -121,12 +229,20 @@ import { homedir } from "node:os";
 import { TextDecoder as TextDecoder2 } from "node:util";
 var IF_PATH_RE = /^<@if\((.+?)\)>(.*)$/;
 var VAR_RE2 = /<@var\(context\.(.+?)(?::(\w+))?\)>/g;
-var DIRECTIVE_RE2 = /<@(if|elseif|else|endif)(?:\((.+?)\))?>/g;
 var STRING_COMPARE_RE2 = /^(eq|neq)\(context\.(.+?),\s*"(.*)"\)$/;
 var PATH_RE2 = /^context\.(.+)$/;
 function evalCondition(expr, context) {
   if (!expr)
     throw new Error("Missing condition expression");
+  for (const operator of ["and", "or"]) {
+    const prefix = `${operator}(`;
+    if (expr.startsWith(prefix) && expr.endsWith(")")) {
+      const args = splitArgs(expr.slice(prefix.length, -1));
+      if (args.length === 0)
+        throw new Error(`Invalid condition expression: ${expr}`);
+      return operator === "and" ? args.every((arg) => evalCondition(arg, context)) : args.some((arg) => evalCondition(arg, context));
+    }
+  }
   const stringCompareMatch = expr.match(STRING_COMPARE_RE2);
   if (stringCompareMatch) {
     const result = resolveContext(context, stringCompareMatch[2]) === stringCompareMatch[3];
@@ -240,14 +356,6 @@ function isUtf8Text2(buffer) {
     return false;
   }
 }
-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) {

package/dist/scanner.d.ts

@@ -0,0 +1,8 @@
+export type DirectiveToken = {
+    type: "if" | "elseif" | "else" | "endif";
+    condition?: string;
+    index: number;
+    end: number;
+};
+export declare function getDirectiveTokens(text: string): DirectiveToken[];
+export declare function splitArgs(args: string): string[];

package/package.json

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