@gjsify/oxlint-plugin-gjsify 0.53.0

package/lib/no-literal-widget-label.js

@@ -0,0 +1,190 @@
+// `gjsify/no-literal-widget-label` — user-visible text hard-coded into a widget from TypeScript.
+//
+// This is the half of the Blueprint problem that survives even after a class HAS a template: a
+// label handed to a constructor or a setter as a bare string literal. It is not a style question.
+// `xgettext` collects `translatable="yes"` out of Blueprint and `_("…")` out of TypeScript, and a
+// bare literal is neither — so the string is invisible to extraction, absent from every catalogue,
+// and shows up in the user's language only by accident. The failure is silent in the worst way:
+// the interface looks untranslated rather than untranslatABLE, so it never gets filed.
+//
+// Two repairs, and the rule accepts both because the right one depends on the string:
+//   · move it into the co-located `.blp` as `title: _("…")` — correct for anything static;
+//   · wrap it here as `_("…")` — correct for a string a runtime value picks.
+// Either turns the literal into something extraction can see, which is why wrapping silences it.
+//
+// Only PROSE positions are checked. `icon-name`, `css-classes`, `action-name`, a stack page's
+// `name` and an `Adw.EntryRow`'s `text` (which carries user data, not a caption) are deliberately
+// absent: a false finding on those would teach people to disable the rule.
+//
+// The setter half matches on METHOD NAME alone — the rule cannot see whether the receiver is a
+// widget — so a non-GTK object with a `set_title` method is reported too. That is the deliberate
+// trade: the alternative is missing every setter call on a variable whose type the linter has no
+// access to, and `_()` around a genuinely non-UI string costs a catalogue entry and nothing else.
+import { walk } from "./walk.js";
+/** Constructor-object keys whose value is shown to a person. Both GJS spellings. */
+const PROSE_PROPERTIES = new Set([
+    'label',
+    'title',
+    'subtitle',
+    'description',
+    'heading',
+    'body',
+    'tooltipText',
+    'tooltip_text',
+    'placeholderText',
+    'placeholder_text',
+    'secondaryText',
+    'secondary_text',
+]);
+/**
+ * Setters that write the same prose positions, mapped to the PROPERTY they set — so the repair the
+ * message suggests is one Blueprint can actually express. `set_title: _("…")` is not a Blueprint
+ * property; `title` is.
+ */
+const PROSE_SETTERS = new Map([
+    ['set_label', 'label'],
+    ['set_title', 'title'],
+    ['set_subtitle', 'subtitle'],
+    ['set_description', 'description'],
+    ['set_heading', 'heading'],
+    ['set_body', 'body'],
+    ['set_tooltip_text', 'tooltip-text'],
+    ['set_placeholder_text', 'placeholder-text'],
+]);
+/**
+ * Prose that arrives as a LATER argument, with the index it sits at.
+ *
+ * `Adw.AlertDialog` gets its button captions only through these, and nothing else covered them: a
+ * dialog whose `heading` this rule reports would still ship English-only buttons, in the very same
+ * function. Measured across the two consumer apps: 24 live `add_response(` call sites.
+ *
+ * The surface is small and closed — `Adw.AlertDialog` and `Adw.MessageDialog` are the only classes
+ * in `@girs/adw-1` that declare `set_response_label`.
+ */
+const PROSE_ARGUMENTS = new Map([
+    ['add_response', 1],
+    ['set_response_label', 1],
+]);
+/**
+ * Is this literal worth reporting?
+ *
+ * A caption needs letters. `""`, `"—"`, `"…"`, `"%"` and `"3"` are punctuation or data with
+ * nothing to translate, and reporting them is how a rule loses its audience.
+ */
+function isProse(value) {
+    return typeof value === 'string' && /\p{L}/u.test(value);
+}
+/** The string value of a plain literal (not a template, not a concatenation); else null. */
+function literalString(node) {
+    if (!node)
+        return null;
+    if (node.type === 'Literal' && isProse(node.value))
+        return node.value;
+    // A no-substitution template literal is a literal in every way that matters here.
+    if (node.type === 'TemplateLiteral') {
+        const expressions = node.expressions;
+        const quasis = node.quasis;
+        if (expressions?.length === 0 && quasis?.length === 1) {
+            const cooked = quasis[0].value?.cooked;
+            if (isProse(cooked))
+                return cooked;
+        }
+    }
+    return null;
+}
+/** `Gtk`/`Adw` namespaced callee — `new Adw.ActionRow(…)`. */
+function isGtkAdwNew(node) {
+    if (node.type !== 'NewExpression')
+        return false;
+    const callee = node.callee;
+    if (!callee || callee.type !== 'MemberExpression' || callee.computed === true)
+        return false;
+    const object = callee.object;
+    if (object?.type !== 'Identifier')
+        return false;
+    const ns = object.name;
+    return ns === 'Gtk' || ns === 'Adw';
+}
+export const noLiteralWidgetLabelRule = {
+    create(context) {
+        /** For a caption with no declarative form: the only repair is `_()` at the call site. */
+        const reportInPlace = (node, method, text) => {
+            const shown = text.length > 40 ? `${text.slice(0, 40)}…` : text;
+            context.report({
+                message: `\`${method}\` is given the literal "${shown}". Extraction sees neither a Blueprint ` +
+                    `\`translatable\` attribute nor a \`_()\` call here, so this text can never reach a ` +
+                    `catalogue. There is no Blueprint property for it — the caption is added by a call — ` +
+                    `so wrap it: \`${method}(…, _("…"))\`.`,
+                node,
+            });
+        };
+        const report = (node, key, text) => {
+            const shown = text.length > 40 ? `${text.slice(0, 40)}…` : text;
+            context.report({
+                message: `\`${key}\` is set to the literal "${shown}". Extraction sees neither a Blueprint ` +
+                    `\`translatable\` attribute nor a \`_()\` call here, so this text can never reach a ` +
+                    `catalogue. Move it into the co-located .blp as \`${key}: _("…")\`, or wrap it as \`_("…")\` ` +
+                    `if a runtime value picks it.`,
+                node,
+            });
+        };
+        return {
+            Program(program) {
+                // The statements, NOT the Program node: oxlint hangs `tokens` and `comments` off
+                // Program, and `walk`'s node test is structural, so handing it Program walked the
+                // whole token stream — the large majority of this rule's cost, for nothing.
+                const visit = (node) => {
+                    // new Gtk.X({ title: "…" })
+                    if (isGtkAdwNew(node)) {
+                        for (const arg of node.arguments ?? []) {
+                            if (arg.type !== 'ObjectExpression')
+                                continue;
+                            for (const prop of arg.properties ?? []) {
+                                if (prop.type !== 'Property' || prop.computed === true)
+                                    continue;
+                                const key = prop.key;
+                                if (key?.type !== 'Identifier')
+                                    continue;
+                                const name = key.name;
+                                if (!PROSE_PROPERTIES.has(name))
+                                    continue;
+                                const text = literalString(prop.value);
+                                if (text !== null)
+                                    report(prop, name, text);
+                            }
+                        }
+                        return;
+                    }
+                    // widget.set_title("…") / dialog.add_response("cancel", "…")
+                    if (node.type === 'CallExpression') {
+                        const callee = node.callee;
+                        if (!callee || callee.type !== 'MemberExpression' || callee.computed === true)
+                            return;
+                        const property = callee.property;
+                        if (property?.type !== 'Identifier')
+                            return;
+                        const name = property.name;
+                        const args = node.arguments ?? [];
+                        const setterProperty = PROSE_SETTERS.get(name);
+                        if (setterProperty !== undefined) {
+                            const text = literalString(args[0]);
+                            if (text !== null)
+                                report(node, setterProperty, text);
+                            return;
+                        }
+                        const index = PROSE_ARGUMENTS.get(name);
+                        if (index !== undefined) {
+                            const text = literalString(args[index]);
+                            // No Blueprint property to name here — a response label is ADDED by a
+                            // call, not declared — so the message says to wrap it in place.
+                            if (text !== null)
+                                reportInPlace(node, name, text);
+                        }
+                    }
+                };
+                for (const statement of program.body ?? [])
+                    walk(statement, visit);
+            },
+        };
+    },
+};

