@stll/template-conditions 0.5.4 → 0.6.0

package/dist/index.d.ts

@@ -181,9 +181,14 @@ type MarkerMeta = {
 } | {
   kind: "if";
   expr: string;
+  /** Filters on a tag whose whole body is one field path configure THAT
+   *  boolean: a question the document only asks has no value marker to
+   *  carry a chain. A tag holding a real expression carries none. */
+  filters: readonly FilterCall[];
 } | {
   kind: "elif";
   expr: string;
+  filters: readonly FilterCall[];
 } | {
   kind: "else";
 } | {
@@ -525,17 +530,24 @@ type ConditionTagOptions = {
   kind: "if" | "elif";
   /** The `{% if %}` expression, already serialized. */
   expression: string;
+  /** The chain the boolean this tag names carries. Only a tag whose whole
+   *  expression is one field path reads one back, so an expression tag writes
+   *  none. */
+  filters: readonly FilterCall[];
   /** The placement the tag already carried. */
   prefix: MarkerPrefix;
 };
 /**
- * One `{% if %}` / `{% elif %}` opener carrying its expression.
+ * One `{% if %}` / `{% elif %}` opener carrying its expression, and the field
+ * configuration of the boolean it asks for.
  *
  * A rule that decides whether a block shows belongs in the tag that shows it:
  * the tag is the only place a document has for it, so a builder's rule is
- * serialized here rather than stored beside the document under a name.
+ * serialized here rather than stored beside the document under a name. The
+ * same is true of what to call the question and how to decide it: a condition
+ * the document never prints has no value marker to hold that chain either.
  */
-export declare const renderConditionTag: ({ expression, kind, prefix }: ConditionTagOptions) => string;
+export declare const renderConditionTag: ({ expression, filters, kind, prefix }: ConditionTagOptions) => string;
 type ForOpenerOptions = {
   alias: string;
   path: string;

package/dist/index.js

@@ -945,6 +945,32 @@ const readPrefix = (token) => token === "p" || token === "tr" ? PREFIX_BY_TOKEN[
 const TAG_RE = /^(?<tag>[\p{L}_][\p{L}\p{N}_]*)\b(?<rest>[\s\S]*)$/u;
 const FOR_RE = /^(?<alias>[\p{L}_][\p{L}\p{N}_-]*)\s+in\s+(?<path>[\p{L}\p{N}_.-]+)\s*(?<filters>\|[\s\S]*)?$/u;
 const CALL_RE = /^(?<name>[\p{L}_][\p{L}\p{N}_]*)\s*\(/u;
+const CONDITION_RE = /^(?<path>[\p{L}\p{N}_.-]+)\s*(?<filters>\|[\s\S]*)$/u;
+/**
+* Read an `{% if %}` / `{% elif %}` body: one field path plus the chain that
+* configures the boolean it names, or an expression the author wrote.
+*
+* A tail the filter catalogue does not read is part of that expression
+* (`items|length > 0`), never a configuration, so the body stays verbatim
+* rather than being rejected: a tag the grammar refuses would take its whole
+* block with it.
+*/
+const readConditionBody = (rest) => {
+	const match = CONDITION_RE.exec(rest);
+	if (!match) return {
+		expr: rest,
+		filters: []
+	};
+	const chain = scanFilterChain(match.groups?.["filters"] ?? "");
+	if (chain === null || "unknownFilter" in chain || chain.filters.length === 0) return {
+		expr: rest,
+		filters: []
+	};
+	return {
+		expr: match.groups?.["path"] ?? rest,
+		filters: chain.filters
+	};
+};
 /** Classify a `{% ... %}` tag. */
 const classifyStatement = (inner) => {
 	const match = TAG_RE.exec(inner);
@@ -952,14 +978,22 @@ const classifyStatement = (inner) => {
 	const tag = match.groups?.["tag"] ?? "";
 	const rest = (match.groups?.["rest"] ?? "").trim();
 	switch (tag) {
-		case "if": return {
-			kind: "if",
-			expr: rest
-		};
-		case "elif": return {
-			kind: "elif",
-			expr: rest
-		};
+		case "if": {
+			const { expr, filters } = readConditionBody(rest);
+			return {
+				kind: "if",
+				expr,
+				filters
+			};
+		}
+		case "elif": {
+			const { expr, filters } = readConditionBody(rest);
+			return {
+				kind: "elif",
+				expr,
+				filters
+			};
+		}
 		case "else": return rest === "" ? { kind: "else" } : null;
 		case "endif": return rest === "" ? { kind: "endif" } : null;
 		case "endfor": return rest === "" ? { kind: "endfor" } : null;
@@ -1466,13 +1500,20 @@ const PREFIX_TOKEN = {
 	row: "tr"
 };
 /**
-* One `{% if %}` / `{% elif %}` opener carrying its expression.
+* One `{% if %}` / `{% elif %}` opener carrying its expression, and the field
+* configuration of the boolean it asks for.
 *
 * A rule that decides whether a block shows belongs in the tag that shows it:
 * the tag is the only place a document has for it, so a builder's rule is
-* serialized here rather than stored beside the document under a name.
+* serialized here rather than stored beside the document under a name. The
+* same is true of what to call the question and how to decide it: a condition
+* the document never prints has no value marker to hold that chain either.
 */
-const renderConditionTag = ({ expression, kind, prefix }) => `{%${PREFIX_TOKEN[prefix]} ${kind} ${expression} %}`;
+const renderConditionTag = ({ expression, filters, kind, prefix }) => {
+	const chain = renderFilterChain(filters);
+	const head = `{%${PREFIX_TOKEN[prefix]} ${kind} ${expression}`;
+	return chain === "" ? `${head} %}` : `${head} | ${chain} %}`;
+};
 /** One `{% for %}` opener, keeping its placement prefix. */
 const renderForOpener = ({ alias, filters, path, prefix }) => {
 	const chain = renderFilterChain(filters);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stll/template-conditions",
-  "version": "0.5.4",
+  "version": "0.6.0",
   "description": "A document-template marker and condition engine: {{...}} marker grammar, parse, compute, serialize, field values.",
   "keywords": [
     "condition",