@stll/template-conditions 0.5.3 → 0.6.0

package/dist/index.d.ts

@@ -1,13 +1,13 @@
 import { CompareNode, CompareOp, Condition, ConditionNode, ConditionNode as ConditionNode$1, GroupNode, Operand, PredicateNode, PredicateOp, conditionHasFormula, conditionNodeSchema, conditionSchema, emptyCondition } from "@stll/conditions";
 //#region src/path.d.ts
 /** Resolve a dotted path like `company.name` against data. */
-declare const resolvePath: (path: string, data: Record<string, unknown>) => unknown;
+export declare const resolvePath: (path: string, data: Record<string, unknown>) => unknown;
 //#endregion
 //#region src/parse.d.ts
 /** Bare words the tokenizer reads as operators or literals; a data path can
  *  never be one of them. */
-declare const CONDITION_RESERVED_WORDS: readonly ["and", "or", "not", "in", "is", "defined", "true", "false"];
-declare const parseCondition: (expression: string) => ConditionNode$1 | null;
+export declare const CONDITION_RESERVED_WORDS: readonly ["and", "or", "not", "in", "is", "defined", "true", "false"];
+export declare const parseCondition: (expression: string) => ConditionNode$1 | null;
 //#endregion
 //#region src/referenced-paths.d.ts
 /**
@@ -23,7 +23,7 @@ declare const parseCondition: (expression: string) => ConditionNode$1 | null;
  * deciding what a condition depends on must not read that as "depends on
  * nothing".
  */
-declare const referencedConditionPaths: (expression: string) => string[] | null;
+export declare const referencedConditionPaths: (expression: string) => string[] | null;
 //#endregion
 //#region src/compute.d.ts
 /**
@@ -43,9 +43,9 @@ declare const referencedConditionPaths: (expression: string) => string[] | null;
  * non-numeric variable, division producing a non-finite result) so callers
  * can fall back to leaving the field unfilled rather than emitting `NaN`.
  */
-declare const NUMERIC_FUNCTION_NAMES: readonly ["min", "max", "round", "abs", "floor", "ceil"];
+export declare const NUMERIC_FUNCTION_NAMES: readonly ["min", "max", "round", "abs", "floor", "ceil"];
 type NumericFunctionName = (typeof NUMERIC_FUNCTION_NAMES)[number];
-declare const evaluateNumericExpression: (expression: string, data: Record<string, unknown>) => number | undefined;
+export declare const evaluateNumericExpression: (expression: string, data: Record<string, unknown>) => number | undefined;
 //#endregion
 //#region src/field-values.d.ts
 /**
@@ -67,10 +67,10 @@ declare const evaluateNumericExpression: (expression: string, data: Record<strin
  * STRUCTURAL shapes so the package stays free of api/web imports; callers pass
  * their own field objects, which structurally satisfy these.
  */
-declare const DATE_FORMAT_STYLES: readonly ["long", "medium", "short", "iso"];
+export declare const DATE_FORMAT_STYLES: readonly ["long", "medium", "short", "iso"];
 type DateFormatStyle = (typeof DATE_FORMAT_STYLES)[number];
 /** Stable exemplar for date-format configuration previews. */
