@stll/template-conditions 0.5.4 → 0.6.2

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

@@ -15,14 +15,14 @@ import { Temporal } from "temporal-polyfill/full";
 * (`parties.1.name`), and rejecting arrays would silently resolve those to
 * `undefined`.
 */
-const isRecord = (v) => typeof v === "object" && v !== null;
+const isNonNullObject = (v) => typeof v === "object" && v !== null;
 /** Resolve a dotted path like `company.name` against data. */
 const resolvePath = (path, data) => {
 	if (Object.hasOwn(data, path)) return data[path];
 	const parts = path.split(".");
 	let current = data;
 	for (const part of parts) {
-		if (!isRecord(current)) return;
+		if (!isNonNullObject(current)) return;
 		current = current[part];
 	}
 	return current;
@@ -55,6 +55,14 @@ const NUMERIC_FUNCTION_NAMES = Object.freeze([
 	"ceil"
 ]);
 const isNumericFunctionName = (name) => NUMERIC_FUNCTION_NAMES.some((candidate) => candidate === name);
+const OPERATORS = [
+	"+",
+	"-",
+	"*",
+	"/",
+	"%"
+];
+const isOperator = (value) => OPERATORS.some((candidate) => candidate === value);
 const TOKEN_RE = /(?<numeric>[0-9][0-9_]*(?:\.[0-9]+)?)|(?<ident>[\p{L}_][\p{L}\p{N}_.]*(?:-[\p{L}\p{N}_.]+)*)|(?<punct>[+\-*/%(),])|(?<invalid>\S)/gu;
 const PRECEDENCE = {
 	"+": 1,
@@ -79,7 +87,7 @@ const tokenize$1 = (expression) => {
 		else if (punct === "(") tokens.push({ t: "lp" });
 		else if (punct === ")") tokens.push({ t: "rp" });
 		else if (punct === ",") tokens.push({ t: "comma" });
-		else if (punct !== void 0) tokens.push({
+		else if (punct !== void 0 && isOperator(punct)) tokens.push({
 			t: "op",
 			v: punct
 		});
@@ -208,7 +216,7 @@ const RESERVED_WORDS = new Set(CONDITION_RESERVED_WORDS);
 const isConditionKeyword = (raw) => raw !== "true" && raw !== "false" && RESERVED_WORDS.has(raw);
 /** The keyword alternation of the tokenizer, derived from the same list. */
 const KEYWORD_PATTERN = CONDITION_RESERVED_WORDS.filter(isConditionKeyword).map((word) => String.raw`${word}\b`).join("|");
-const COMPARE_SYMBOL_PATTERN = Object.keys(COMPARE_SYMBOL_TO_OP).sort((left, right) => right.length - left.length).map(escapeRegexLiteral).join("|");
+const COMPARE_SYMBOL_PATTERN = Object.keys(COMPARE_SYMBOL_TO_OP).toSorted((left, right) => right.length - left.length).map(escapeRegexLiteral).join("|");
 const NON_STRING_TOKEN_RE = new RegExp(String.raw`(?<token>${COMPARE_SYMBOL_PATTERN}|${KEYWORD_PATTERN}|[()]|-?\d[\p{N}_.]*|[\p{L}\p{N}_.]+(?:-[\p{L}\p{N}_.]+)*)`, "uy");
 const STARTS_WITH_DIGIT_RE = /^-?\d/u;
 const isCompareSymbol = (raw) => Object.hasOwn(COMPARE_SYMBOL_TO_OP, raw);
@@ -945,6 +953,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 +986,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 +1508,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.2",
   "description": "A document-template marker and condition engine: {{...}} marker grammar, parse, compute, serialize, field values.",
   "keywords": [
     "condition",
@@ -43,7 +43,7 @@
     "test": "bun test",
     "test:property": "bun test --preload @stll/property-testing/preload $(grep -rlF 'fc.assert' src --include='*.test.ts')",
     "typecheck": "bun ../../packages/scripts/src/tsc-native.ts --noEmit",
-    "lint": "cd ../.. && bun --bun oxlint -c oxlint.config.ts --report-unused-disable-directives-severity=error --deny-warnings --type-aware packages/template-conditions",
+    "lint": "cd ../.. && bun --bun oxlint -c oxlint.config.ts --report-unused-disable-directives-severity=error --type-aware packages/template-conditions",
     "lint:fix": "cd ../.. && bun --bun oxlint -c oxlint.config.ts --type-aware --fix packages/template-conditions",
     "format": "bun ../../scripts/run-oxfmt.ts .",
     "prepack": "bun run build"
@@ -51,13 +51,13 @@
   "dependencies": {
     "@stll/conditions": "^0.4.0",
     "better-result": "3.0.1",
-    "temporal-polyfill": "1.0.4"
+    "temporal-polyfill": "1.0.5"
   },
   "devDependencies": {
     "@stll/property-testing": "0.0.0",
     "@stll/typescript-config": "0.0.0",
     "bun-types": "1.4.2",
-    "fast-check": "^4.9.0",
+    "fast-check": "^4.10.1",
     "tsdown": "0.23.0"
   },
   "main": "./dist/index.js",