package/lib/prefer-blueprint-template.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from './types.ts';
+export declare const preferBlueprintTemplateRule: Rule;

package/lib/prefer-blueprint-template.js

@@ -0,0 +1,380 @@
+// `gjsify/prefer-blueprint-template` — code that BUILDS a widget tree in TypeScript instead of
+// declaring it in a Blueprint template.
+//
+// NOT ONLY A CLASS. The rule shipped visiting `ClassDeclaration`/`ClassExpression` only, and the
+// one interface in this repository that every new user inherits was assembled somewhere else:
+// `templates/gtk-minimal/src/index.ts` built its window, box and two labels inside the
+// `activate` callback, with a literal caption no extraction can see, and reported ZERO — a green
+// that meant "did not look". So the rule now also walks module scope (top-level statements,
+// callbacks, factory functions) and reports the DEEPEST function that holds both signals.
+//
+// The incident this rule exists for is structural rather than a crash, which is why nothing else
+// catches it. Measured across this workspace in 2026-08:
+//
+//     Learn6502 (the reference app)   24 .blp   8 programmatic `new Gtk/Adw.X`
+//     bauplaner                        0 .blp  422
+//     steuererklaerung                15 .blp  895   — and those 15 are empty scaffolds
+//
+// Learn6502 is proof that a whole application's interface fits in Blueprint. The other two grew
+// the opposite way, one `append()` at a time, and the cost only shows up later and all at once:
+//
+//   · A string built into a widget from TypeScript cannot be marked `translatable`, so xgettext
+//     never sees it. The interface is then untranslatable by construction, and it looks exactly
+//     like an interface nobody has translated yet.
+//   · `bind` and `notify` wiring has to be hand-written, so state and widget drift apart.
+//   · There is no artifact a designer can read or a screenshot tool can diff against.
+//
+// WHAT IS NOT A FINDING. A template that populates DATA-DRIVEN children at runtime is the
+// intended pattern, not a violation — declare the container in Blueprint, fill it in TypeScript.
+// Such a class has a `Template`, so it is silent here. So is a class that constructs no widget at
+// all (a model, a controller, a `vfunc_snapshot` drawing widget), and so is one that constructs
+// widgets but never parents any — the rule requires BOTH signals before it says anything, because
+// either one alone is ordinary code.
+//
+// Library code that implements widgets for others (a renderer, a host, a storybook harness) is
+// exempt by nature; scope the rule to application packages in `.oxlintrc.json` rather than
+// disabling it line by line. A site blocked by the TOOLCHAIN rather than by its nature is the
+// other case and keeps a line-level disable with its measurement, so the blocker is still
+// visible where it applies and still deletable when it lifts.
+//
+// WHAT STILL ESCAPES, measured with fixtures rather than assumed: a class that already declares a
+// `Template` and assembles a SECOND tree in one of its methods. That is the price of the promise
+// two paragraphs up — a templated class is silent — and it is bounded, because such a class has
+// already declared most of its interface. Everything else that was tried is caught: construction
+// and parenting split across two sibling functions, a factory that returns a widget, assembly in
+// a top-level statement, a method of a plain class, an object-literal method, an arrow stored in
+// a const, `.tsx`, and a `vfunc_activate()` inside an application subclass.
+import { isNode, memberCallName, newGtkAdwType, walk } from "./walk.js";
+/**
+ * Methods that take a WIDGET and place it inside another one. Membership here is what separates
+ * "constructs a widget" from "assembles an interface" — the second is the finding.
+ */
+const PARENTING_METHODS = new Set([
+    'set_child',
+    'append',
+    'prepend',
+    'insert_child_after',
+    'add',
+    'add_row',
+    'add_prefix',
+    'add_suffix',
+    'add_child',
+    'add_overlay',
+    'add_titled',
+    'add_named',
+    'add_page',
+    'add_top_bar',
+    'add_bottom_bar',
+    'add_toolbar',
+    'set_content',
+    'set_title_widget',
+    'set_start_widget',
+    'set_end_widget',
+    'set_center_widget',
+    'set_header_suffix',
+    'set_extra_child',
+    'attach',
+]);
+/**
+ * Constructions that are NOT widgets, so building one is never "assembling an interface".
+ *
+ * The rule needs both its signals to be about widgets, and it cannot type-check: it sees
+ * `new Gtk.X` and a method NAME, never a GType. Most non-widgets are harmless because their own
+ * API shares no name with a parenting method — `new Gtk.GestureClick()` + `add_controller` is
+ * already silent. The ones that DO collide are listed here, `Gtk.StringList` being the case that
+ * actually occurs: a combo row filling a model with `.append(<string>)` was reported as assembling
+ * an interface, which is exactly the model case the header promises is silent.
+ *
+ * Families are matched by prefix below rather than enumerated, because their members are many and
+ * the list would drift against the GIR.
+ */
+const NON_WIDGET_CONSTRUCTIONS = new Set([
+    'Gtk.Adjustment',
+    'Gtk.AnyFilter',
+    'Gtk.BoolFilter',
+    'Gtk.Builder',
+    'Gtk.BuilderListItemFactory',
+    'Gtk.CssProvider',
+    'Gtk.CustomFilter',
+    'Gtk.CustomSorter',
+    'Gtk.EntryBuffer',
+    'Gtk.EveryFilter',
+    'Gtk.FileDialog',
+    'Gtk.FileFilter',
+    'Gtk.ListStore',
+    'Gtk.NumericSorter',
+    'Gtk.SignalListItemFactory',
+    'Gtk.SizeGroup',
+    'Gtk.StringFilter',
+    'Gtk.StringList',
+    'Gtk.StringObject',
+    'Gtk.StringSorter',
+    'Gtk.TextBuffer',
+    'Gtk.TextTag',
+    'Gtk.TextTagTable',
+    'Adw.Breakpoint',
+    'Adw.BreakpointCondition',
+    'Adw.CallbackAnimationTarget',
+    'Adw.EnumListModel',
+    'Adw.PropertyAnimationTarget',
+    'Adw.SpringAnimation',
+    'Adw.SpringParams',
+    'Adw.StyleManager',
+    'Adw.TimedAnimation',
+    'Adw.Toast',
+    // An application object is not a widget, and every scaffold constructs one at module scope.
+    // Listed here (not only in `NON_WIDGET_BASES`, which answers a different question) so that
+    // `new Adw.Application(…)` is not the construction half of a module-scope finding.
+    'Gtk.Application',
+    'Adw.Application',
+]);
+/** Prefixes whose whole family is non-widget: controllers, gestures and list models. */
+const NON_WIDGET_PREFIXES = ['Gtk.EventController', 'Gtk.Gesture', 'Gtk.MultiSorter'];
+/** Suffixes covering the list-model and selection families without enumerating them. */
+const NON_WIDGET_SUFFIXES = ['ListModel', 'Selection'];
+function isNonWidgetConstruction(type) {
+    if (NON_WIDGET_CONSTRUCTIONS.has(type))
+        return true;
+    if (NON_WIDGET_PREFIXES.some((prefix) => type.startsWith(prefix)))
+        return true;
+    return NON_WIDGET_SUFFIXES.some((suffix) => type.endsWith(suffix));
+}
+/**
+ * Bases that are NOT widgets, so there is no interface for a template to hold. `Gtk.Application` /
+ * `Adw.Application` are the ones that actually occur: an application object legitimately builds a
+ * `Gtk.CssProvider` and an `Adw.AboutDialog` from its own metadata, and reporting that taught the
+ * rule's first reader that it cries wolf.
+ */
+const NON_WIDGET_BASES = new Set(['Gtk.Application', 'Adw.Application']);
+/** `class X extends Gtk.Widget` / `extends Adw.Bin` → the base name; null for anything else. */
+function gtkAdwSuperClass(node) {
+    const superClass = node.superClass;
+    if (!superClass || superClass.type !== 'MemberExpression' || superClass.computed === true)
+        return null;
+    const object = superClass.object;
+    const property = superClass.property;
+    if (object?.type !== 'Identifier' || property?.type !== 'Identifier')
+        return null;
+    const ns = object.name;
+    if (ns !== 'Gtk' && ns !== 'Adw')
+        return null;
+    const base = `${ns}.${property.name}`;
+    return NON_WIDGET_BASES.has(base) ? null : base;
+}
+/** A `Template` key directly on this object literal — not nested anywhere inside it. */
+function objectDeclaresTemplate(node) {
+    if (node.type !== 'ObjectExpression')
+        return false;
+    for (const prop of node.properties ?? []) {
+        if (prop.type !== 'Property' || prop.computed === true)
+            continue;
+        const key = prop.key;
+        if (key?.type === 'Identifier' && key.name === 'Template')
+            return true;
+    }
+    return false;
+}
+/** A `registerClass(…)` call inside this static block whose metadata object carries `Template`. */
+function staticBlockDeclaresTemplate(block) {
+    let found = false;
+    walk(block, (node) => {
+        if (found || node.type !== 'CallExpression')
+            return;
+        const callee = node.callee;
+        const named = (callee?.type === 'MemberExpression' &&
+            callee.computed !== true &&
+            callee.property?.type === 'Identifier' &&
+            callee.property.name === 'registerClass') ||
+            (callee?.type === 'Identifier' && callee.name === 'registerClass');
+        if (!named)
+            return;
+        for (const arg of node.arguments ?? []) {
+            if (objectDeclaresTemplate(arg))
+                found = true;
+        }
+    });
+    return found;
+}
+/**
+ * True when THIS class body declares a `Template`: a `static Template` field of its own, or a
+ * `registerClass` metadata object inside its own `static {}` block, which is this repo's
+ * convention (see the sibling `gjsify/register-class-order`).
+ *
+ * Deliberately NOT a subtree search. An unbounded walk for the identifier `Template` was silenced
+ * by things that declare nothing — a data literal that merely uses the word (`{ Template: false }`,
+ * `{ columns: [{ Template: 'row.ui' }] }`), and a NESTED helper class carrying the only real
+ * template. The rule's whole value is that it cannot be switched off by accident, so an accidental
+ * silencer is worse here than a missed case.
+ *
+ * A class defined INSIDE the static block still counts, which is pathological enough to leave.
+ */
+function declaresTemplate(body) {
+    for (const element of body.body) {
+        if (element.type === 'PropertyDefinition' || element.type === 'TSAbstractPropertyDefinition') {
+            const field = element;
+            const key = field.key;
+            if (field.static && !field.computed && key.type === 'Identifier' && key.name === 'Template') {
+                return true;
+            }
+            continue;
+        }
+        if (element.type === 'StaticBlock' && staticBlockDeclaresTemplate(element))
+            return true;
+    }
+    return false;
+}
+/** The nodes that own a scope here: a function is the unit a reader can move into a `.blp`. */
+const SCOPE_TYPES = new Set(['FunctionDeclaration', 'FunctionExpression', 'ArrowFunctionExpression']);
+/**
+ * How a scope is named in its own report. A class gets to be named by its base; a function has no
+ * base, so the message names the SHAPE the reader is looking at instead of saying "somewhere".
+ */
+function describeScope(node) {
+    if (node.type === 'Program')
+        return 'This module assembles an interface at top level';
+    if (node.type === 'FunctionDeclaration') {
+        const id = node.id;
+        const name = id?.type === 'Identifier' ? id.name : null;
+        return name === null ? 'This function assembles an interface' : `\`${name}()\` assembles an interface`;
+    }
+    return 'This callback assembles an interface';
+}
+/**
+ * Depth-first descent that attributes every construction and every parenting call to the nearest
+ * enclosing function, and refuses to enter a Gtk/Adw class body.
+ *
+ * It cannot be {@link walk}: walk's visitor is flat, and this needs a scope that is pushed on the
+ * way down and popped on the way out. The three skipped keys are walk's, for walk's reasons
+ * (`parent` loops; `tokens`/`comments` hang off Program and pass the structural node test).
+ */
+function descend(node, scope) {
+    // Skip exactly what `checkClass` owns — a widget subclass — so the two halves can never
+    // report one tree twice. NOT the wider `extends Gtk.*|Adw.*` test: that also skipped the
+    // APPLICATION bases, and an `activate` handler moved from a callback into
+    // `vfunc_activate()` of a `Gtk.Application` subclass then escaped the rule completely,
+    // which is the same bug this rule exists for wearing the most idiomatic GJS spelling.
+    // Measured before widening the entry: 0 new findings across this repository, and the
+    // false positive the application exemption was written for does not come back —
+    // `Gtk.CssProvider` is already a non-widget construction and an `Adw.AboutDialog` is
+    // presented rather than parented, so the both-signals requirement stays unsatisfied.
+    if ((node.type === 'ClassDeclaration' || node.type === 'ClassExpression') && gtkAdwSuperClass(node) !== null) {
+        return;
+    }
+    let current = scope;
+    if (SCOPE_TYPES.has(node.type)) {
+        current = { node, constructed: [], parents: false, children: [] };
+        scope.children.push(current);
+    }
+    const type = newGtkAdwType(node);
+    if (type !== null) {
+        if (!isNonWidgetConstruction(type) && !current.constructed.includes(type))
+            current.constructed.push(type);
+    }
+    else {
+        const method = memberCallName(node);
+        if (method !== null && PARENTING_METHODS.has(method))
+            current.parents = true;
+    }
+    for (const key of Object.keys(node)) {
+        if (key === 'parent' || key === 'tokens' || key === 'comments')
+            continue;
+        const value = node[key];
+        if (Array.isArray(value)) {
+            for (const item of value)
+                if (isNode(item))
+                    descend(item, current);
+        }
+        else if (isNode(value)) {
+            descend(value, current);
+        }
+    }
+}
+/** `Gtk.Box, Gtk.Label, Gtk.Button, +2 more` — the evidence, capped so a message stays readable. */
+function listConstructed(constructed) {
+    const shown = constructed.slice(0, 3).join(', ');
+    return constructed.length > 3 ? `${shown}, +${constructed.length - 3} more` : shown;
+}
+/** The half of the message that is the same wherever the assembly happened. */
+const WHY = 'a string set from TypeScript can never be marked translatable, so an interface built this ' +
+    'way cannot be translated at all. Populating data-driven children inside a template is fine ' +
+    'and is not reported.';
+export const preferBlueprintTemplateRule = {
+    create(context) {
+        const checkClass = (node) => {
+            const base = gtkAdwSuperClass(node);
+            if (base === null)
+                return;
+            const body = node.body;
+            if (!body || body.type !== 'ClassBody')
+                return;
+            if (declaresTemplate(body))
+                return;
+            const constructed = [];
+            let parents = false;
+            walk(body, (inner) => {
+                const type = newGtkAdwType(inner);
+                if (type !== null) {
+                    if (!isNonWidgetConstruction(type) && !constructed.includes(type))
+                        constructed.push(type);
+                    return;
+                }
+                const method = memberCallName(inner);
+                if (method !== null && PARENTING_METHODS.has(method))
+                    parents = true;
+            });
+            // BOTH signals, deliberately: constructing without parenting is a model or an
+            // adjustment, and parenting without constructing is moving an existing widget.
+            if (constructed.length === 0 || !parents)
+                return;
+            context.report({
+                message: `\`${base}\` subclass assembles its interface in TypeScript ` +
+                    `(${listConstructed(constructed)}) with no Blueprint \`Template\`. Declare the widget ` +
+                    `tree in a co-located \`.blp\` and keep only logic here — ${WHY}`,
+                node,
+            });
+        };
+        /**
+         * Report the DEEPEST scope that holds both signals, once.
+         *
+         * Signals bubble outward so that a function which builds a container and a callback which
+         * fills it are one finding rather than two halves that each look ordinary; reporting at the
+         * innermost scope that is already complete then puts the message on the code a reader can
+         * actually move into a `.blp`, instead of on the whole module.
+         */
+        const settle = (scope) => {
+            const constructed = [...scope.constructed];
+            let parents = scope.parents;
+            let reported = false;
+            for (const child of scope.children) {
+                const inner = settle(child);
+                for (const type of inner.constructed)
+                    if (!constructed.includes(type))
+                        constructed.push(type);
+                if (inner.parents)
+                    parents = true;
+                if (inner.reported)
+                    reported = true;
+            }
+            if (!reported && constructed.length > 0 && parents) {
+                context.report({
+                    message: `${describeScope(scope.node)} in TypeScript (${listConstructed(constructed)}) outside ` +
+                        `any widget class, so no Blueprint \`Template\` can hold it. Declare the widget tree ` +
+                        `in a co-located \`.blp\`, register it on a widget subclass and keep only logic here ` +
+                        `— ${WHY}`,
+                    node: scope.node,
+                });
+                reported = true;
+            }
+            return { constructed, parents, reported };
+        };
+        const checkModule = (program) => {
+            // The statements, not the Program node: `descend` skips `tokens`/`comments` by key, but
+            // starting at the body keeps that a belt-and-braces guard rather than the only one.
+            const root = { node: program, constructed: [], parents: false, children: [] };
+            for (const statement of program.body ?? [])
+                descend(statement, root);
+            settle(root);
+        };
+        return { ClassDeclaration: checkClass, ClassExpression: checkClass, Program: checkModule };
+    },
+};

package/lib/register-class-order.d.ts

@@ -0,0 +1,2 @@
+import type { Rule } from './types.ts';
+export declare const registerClassOrderRule: Rule;