@invariant-ui/cli 0.0.0-stage → 0.2.0

package/dist/validation/pattern-rules.js

@@ -0,0 +1,608 @@
+import { constraintDetailsSchemas, effectiveParts, isPatternConstraintKind } from "../contract/index.js";
+import { globToRegExp } from "../shared/index.js";
+import { analyzeInteractions } from "./interaction-workflows.js";
+const CODE = {
+    "required-child": "pattern-required-child-missing",
+    "forbidden-child": "pattern-child-forbidden",
+    "requires-parent": "pattern-parent-required",
+    "required-region": "pattern-region-missing",
+    ordering: "pattern-order-violated",
+    cardinality: "pattern-cardinality-violated",
+    "required-state": "pattern-state-missing"
+};
+export const PATTERN_RULE_CODES = Object.values(CODE);
+export const patternRuleCode = (kind) => CODE[kind];
+const capped = (severity, enforcement) => enforcement === "report-only"
+    ? "info"
+    : enforcement === "warn" && severity === "error"
+        ? "warning"
+        : severity;
+/**
+ * The structural rules approved policies carry. A policy carries one when it is based on a constraint of a
+ * pattern kind; its `details` are parsed here and a constraint that does not parse is reported, not enforced.
+ */
+export function patternRules(ds) {
+    const rules = [];
+    const problems = [];
+    for (const policy of ds.contract.policies)
+        for (const id of policy.basedOn) {
+            const constraint = ds.contract.constraints.find((c) => c.id === id);
+            if (!constraint || !isPatternConstraintKind(constraint.kind))
+                continue;
+            const owner = ds.contract.patterns.find((p) => p.constraints?.includes(constraint.id));
+            const parsed = constraintDetailsSchemas[constraint.kind].safeParse(constraint.details);
+            if (!owner || !parsed.success) {
+                problems.push(`policy ${policy.id}: ${constraint.id} ${owner ? "has details that do not fit its kind" : "belongs to no pattern"}`);
+                continue;
+            }
+            const source = ds.location(constraint.facts.description?.evidenceIds ?? []);
+            rules.push({
+                policy: policy.id,
+                pattern: owner.id,
+                constraint: constraint.id,
+                kind: constraint.kind,
+                details: parsed.data,
+                severity: capped(policy.severity, policy.enforcement),
+                paths: policy.scope.paths ?? [],
+                frameworks: policy.scope.frameworks ?? [],
+                ...(source ? { source } : {})
+            });
+        }
+    return { rules: [...rules, ...inheritedRules(ds, rules)], problems };
+}
+/** Every pattern a pattern composes, in the base blueprint and every variation, followed through patterns it uses. */
+function composedPatterns(ds, root) {
+    const byId = new Map(ds.contract.patterns.map((p) => [p.id, p]));
+    const seen = new Set();
+    const queue = [root];
+    for (let next = queue.shift(); next; next = queue.shift()) {
+        const ids = [undefined, ...(next.variations ?? []).map((v) => v.name)];
+        for (const v of ids)
+            for (const part of effectiveParts(next, v)) {
+                const target = byId.get(part.ref);
+                if (!target || seen.has(target.id) || target.id === root.id)
+                    continue;
+                seen.add(target.id);
+                queue.push(target);
+            }
+    }
+    return seen;
+}
+/**
+ * Constraint inheritance is opt in and needs approval. A page pattern that sets `inheritsConstraints` and names
+ * `appliesTo.paths` puts the rules of everything it composes onto those paths. Both settings must be approved facts,
+ * so a definition nobody approved enforces nothing, and no rule is created that an approved policy did not already carry.
+ */
+function inheritedRules(ds, base) {
+    const out = [];
+    for (const page of ds.contract.patterns) {
+        const paths = page.appliesTo?.paths;
+        if (page.inheritsConstraints !== true || !paths)
+            continue;
+        if (page.facts.appliesTo?.status !== "approved" || page.facts.inheritsConstraints?.status !== "approved")
+            continue;
+        const composed = composedPatterns(ds, page);
+        for (const rule of base) {
+            if (!composed.has(rule.pattern))
+                continue;
+            out.push({
+                ...rule,
+                paths,
+                frameworks: page.appliesTo?.frameworks ?? rule.frameworks,
+                inheritedFrom: page.id
+            });
+        }
+    }
+    return out;
+}
+const PRECEDENCE = ["fail", "warning", "not-verifiable", "pass", "skipped"];
+const depthOf = (t, i) => t.uses[i]?.exprDepth ?? 0;
+const loopOf = (t, i) => t.uses[i]?.loopDepth ?? 0;
+const nameOf = (ctx, ref) => ref.startsWith("region:") ? ref : (ctx.ds.component(ref)?.name ?? ref.replace(/^[a-z]+:/, ""));
+function matcher(ctx, ref) {
+    if (ref.startsWith("pattern:"))
+        return {
+            ok: false,
+            reason: `${ref} is a pattern, and occurrences of a pattern are not detected statically yet`
+        };
+    if (ref.startsWith("region:")) {
+        const name = ref.slice("region:".length);
+        const parts = (ctx.owner?.composition?.parts ?? []).filter((p) => p.region === name && p.role !== "prohibited");
+        const ids = new Set(parts.filter((p) => p.ref.startsWith("component:")).map((p) => p.ref));
+        if (ids.size === 0)
+            return {
+                ok: false,
+                reason: `region ${name} has no component parts to recognize it by; give a composition part that region`
+            };
+        return {
+            ok: true,
+            describe: `region ${name}`,
+            test: (i) => {
+                const c = ctx.tree.components[i];
+                return c !== undefined && ids.has(c.id);
+            }
+        };
+    }
+    return {
+        ok: true,
+        describe: nameOf(ctx, ref),
+        test: (i) => ctx.tree.components[i]?.id === ref
+    };
+}
+function descendants(ctx, root) {
+    const out = [];
+    const walk = (i) => {
+        for (const c of ctx.children[i] ?? []) {
+            out.push(c);
+            walk(c);
+        }
+    };
+    walk(root);
+    return out.sort((a, b) => a - b);
+}
+/** True when nothing in the scope can hide elements: no other-file component and no opaque children. */
+function closed(ctx, scope) {
+    for (const i of scope) {
+        const use = ctx.tree.uses[i];
+        const kind = ctx.tree.kinds[i];
+        if (kind === "foreign" || kind === "unknown" || kind === "ambiguous")
+            return {
+                ok: false,
+                why: `<${use.tag}> at line ${use.line} comes from outside the design system and may render more`
+            };
+        if (use.opaque)
+            return {
+                ok: false,
+                why: `<${use.tag}> at line ${use.line} gets content from outside what this file shows (children, a spread or an expression)`
+            };
+    }
+    return { ok: true };
+}
+function record(ctx, status, reason, at, suggestion, extra) {
+    const { rule } = ctx;
+    const code = CODE[rule.kind];
+    ctx.out.evaluations.push({
+        rule: code,
+        status,
+        reason,
+        pattern: rule.pattern,
+        constraint: rule.constraint,
+        policy: rule.policy,
+        ...(ctx.filename ? { file: ctx.filename } : {}),
+        ...(at?.line === undefined ? {} : { line: at.line }),
+        ...(at?.column === undefined ? {} : { column: at.column }),
+        ...(extra?.level ? { level: extra.level } : {}),
+        ...(extra?.evidence && extra.evidence.length > 0 ? { evidence: extra.evidence } : {}),
+        ...(rule.inheritedFrom ? { inheritedFrom: rule.inheritedFrom } : {})
+    });
+    if (status !== "fail" && status !== "warning")
+        return;
+    ctx.out.findings.push({
+        code,
+        severity: status === "warning" && rule.severity === "error" ? "warning" : rule.severity,
+        message: `${reason} (pattern ${rule.pattern}${rule.inheritedFrom ? `, inherited through ${rule.inheritedFrom}` : ""})`,
+        subject: rule.pattern,
+        ...(at?.line === undefined ? {} : { line: at.line }),
+        ...(at?.column === undefined ? {} : { column: at.column }),
+        basis: "approved",
+        policy: rule.policy,
+        ...(rule.source ? { source: rule.source } : {}),
+        ...(suggestion ? { suggestion } : {})
+    });
+}
+const at = (ctx, i) => ({
+    line: ctx.tree.uses[i].line,
+    column: ctx.tree.uses[i].column
+});
+/** A scope is the whole file, or the subtree of one element. Returns the indices inside it. */
+function scopeOf(ctx, within) {
+    return within === undefined ? ctx.tree.uses.map((_, i) => i) : descendants(ctx, within);
+}
+/**
+ * Matches in a scope. `certain` ones render exactly once relative to the scope's root; `repeated` ones sit in a
+ * callback (a list, a render prop) and may render any number of times, so they can never prove an upper bound.
+ */
+function counts(ctx, scope, test, baseDepth, baseLoop = 0) {
+    const matched = scope.filter(test);
+    return {
+        all: matched,
+        certain: matched.filter((i) => depthOf(ctx.tree, i) <= baseDepth),
+        repeated: matched.filter((i) => loopOf(ctx.tree, i) > baseLoop)
+    };
+}
+function evaluateRequiredChild(ctx, d) {
+    const parent = matcher(ctx, d.parent);
+    const child = matcher(ctx, d.child);
+    if (!parent.ok || !child.ok) {
+        record(ctx, "not-verifiable", (!parent.ok ? parent : child).reason, undefined);
+        return;
+    }
+    const min = d.min ?? 1;
+    const each = (p) => {
+        if (!parent.test(p))
+            return;
+        const scope = descendants(ctx, p);
+        const { all, certain } = counts(ctx, scope, child.test, depthOf(ctx.tree, p));
+        const label = `${parent.describe} at line ${at(ctx, p).line}`;
+        if (certain.length >= min)
+            return record(ctx, "pass", `${label} contains ${child.describe}`, at(ctx, p));
+        if (all.length >= min)
+            return record(ctx, "warning", `${label} contains ${child.describe} only conditionally, so it may be missing when rendered`, at(ctx, p), `Render ${child.describe} unconditionally inside ${parent.describe}.`);
+        const c = closed(ctx, [p, ...scope]);
+        if (!c.ok)
+            return record(ctx, "not-verifiable", `${label}: cannot tell whether it contains ${child.describe}; ${c.why}`, at(ctx, p));
+        record(ctx, "fail", `${label} has no ${child.describe}${min > 1 ? ` (needs ${min})` : ""}`, at(ctx, p), `Add ${child.describe} inside ${parent.describe}.`);
+    };
+    for (const p of ctx.tree.uses.keys())
+        each(p);
+}
+function evaluateForbiddenChild(ctx, d) {
+    const parent = matcher(ctx, d.parent);
+    const child = matcher(ctx, d.child);
+    if (!parent.ok || !child.ok) {
+        record(ctx, "not-verifiable", (!parent.ok ? parent : child).reason, undefined);
+        return;
+    }
+    const each = (p) => {
+        if (!parent.test(p))
+            return;
+        const scope = descendants(ctx, p);
+        const label = `${parent.describe} at line ${at(ctx, p).line}`;
+        const found = scope.find(child.test);
+        if (found !== undefined)
+            return record(ctx, "fail", `${label} contains ${child.describe} at line ${at(ctx, found).line}, which is not allowed there`, at(ctx, found), `Remove ${child.describe} from inside ${parent.describe}.`);
+        const c = closed(ctx, [p, ...scope]);
+        if (!c.ok)
+            return record(ctx, "not-verifiable", `${label}: cannot tell whether it avoids ${child.describe}; ${c.why}`, at(ctx, p));
+        record(ctx, "pass", `${label} does not contain ${child.describe}`, at(ctx, p));
+    };
+    for (const p of ctx.tree.uses.keys())
+        each(p);
+}
+function evaluateRequiresParent(ctx, d) {
+    const child = matcher(ctx, d.child);
+    const parents = d.parents.map((p) => matcher(ctx, p));
+    const bad = [child, ...parents].find((m) => !m.ok);
+    if (bad && !bad.ok) {
+        record(ctx, "not-verifiable", bad.reason, undefined);
+        return;
+    }
+    const okParents = parents;
+    const okChild = child;
+    const names = okParents.map((m) => m.describe).join(" or ");
+    const each = (i) => {
+        const use = ctx.tree.uses[i];
+        if (!okChild.test(i))
+            return;
+        const chain = [];
+        for (let p = use.parent; p !== undefined; p = ctx.tree.uses[p]?.parent)
+            chain.push(p);
+        const label = `${okChild.describe} at line ${use.line}`;
+        if (chain.some((a) => okParents.some((m) => m.test(a))))
+            return record(ctx, "pass", `${label} is inside ${names}`, at(ctx, i));
+        const designSystemAncestors = chain.filter((a) => ctx.tree.components[a] !== undefined);
+        if (designSystemAncestors.length === 0)
+            return record(ctx, "not-verifiable", `${label}: no design-system element encloses it in this file, so its parent may be in another file`, at(ctx, i));
+        record(ctx, "fail", `${label} must be inside ${names}, but sits inside ${nameOf(ctx, ctx.tree.components[designSystemAncestors[0]]?.id ?? "")} instead`, at(ctx, i), `Wrap it in ${names}.`);
+    };
+    for (const i of ctx.tree.uses.keys())
+        each(i);
+}
+/** A file-level scope needs the policy to say which files are instances of the pattern. */
+function fileLevel(ctx) {
+    if (ctx.rule.paths.length > 0)
+        return true;
+    record(ctx, "skipped", "this rule is about a whole file, and the policy names no paths (appliesTo.paths), so there is no way to know this file is an instance of the pattern", undefined);
+    return false;
+}
+function evaluateRequiredRegion(ctx, d) {
+    const region = matcher(ctx, d.region);
+    if (!region.ok)
+        return record(ctx, "not-verifiable", region.reason, undefined);
+    if (!fileLevel(ctx))
+        return;
+    const all = ctx.tree.uses.map((_, i) => i);
+    const { all: found, certain } = counts(ctx, all, region.test, 0);
+    if (certain.length > 0)
+        return record(ctx, "pass", `${region.describe} is present`, at(ctx, certain[0]));
+    if (found.length > 0)
+        return record(ctx, "warning", `${region.describe} appears only conditionally, so it may be missing when rendered`, at(ctx, found[0]), `Render ${region.describe} unconditionally.`);
+    const c = closed(ctx, all);
+    if (!c.ok)
+        return record(ctx, "not-verifiable", `cannot tell whether ${region.describe} is present; ${c.why}`, {
+            line: 1,
+            column: 1
+        });
+    record(ctx, "fail", `${region.describe} is missing`, { line: 1, column: 1 }, `Add the components that make up ${region.describe}.`);
+}
+function evaluateOrdering(ctx, d) {
+    const before = matcher(ctx, d.before);
+    const after = matcher(ctx, d.after);
+    const within = d.within === undefined ? undefined : matcher(ctx, d.within);
+    const bad = [before, after, within].find((m) => m !== undefined && !m.ok);
+    if (bad && !bad.ok)
+        return record(ctx, "not-verifiable", bad.reason, undefined);
+    if (d.within?.startsWith("region:"))
+        return record(ctx, "not-verifiable", "ordering within a region is not evaluated yet", undefined);
+    const b = before;
+    const a = after;
+    const scopes = within === undefined
+        ? [{ root: undefined, label: "this file" }]
+        : ctx.tree.uses.flatMap((_, i) => within.test(i)
+            ? [
+                {
+                    root: i,
+                    label: `${within.describe} at line ${at(ctx, i).line}`
+                }
+            ]
+            : []);
+    if (within === undefined && !fileLevel(ctx))
+        return;
+    for (const { root, label } of scopes) {
+        const scope = scopeOf(ctx, root);
+        const bs = scope.filter(b.test);
+        const as = scope.filter(a.test);
+        const where = root === undefined ? undefined : at(ctx, root);
+        if (bs.length === 0 || as.length === 0) {
+            record(ctx, "skipped", `${label}: no ${bs.length === 0 ? b.describe : a.describe} to order`, where);
+            continue;
+        }
+        const early = as.find((x) => bs.some((y) => y > x && !isAncestor(ctx, x, y) && !isAncestor(ctx, y, x)));
+        if (early !== undefined) {
+            const late = bs.find((y) => y > early);
+            record(ctx, "fail", `${label}: ${a.describe} (line ${at(ctx, early).line}) comes before ${b.describe} (line ${at(ctx, late).line}); ${b.describe} must come first`, at(ctx, early), `Move ${b.describe} before ${a.describe}.`);
+            continue;
+        }
+        const c = closed(ctx, root === undefined ? scope : [root, ...scope]);
+        if (!c.ok)
+            record(ctx, "not-verifiable", `${label}: order looks right, but ${c.why}`, where);
+        else
+            record(ctx, "pass", `${label}: ${b.describe} comes before ${a.describe}`, where);
+    }
+}
+function isAncestor(ctx, ancestor, of) {
+    for (let p = ctx.tree.uses[of]?.parent; p !== undefined; p = ctx.tree.uses[p]?.parent)
+        if (p === ancestor)
+            return true;
+    return false;
+}
+function evaluateCardinality(ctx, d) {
+    const target = matcher(ctx, d.target);
+    const within = d.within === undefined ? undefined : matcher(ctx, d.within);
+    const bad = [target, within].find((m) => m !== undefined && !m.ok);
+    if (bad && !bad.ok)
+        return record(ctx, "not-verifiable", bad.reason, undefined);
+    if (d.within?.startsWith("region:"))
+        return record(ctx, "not-verifiable", "counting within a region is not evaluated yet", undefined);
+    const t = target;
+    const w = within;
+    if (w === undefined && !fileLevel(ctx))
+        return;
+    const scopes = w === undefined
+        ? [{ root: undefined, label: "this file" }]
+        : ctx.tree.uses.flatMap((_, i) => w.test(i)
+            ? [{ root: i, label: `${w.describe} at line ${at(ctx, i).line}` }]
+            : []);
+    for (const { root, label } of scopes) {
+        const scope = scopeOf(ctx, root);
+        const base = root === undefined ? 0 : depthOf(ctx.tree, root);
+        const { all, certain, repeated } = counts(ctx, scope, t.test, base, root === undefined ? 0 : loopOf(ctx.tree, root));
+        const where = root === undefined ? undefined : at(ctx, root);
+        const range = `${d.min !== undefined ? `at least ${d.min}` : ""}${d.min !== undefined && d.max !== undefined ? " and " : ""}${d.max !== undefined ? `at most ${d.max}` : ""}`;
+        const seal = closed(ctx, root === undefined ? scope : [root, ...scope]);
+        const outcomes = [];
+        if (d.max !== undefined) {
+            if (certain.length > d.max)
+                outcomes.push({
+                    status: "fail",
+                    reason: `${label} has ${certain.length} ${t.describe}, but ${range} are allowed`,
+                    at: at(ctx, certain[d.max]),
+                    fix: `Keep at most ${d.max} ${t.describe}.`
+                });
+            else if (repeated.length > 0)
+                outcomes.push({
+                    status: "warning",
+                    reason: `${label} renders ${t.describe} in a list or callback, so there may be more than ${d.max}`,
+                    at: at(ctx, repeated[0])
+                });
+            else if (all.length > d.max)
+                outcomes.push({
+                    status: "warning",
+                    reason: `${label} may have more than ${d.max} ${t.describe} when conditional ones render`,
+                    ...(all[0] === undefined ? {} : { at: at(ctx, all[0]) })
+                });
+            else if (!seal.ok)
+                outcomes.push({
+                    status: "not-verifiable",
+                    reason: `${label}: ${all.length} ${t.describe} seen (at most ${d.max} allowed), but ${seal.why}`
+                });
+            else
+                outcomes.push({
+                    status: "pass",
+                    reason: `${label} has ${all.length} ${t.describe}, within the limit of ${d.max}`
+                });
+        }
+        if (d.min !== undefined) {
+            if (certain.length >= d.min)
+                outcomes.push({
+                    status: "pass",
+                    reason: `${label} has ${certain.length} ${t.describe}, at least ${d.min}`
+                });
+            else if (all.length >= d.min)
+                outcomes.push({
+                    status: "warning",
+                    reason: `${label} reaches ${d.min} ${t.describe} only with conditionally rendered ones`,
+                    ...(all[0] === undefined ? {} : { at: at(ctx, all[0]) }),
+                    fix: `Render ${t.describe} unconditionally.`
+                });
+            else if (!seal.ok)
+                outcomes.push({
+                    status: "not-verifiable",
+                    reason: `${label}: ${all.length} ${t.describe} seen (needs ${d.min}), but ${seal.why}`
+                });
+            else
+                outcomes.push({
+                    status: "fail",
+                    reason: `${label} has ${all.length} ${t.describe}, but needs at least ${d.min}`,
+                    at: where ?? { line: 1, column: 1 },
+                    fix: `Add ${t.describe}.`
+                });
+        }
+        const worst = PRECEDENCE.find((s) => outcomes.some((o) => o.status === s));
+        const picked = outcomes.filter((o) => o.status === worst);
+        record(ctx, worst, picked.map((o) => o.reason).join("; "), picked[0]?.at ?? where, picked.find((o) => o.fix)?.fix);
+    }
+}
+const STATE_FIX = {
+    "form-submission:submitting": "Show that the form is submitting, for example disable the submit button and show progress.",
+    "form-submission:error": "Show an error message, and a way to try again, when the submission fails.",
+    "form-submission:success": "Confirm the result, for example with a message or by navigating on success.",
+    "form-submission:guarded": "Disable the submit button, or return early in the handler, while the form is pending.",
+    "destructive-confirmation:confirming": "Ask for confirmation, for example in a dialog, before deleting.",
+    "destructive-confirmation:cancellable": "Give the confirmation a Cancel button that closes it without deleting.",
+    "search-results:connected": "Use the search text to filter or fetch the results.",
+    "search-results:loading": "Show a loading state while the results load.",
+    "search-results:empty": "Show an empty state when the search finds nothing.",
+    "search-results:error": "Show an error state when the search fails.",
+    "search-results:clearable": "Give the user a way to clear the search."
+};
+const LEVEL_RANK = { structural: 1, "static-inferred": 2 };
+/**
+ * A workflow state the code must represent. The result says how it was established. A state found only
+ * structurally when the rule asks for more is a warning, and one the file hides is not verifiable.
+ */
+function evaluateRequiredState(ctx, d) {
+    const minimum = d.minimum ?? "structural";
+    for (const site of ctx.interactions().filter((s) => s.workflow === d.workflow)) {
+        const check = site.states[d.state];
+        const where = { line: site.line, column: site.column };
+        if (!check) {
+            record(ctx, "not-verifiable", `${site.label}: ${d.state} is not a state this analysis looks for`, where);
+        }
+        else if (check.level) {
+            const extra = { level: check.level, evidence: check.evidence };
+            if (LEVEL_RANK[check.level] >= LEVEL_RANK[minimum])
+                record(ctx, "pass", `${site.label}: ${d.state} is represented (${check.level})`, where, undefined, extra);
+            else
+                record(ctx, "warning", `${site.label}: ${d.state} is represented only structurally; the rule asks for evidence that the code makes it happen (${minimum})`, where, STATE_FIX[`${d.workflow}:${d.state}`], extra);
+        }
+        else if (check.open)
+            record(ctx, "not-verifiable", `${site.label}: cannot tell whether ${d.state} is represented; ${check.open}`, where);
+        else
+            record(ctx, "fail", `${site.label}: ${d.state} is not represented; ${check.absent ?? "nothing shows it"}`, where, STATE_FIX[`${d.workflow}:${d.state}`]);
+    }
+    return undefined;
+}
+const framework = (rule, name) => rule.frameworks.length === 0 || rule.frameworks.includes(name);
+/**
+ * Evaluates the structural rules that apply to one file. A rule applies when the policy's frameworks include
+ * the file's framework and, if the policy names paths, the file matches one. Rules for other files are not
+ * recorded: they are not part of this file's result.
+ */
+/**
+ * One policy and constraint is evaluated once per file. When inheritance gives a rule a second route to the file,
+ * the route that says most wins: the policy's own paths, then inherited paths, then no paths at all.
+ */
+function shadowedRules(rules, frameworkName, filename) {
+    const shadowed = new Set();
+    if (!rules.some((r) => r.inheritedFrom))
+        return shadowed;
+    const name = filename?.replace(/^\.\//, "");
+    const applies = (r) => framework(r, frameworkName) &&
+        (r.paths.length === 0 || (name !== undefined && r.paths.some((g) => globToRegExp(g).test(name))));
+    const rank = (r) => (r.inheritedFrom ? 1 : r.paths.length > 0 ? 0 : 2);
+    const best = new Map();
+    for (const r of rules) {
+        if (!applies(r))
+            continue;
+        const key = `${r.policy}|${r.constraint}`;
+        const held = best.get(key);
+        if (!held || rank(r) < rank(held))
+            best.set(key, r);
+    }
+    for (const r of rules)
+        if (applies(r) && best.get(`${r.policy}|${r.constraint}`) !== r)
+            shadowed.add(r);
+    return shadowed;
+}
+export function evaluatePatternRules(input) {
+    const out = { evaluations: [], findings: [] };
+    const children = input.tree.uses.map(() => []);
+    input.tree.uses.forEach((u, i) => {
+        if (u.parent !== undefined)
+            children[u.parent]?.push(i);
+    });
+    let model;
+    const interactions = () => {
+        if (model)
+            return model;
+        const components = new Set(input.tree.uses.filter((_, i) => input.tree.kinds[i] === "component").map((u) => u.tag));
+        model =
+            input.code === undefined
+                ? []
+                : analyzeInteractions(input.code, input.filename ?? "snippet.tsx", components);
+        return model;
+    };
+    const shadowed = shadowedRules(input.rules, input.framework, input.filename);
+    for (const rule of input.rules) {
+        if (shadowed.has(rule))
+            continue;
+        if (!framework(rule, input.framework))
+            continue;
+        if (rule.paths.length > 0) {
+            if (input.filename === undefined) {
+                out.evaluations.push({
+                    rule: CODE[rule.kind],
+                    status: "skipped",
+                    reason: "the policy applies to certain paths and no file name was given, so it was not checked",
+                    pattern: rule.pattern,
+                    constraint: rule.constraint,
+                    policy: rule.policy
+                });
+                continue;
+            }
+            const name = input.filename.replace(/^\.\//, "");
+            if (!rule.paths.some((g) => globToRegExp(g).test(name)))
+                continue;
+        }
+        const ctx = {
+            ds: input.ds,
+            tree: input.tree,
+            rule,
+            owner: input.ds.contract.patterns.find((p) => p.id === rule.pattern),
+            filename: input.filename,
+            children,
+            out,
+            interactions
+        };
+        if (input.framework !== "react") {
+            record(ctx, "skipped", `pattern rules are evaluated for React JSX only; ${input.framework} templates are not analyzed for patterns yet`, undefined);
+            continue;
+        }
+        switch (rule.kind) {
+            case "required-child":
+                evaluateRequiredChild(ctx, rule.details);
+                break;
+            case "forbidden-child":
+                evaluateForbiddenChild(ctx, rule.details);
+                break;
+            case "requires-parent":
+                evaluateRequiresParent(ctx, rule.details);
+                break;
+            case "required-region":
+                evaluateRequiredRegion(ctx, rule.details);
+                break;
+            case "ordering":
+                evaluateOrdering(ctx, rule.details);
+                break;
+            case "cardinality":
+                evaluateCardinality(ctx, rule.details);
+                break;
+            case "required-state":
+                evaluateRequiredState(ctx, rule.details);
+                break;
+        }
+    }
+    return out;
+}
+//# sourceMappingURL=pattern-rules.js.map