-declare const DATE_FORMAT_EXAMPLE_ISO = "2028-06-13";
+export declare const DATE_FORMAT_EXAMPLE_ISO = "2028-06-13";
 /** Locale-aware date rendering config. "iso" leaves the submitted value as-is;
  *  the other styles map to `Intl.DateTimeFormat` `dateStyle`. */
 type FieldDateFormat = {
@@ -85,7 +85,7 @@ type FieldDateFormat = {
  * 2028". The "iso" style returns the value unchanged; an invalid calendar date
  * returns null.
  */
-declare const formatDate: (value: string, dateFormat: FieldDateFormat) => string | null;
+export declare const formatDate: (value: string, dateFormat: FieldDateFormat) => string | null;
 /**
  * Minimal STRUCTURAL config of a field, carrying only what the deterministic
  * transforms read. Callers (api FieldMeta, web StudioField) structurally
@@ -112,7 +112,7 @@ type DeterministicFieldConfig = {
  * Formula and date return null when the expression or value does not yield a
  * value, so the caller leaves the field as-is.
  */
-declare const renderDeterministicFieldValue: (field: DeterministicFieldConfig, values: Record<string, unknown>) => string | null;
+export declare const renderDeterministicFieldValue: (field: DeterministicFieldConfig, values: Record<string, unknown>) => string | null;
 //#endregion
 //#region src/condition-builder.d.ts
 /**
@@ -120,7 +120,7 @@ declare const renderDeterministicFieldValue: (field: DeterministicFieldConfig, v
  * Returns an empty string for an empty tree (caller treats that as "no
  * condition" / always-visible).
  */
-declare const serializeCondition: (node: ConditionNode$1) => string;
+export declare const serializeCondition: (node: ConditionNode$1) => string;
 //#endregion
 //#region src/markers.d.ts
 /**
@@ -159,7 +159,7 @@ type FilterCall = {
   args: readonly FilterArgument[];
 };
 /** The loop properties addressable inside a `{% for %}` body. */
-declare const LOOP_PROPERTIES: readonly ["index", "index0", "first", "last", "length"];
+export declare const LOOP_PROPERTIES: readonly ["index", "index0", "first", "last", "length"];
 type LoopProperty = (typeof LOOP_PROPERTIES)[number];
 type MarkerMeta = {
   kind: "placeholder";
@@ -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";
 } | {
@@ -199,7 +204,7 @@ type MarkerMeta = {
   kind: "endfor";
 };
 type DirectiveKind = MarkerMeta["kind"];
-declare const DIRECTIVE_KINDS: readonly ["placeholder", "clause", "num", "ref", "loop", "if", "elif", "else", "endif", "for", "endfor"];
+export declare const DIRECTIVE_KINDS: readonly ["placeholder", "clause", "num", "ref", "loop", "if", "elif", "else", "endif", "for", "endfor"];
 declare const DIRECTIVE_PLACEMENT: {
   readonly placeholder: "inline";
   readonly clause: "inline";
@@ -215,19 +220,19 @@ declare const DIRECTIVE_PLACEMENT: {
 };
 type BlockDirectiveKind = { [TKind in DirectiveKind]: (typeof DIRECTIVE_PLACEMENT)[TKind] extends "block" ? TKind : never; }[DirectiveKind];
 /** Directives that occupy their own paragraph, in canonical grammar order. */
-declare const BLOCK_DIRECTIVE_KINDS: readonly ["if", "elif", "else", "endif", "for", "endfor"];
-declare const isBlockDirectiveKind: (kind: unknown) => kind is BlockDirectiveKind;
+export declare const BLOCK_DIRECTIVE_KINDS: readonly ["if", "elif", "else", "endif", "for", "endfor"];
+export declare const isBlockDirectiveKind: (kind: unknown) => kind is BlockDirectiveKind;
 /**
  * Every filter the dialect accepts on a fillable value. The names are the
  * grammar's; which manifest property each one writes is decided by the field
  * catalogue in the api, which is total over BOTH this list and the manifest
  * keys, so neither side can gain an entry the other has not decided.
  */
-declare const FILTER_NAMES: readonly ["text", "number", "date", "checkbox", "select", "options_from", "label", "hint", "required", "pattern", "min", "max", "min_length", "max_length", "min_items", "max_items", "ai", "lookup", "matter", "contact", "party", "attorney", "firm", "formula", "condition"];
+export declare const FILTER_NAMES: readonly ["text", "number", "date", "checkbox", "select", "options_from", "label", "hint", "required", "pattern", "min", "max", "min_length", "max_length", "min_items", "max_items", "ai", "lookup", "matter", "contact", "party", "attorney", "firm", "formula", "condition"];
 type FilterName = (typeof FILTER_NAMES)[number];
 /** Normalise one marker's inner text: typographic quotes become straight
  *  quotes, fixed-width spaces become ordinary ones. */
-declare const normalizeMarkerInner: (inner: string) => string;
+export declare const normalizeMarkerInner: (inner: string) => string;
 /**
  * What an output marker holds between its braces: anything but a brace or a
  * double quote, plus whole double-quoted arguments, whose braces are content
@@ -246,39 +251,39 @@ declare const normalizeMarkerInner: (inner: string) => string;
  * adversarial input: a `{{` with no closing `}}` costs one failed pass, not a
  * polynomial retry.
  */
-declare const MARKER_OUTPUT_BODY: string;
+export declare const MARKER_OUTPUT_BODY: string;
 /** What a tag holds between `{%` and `%}`: anything but a brace, and a `%`
  *  only where it does not close the tag. */
-declare const MARKER_STATEMENT_BODY: string;
+export declare const MARKER_STATEMENT_BODY: string;
 /**
  * Any marker span: an output `{{...}}` (group `output`) or a tag `{%...%}`
  * (group `statement`, with the docxtpl placement in group `prefix`).
  */
-declare const markerPattern: () => RegExp;
+export declare const markerPattern: () => RegExp;
 /** Inline value marker, including its filter chain; group `name` is the path
  *  the value comes from and group `filters` the untouched chain. */
-declare const placeholderPattern: () => RegExp;
+export declare const placeholderPattern: () => RegExp;
 /** `{{ clause("Name") }}` / `{{ clause("Name", "v3") }}`. */
-declare const clauseSlotPattern: () => RegExp;
+export declare const clauseSlotPattern: () => RegExp;
 /** `{{ num("key") }}` — the `key` group. */
-declare const numPattern: () => RegExp;
+export declare const numPattern: () => RegExp;
 /** `{{ ref("key") }}` — the `key` group. */
-declare const refPattern: () => RegExp;
+export declare const refPattern: () => RegExp;
 /** `{{ loop.index }}` and its siblings — the `property` group. */
-declare const loopPattern: () => RegExp;
+export declare const loopPattern: () => RegExp;
 /** Cheap presence test for any numbering marker (no capture). */
-declare const hasNumberingPattern: () => RegExp;
+export declare const hasNumberingPattern: () => RegExp;
 /** Cheap presence test for any tag (no capture). */
-declare const hasBlockDirectivePattern: () => RegExp;
+export declare const hasBlockDirectivePattern: () => RegExp;
 /** A whole line that is a single block tag — `prefix`, `tag` and `expr`. */
-declare const blockDirectiveLinePattern: () => RegExp;
+export declare const blockDirectiveLinePattern: () => RegExp;
 /** Whether `value` is a valid field path per the marker grammar (dotted
  *  segments of letters/digits/underscore/dash — no brackets or spaces). */
-declare const isFieldPath: (value: string) => boolean;
+export declare const isFieldPath: (value: string) => boolean;
 /** Whether `value` is safe to use as a dotted object path. */
-declare const isSafeFieldPath: (value: string) => boolean;
+export declare const isSafeFieldPath: (value: string) => boolean;
 /** Whether `value` is a valid name for authoring a `clause("NAME")` slot. */
-declare const isClauseSlotName: (value: string) => boolean;
+export declare const isClauseSlotName: (value: string) => boolean;
 /** Which brace pair carried the marker text. */
 type MarkerForm = "output" | "statement";
 /** Where a tag's docxtpl prefix says the tag belongs. `"none"` is a bare tag,
@@ -288,7 +293,7 @@ type MarkerPrefix = "none" | "paragraph" | "row";
  * Classify the inner text of one marker. Returns `null` when the text is not a
  * recognized directive (so a recognizer can leave stray braces alone).
  */
-declare const classifyMarker: (innerRaw: string, form?: MarkerForm) => MarkerMeta | null;
+export declare const classifyMarker: (innerRaw: string, form?: MarkerForm) => MarkerMeta | null;
 type ScannedMarker = {
   /** Offset of the opening brace pair in the source text. */
   start: number;
@@ -307,23 +312,23 @@ type ScannedMarker = {
  * Find every recognized marker in `text`, in document order, with offsets and
  * classified metadata. Unrecognized spans are skipped.
  */
-declare const scanMarkers: (text: string) => ScannedMarker[];
+export declare const scanMarkers: (text: string) => ScannedMarker[];
 /**
  * Rewrite every `{{ ... }}` output marker in `text` through `replace`, which
  * receives the whole marker and its raw inner text and returns the replacement.
  * Tags are left untouched. The single scan is the same one the classifier uses,
  * so a caller that rewrites marker text never needs its own regex.
  */
-declare const replaceOutputMarkers: (text: string, replace: (raw: string, inner: string) => string) => string;
+export declare const replaceOutputMarkers: (text: string, replace: (raw: string, inner: string) => string) => string;
 /**
  * The values-map key one marker substitutes from, or `null` when the marker is
  * not a substitution target (a tag, or a `loop.*` token the loop expander
  * resolves first). One function so the key discovery writes is the key the
  * patcher reads.
  */
-declare const substitutionKey: (meta: MarkerMeta) => string | null;
+export declare const substitutionKey: (meta: MarkerMeta) => string | null;
 /** The values-map key for one clause slot. */
-declare const clauseSlotKey: (name: string, version?: string) => string;
+export declare const clauseSlotKey: (name: string, version?: string) => string;
 /** A marker-shaped span that classifies to nothing. */
 type InvalidMarker = {
   /** Offset of the opening brace pair in the source text. */
@@ -342,20 +347,20 @@ type InvalidMarker = {
  * recognizer skips, so they print literally at fill time. This is the exact
  * complement of {@link scanMarkers}: a span is in one list or the other.
  */
-declare const scanInvalidMarkers: (text: string) => InvalidMarker[];
+export declare const scanInvalidMarkers: (text: string) => InvalidMarker[];
 /** The loop alias the codemod (and the legacy-marker message) generates for a
  *  `{{#each path}}`: the singular of the last plain-word segment, else `item`. */
-declare const legacyLoopAlias: (path: string) => string;
+export declare const legacyLoopAlias: (path: string) => string;
 /** Translate an old-dialect condition expression to the Jinja surface:
  *  `!a` becomes `not a`, `a contains "x"` becomes `"x" in a`. */
-declare const translateLegacyExpression: (expr: string) => string;
+export declare const translateLegacyExpression: (expr: string) => string;
 /**
  * The Jinja marker that replaces one old-dialect marker's inner text, or
  * `null` when the text is not old-dialect. Shared by the rejection message and
  * the codemod, so the fix an author is told to make is the fix the script
  * would have made.
  */
-declare const legacyMarkerReplacement: (innerRaw: string) => string | null;
+export declare const legacyMarkerReplacement: (innerRaw: string) => string | null;
 /**
  * Why a marker-shaped span misses the grammar in a way that names the
  * authoring mistake rather than merely failing to classify. Consumers derive
@@ -363,7 +368,7 @@ declare const legacyMarkerReplacement: (innerRaw: string) => string | null;
  * drift.
  */
 type MarkerDefectKind = "legacy_marker" | "unsupported_tag" | "unknown_filter" | "python_expression" | "bracket_index";
-declare const MARKER_DEFECT_KINDS: readonly ["legacy_marker", "unsupported_tag", "unknown_filter", "python_expression", "bracket_index"];
+export declare const MARKER_DEFECT_KINDS: readonly ["legacy_marker", "unsupported_tag", "unknown_filter", "python_expression", "bracket_index"];
 /** One diagnosis of a rejected span: the kind plus the construct to quote. */
 type MarkerDefect = {
   kind: MarkerDefectKind;
@@ -377,9 +382,9 @@ type MarkerDefect = {
  * the text is a recognized directive ({@link classifyMarker} accepts it) or an
  * unrecognizable span with no specific diagnosis (`{{my field}}`).
  */
-declare const classifyMarkerDefect: (innerRaw: string, form?: MarkerForm) => MarkerDefect | null;
+export declare const classifyMarkerDefect: (innerRaw: string, form?: MarkerForm) => MarkerDefect | null;
 /** Exhaustiveness guard — pass the discriminant in a `switch` default branch. */
-declare const assertNever: (value: never) => never;
+export declare const assertNever: (value: never) => never;
 //#endregion
 //#region src/loop-scope.d.ts
 /**
@@ -402,14 +407,14 @@ type RowScope = {
   /** The array path the manifest speaks, enclosing loops included. */
   scopedPath: string;
 };
-declare const rowScopePaths: (rowScopes: readonly RowScope[]) => string[];
+export declare const rowScopePaths: (rowScopes: readonly RowScope[]) => string[];
 /** A path already under the innermost repeat is left alone; anything else is
  *  read as a name relative to it. */
-declare const qualifyRowScopedPath: (path: string, rowPaths?: readonly string[]) => string;
+export declare const qualifyRowScopedPath: (path: string, rowPaths?: readonly string[]) => string;
 /** The manifest path for a marker written inside these loops. */
-declare const qualifyRowScopedPlaceholder: (path: string, rowScopes: readonly RowScope[]) => string;
+export declare const qualifyRowScopedPlaceholder: (path: string, rowScopes: readonly RowScope[]) => string;
 /** The manifest path for an array a `{% for %}` opens inside these loops. */
-declare const qualifyLoopPath: (declaredPath: string, rowScopes: readonly RowScope[]) => string;
+export declare const qualifyLoopPath: (declaredPath: string, rowScopes: readonly RowScope[]) => string;
 //#endregion
 //#region src/field-config.d.ts
 /** Where a field's value comes from, when a record supplies it. Only the shape
@@ -481,20 +486,20 @@ type MarkerFieldConfig = {
  * takes and what to call it. These are the ones a `{% for %}` tag may carry,
  * since the loop path names the array, not one of its values.
  */
-declare const ARRAY_FILTER_NAMES: readonly ["label", "hint", "required", "min_items", "max_items"];
-declare const isArrayFilterName: (name: FilterName) => boolean;
+export declare const ARRAY_FILTER_NAMES: readonly ["label", "hint", "required", "min_items", "max_items"];
+export declare const isArrayFilterName: (name: FilterName) => boolean;
 /**
  * The filter chain that declares this field in a document, in the catalogue's
  * own order so a chain the writer produces and one an author wrote read the
  * same.
  */
-declare const filtersFromFieldConfig: (field: MarkerFieldConfig) => FilterCall[];
+export declare const filtersFromFieldConfig: (field: MarkerFieldConfig) => FilterCall[];
 /**
  * The chain a `{% for %}` opener carries for this array: the repeat's own
  * filters and nothing else, derived from {@link ARRAY_FILTER_NAMES}, so a
  * value filter can never be written where the reader refuses it.
  */
-declare const arrayFiltersFromFieldConfig: (field: MarkerFieldConfig) => FilterCall[];
+export declare const arrayFiltersFromFieldConfig: (field: MarkerFieldConfig) => FilterCall[];
 //#endregion
 //#region src/render.d.ts
 /** Why a value has no spelling the scanner reads back as itself. */
@@ -502,12 +507,12 @@ type UnwritableReason = "tag-delimiter" | "number-spelling";
 /** The reason this literal cannot be written in a marker of this form, or
  *  `null` when it can. A boolean always can; a string can in a `{{ }}` marker,
  *  because the writer quotes and escapes it. */
-declare const unwritableMarkerLiteral: (value: MarkerLiteral, form?: MarkerForm) => UnwritableReason | null;
+export declare const unwritableMarkerLiteral: (value: MarkerLiteral, form?: MarkerForm) => UnwritableReason | null;
 /** Every value in a chain the grammar has no spelling for, with the filter it
  *  was written on and why, so a caller can refuse a configuration before it
  *  rewrites a document into something the scanner would read differently. A
  *  repeat's chain goes in a tag, so pass `"statement"` for one. */
-declare const unwritableFilterValues: (filters: readonly FilterCall[], form?: MarkerForm) => {
+export declare const unwritableFilterValues: (filters: readonly FilterCall[], form?: MarkerForm) => {
   filter: string;
   value: MarkerLiteral;
   reason: UnwritableReason;
@@ -517,25 +522,32 @@ declare const unwritableFilterValues: (filters: readonly FilterCall[], form?: Ma
  * required`. An empty chain renders the empty string, which is what a marker
  * that configures nothing carries.
  */
-declare const renderFilterChain: (filters: readonly FilterCall[]) => string;
+export declare const renderFilterChain: (filters: readonly FilterCall[]) => string;
 /** One value marker: `{{ path }}` or `{{ path | filters }}`. */
-declare const renderValueMarker: (path: string, filters: readonly FilterCall[]) => string;
+export declare const renderValueMarker: (path: string, filters: readonly FilterCall[]) => string;
 type ConditionTagOptions = {
   /** Which branch opener this is; `elif` keeps its place in the chain. */
   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.
  */
-declare const renderConditionTag: ({ expression, kind, prefix }: ConditionTagOptions) => string;
+export declare const renderConditionTag: ({ expression, filters, kind, prefix }: ConditionTagOptions) => string;
 type ForOpenerOptions = {
   alias: string;
   path: string;
@@ -545,7 +557,7 @@ type ForOpenerOptions = {
   prefix: MarkerPrefix;
 };
 /** One `{% for %}` opener, keeping its placement prefix. */
-declare const renderForOpener: ({ alias, filters, path, prefix }: ForOpenerOptions) => string;
+export declare const renderForOpener: ({ alias, filters, path, prefix }: ForOpenerOptions) => string;
 //#endregion
 //#region src/row-blocks.d.ts
 /** One end of a row block, addressed within the row that was scanned. */
@@ -573,10 +585,10 @@ type RowBlockPair = {
  * `{% else %}`, a pair wrapping the paragraphs of a single cell — is left to the
  * engine's existing structure errors rather than guessed at.
  */
-declare const detectRowBlockPair: (cells: readonly (readonly string[])[]) => RowBlockPair | null;
+export declare const detectRowBlockPair: (cells: readonly (readonly string[])[]) => RowBlockPair | null;
 //#endregion
 //#region src/index.d.ts
-type NamedCondition = {
+export type NamedCondition = {
   name: string;
   /** The `{% if %}` expression string. Authoritative unless `node` is set. */
   expression: string;
@@ -594,7 +606,7 @@ type NamedCondition = {
  * Prevents stack overflow when a long chain of named
  * conditions (A→B→C→...→Z) is evaluated without cycles.
  */
-declare const MAX_CONDITION_DEPTH = 50;
+export declare const MAX_CONDITION_DEPTH = 50;
 /**
  * Evaluate a template `{% if ... %}` condition. The expression is parsed into
  * the canonical `@stll/conditions` AST and evaluated by the shared evaluator.
@@ -607,6 +619,6 @@ declare const MAX_CONDITION_DEPTH = 50;
  * An empty or unparseable expression is `false` ("no condition" never gates a
  * branch true).
  */
-declare const evaluateCondition: (expression: string, data: Record<string, unknown>, namedConditions?: readonly NamedCondition[], _resolved?: ReadonlySet<string>, _depth?: number) => boolean;
+export declare const evaluateCondition: (expression: string, data: Record<string, unknown>, namedConditions?: readonly NamedCondition[], _resolved?: ReadonlySet<string>, _depth?: number) => boolean;
 //#endregion
-export { ARRAY_FILTER_NAMES, BLOCK_DIRECTIVE_KINDS, type BlockDirectiveKind, CONDITION_RESERVED_WORDS, type CompareNode, type CompareOp, type Condition, type ConditionNode, type ConditionTagOptions, DATE_FORMAT_EXAMPLE_ISO, DATE_FORMAT_STYLES, DIRECTIVE_KINDS, type DateFormatStyle, type DeterministicFieldConfig, type DirectiveKind, FILTER_NAMES, type FieldDateFormat, type FilterArgument, type FilterCall, type FilterName, type ForOpenerOptions, type GroupNode, type InvalidMarker, LOOP_PROPERTIES, type LoopProperty, MARKER_DEFECT_KINDS, MARKER_OUTPUT_BODY, MARKER_STATEMENT_BODY, MAX_CONDITION_DEPTH, type MarkerDefect, type MarkerDefectKind, type MarkerFieldConfig, type MarkerFieldInputType, type MarkerFieldLookup, type MarkerFieldSource, type MarkerFieldValidation, type MarkerForm, type MarkerLiteral, type MarkerMeta, type MarkerPrefix, NUMERIC_FUNCTION_NAMES, NamedCondition, type NumericFunctionName, type Operand, type PredicateNode, type PredicateOp, type RowBlockMarker, type RowBlockPair, type RowScope, type ScannedMarker, type UnwritableReason, arrayFiltersFromFieldConfig, assertNever, blockDirectiveLinePattern, classifyMarker, classifyMarkerDefect, clauseSlotKey, clauseSlotPattern, conditionHasFormula, conditionNodeSchema, conditionSchema, detectRowBlockPair, emptyCondition, evaluateCondition, evaluateNumericExpression, filtersFromFieldConfig, formatDate, hasBlockDirectivePattern, hasNumberingPattern, isArrayFilterName, isBlockDirectiveKind, isClauseSlotName, isFieldPath, isSafeFieldPath, legacyLoopAlias, legacyMarkerReplacement, loopPattern, markerPattern, normalizeMarkerInner, numPattern, parseCondition, placeholderPattern, qualifyLoopPath, qualifyRowScopedPath, qualifyRowScopedPlaceholder, refPattern, referencedConditionPaths, renderConditionTag, renderDeterministicFieldValue, renderFilterChain, renderForOpener, renderValueMarker, replaceOutputMarkers, resolvePath, rowScopePaths, scanInvalidMarkers, scanMarkers, serializeCondition, substitutionKey, translateLegacyExpression, unwritableFilterValues, unwritableMarkerLiteral };
+export { type BlockDirectiveKind, type CompareNode, type CompareOp, type Condition, type ConditionNode, type ConditionTagOptions, type DateFormatStyle, type DeterministicFieldConfig, type DirectiveKind, type FieldDateFormat, type FilterArgument, type FilterCall, type FilterName, type ForOpenerOptions, type GroupNode, type InvalidMarker, type LoopProperty, type MarkerDefect, type MarkerDefectKind, type MarkerFieldConfig, type MarkerFieldInputType, type MarkerFieldLookup, type MarkerFieldSource, type MarkerFieldValidation, type MarkerForm, type MarkerLiteral, type MarkerMeta, type MarkerPrefix, type NumericFunctionName, type Operand, type PredicateNode, type PredicateOp, type RowBlockMarker, type RowBlockPair, type RowScope, type ScannedMarker, type UnwritableReason, conditionHasFormula, conditionNodeSchema, conditionSchema, emptyCondition };

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.3",
+  "version": "0.6.0",
   "description": "A document-template marker and condition engine: {{...}} marker grammar, parse, compute, serialize, field values.",
   "keywords": [
     "condition",
@@ -49,7 +49,7 @@
     "prepack": "bun run build"
   },
   "dependencies": {
-    "@stll/conditions": "^0.3.1",
+    "@stll/conditions": "^0.4.0",
     "better-result": "3.0.1",
     "temporal-polyfill": "1.0.4"
   },
@@ -58,7 +58,7 @@
     "@stll/typescript-config": "0.0.0",
     "bun-types": "1.4.2",
     "fast-check": "^4.9.0",
-    "tsdown": "0.22.14"
+    "tsdown": "0.23.0"
   },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts"