@gjsify/oxlint-plugin-gjsify 0.53.0

package/lib/register-class-order.js

@@ -0,0 +1,140 @@
+// `gjsify/register-class-order` — keep GObject metadata fields above the
+// `GObject.registerClass` static block.
+//
+// GJS classes register their GObject type from a `static { … }` block:
+//
+//     class MyWidget extends Gtk.Widget {
+//         static {
+//             GObject.registerClass({ GTypeName: 'MyWidget', … }, this);
+//         }
+//         static Properties = { … };   // ← read by registerClass, declared AFTER it
+//     }
+//
+// The alternate GJS idiom puts the GObject metadata in `static` class fields
+// (`static GTypeName`, `static Properties`, `static InternalChildren`, …) that
+// `GObject.registerClass(this)` reads off the class. When such a field is
+// declared AFTER the `static {}` block that calls `registerClass`, the
+// registration runs before the field is assigned — the metadata is silently
+// ignored. This rule flags those fields and hoists them above the block.
+//
+// Refs: GNOME/gjs#704, gjsify/ts-for-gir#410.
+/**
+ * GObject metadata keys that `GObject.registerClass` reads off a class (whether
+ * passed inline as the first argument or declared as `static` class fields).
+ * A `static` field whose key is one of these and that sits AFTER the
+ * registerClass static block is the bug this rule targets.
+ */
+const GOBJECT_METADATA_KEYS = new Set([
+    'GTypeName',
+    'GTypeFlags',
+    'Properties',
+    'Signals',
+    'InternalChildren',
+    'Children',
+    'Template',
+    'CssName',
+    'CssTemplate',
+    'Implements',
+    'Requires',
+]);
+function isStaticBlockCallingRegisterClass(el) {
+    if (el.type !== 'StaticBlock')
+        return false;
+    const body = el.body;
+    for (const stmt of body) {
+        if (stmt.type !== 'ExpressionStatement')
+            continue;
+        const expr = stmt.expression;
+        if (!expr || expr.type !== 'CallExpression')
+            continue;
+        const callee = expr.callee;
+        // Match `GObject.registerClass(...)` (and any `<X>.registerClass(...)`).
+        if (callee &&
+            callee.type === 'MemberExpression' &&
+            !callee.computed &&
+            callee.property?.type === 'Identifier' &&
+            callee.property.name === 'registerClass') {
+            return true;
+        }
+    }
+    return false;
+}
+/** Read the static-property key name when it is a plain (non-computed) identifier. */
+function staticMetadataKeyName(el) {
+    if (el.type !== 'PropertyDefinition' && el.type !== 'TSAbstractPropertyDefinition')
+        return null;
+    const field = el;
+    if (!field.static || field.computed)
+        return null;
+    const key = field.key;
+    if (key.type === 'Identifier' && typeof key.name === 'string')
+        return key.name;
+    return null;
+}
+export const registerClassOrderRule = {
+    meta: {
+        fixable: 'code',
+    },
+    create(context) {
+        return {
+            ClassBody(node) {
+                const elements = node.body;
+                // Find the FIRST static block that calls registerClass.
+                let blockIndex = -1;
+                let block = null;
+                for (let i = 0; i < elements.length; i++) {
+                    if (isStaticBlockCallingRegisterClass(elements[i])) {
+                        blockIndex = i;
+                        block = elements[i];
+                        break;
+                    }
+                }
+                if (blockIndex === -1 || block === null)
+                    return;
+                // Collect static GObject-metadata fields that appear AFTER it.
+                const offending = [];
+                for (let i = blockIndex + 1; i < elements.length; i++) {
+                    const key = staticMetadataKeyName(elements[i]);
+                    if (key !== null && GOBJECT_METADATA_KEYS.has(key)) {
+                        offending.push(elements[i]);
+                    }
+                }
+                if (offending.length === 0)
+                    return;
+                const blockNode = block;
+                const sourceText = context.sourceCode.text;
+                // One report per offending field for precise diagnostics, but a
+                // SINGLE combined autofix attached to the first report only.
+                // Reason: every field's hoist inserts at the same anchor (before
+                // the static block), so per-field fixes would conflict and oxlint
+                // applies only one per pass — `oxlint --fix` would need multiple
+                // runs to converge. A single combined fix hoists all fields in one
+                // pass and removes them (plus trailing whitespace, so no blank gap
+                // is left behind).
+                const combinedFix = (fixer) => {
+                    const hoisted = offending.map((f) => context.sourceCode.getText(f)).join('\n\n    ');
+                    const fixes = [fixer.insertTextBefore(blockNode, `${hoisted}\n\n    `)];
+                    for (const f of offending) {
+                        let removeEnd = f.end;
+                        while (removeEnd < sourceText.length && /[ \t\r\n]/.test(sourceText[removeEnd])) {
+                            removeEnd++;
+                        }
+                        fixes.push(fixer.removeRange([f.start, removeEnd]));
+                    }
+                    return fixes;
+                };
+                offending.forEach((field, idx) => {
+                    const keyName = staticMetadataKeyName(field) ?? 'field';
+                    context.report({
+                        message: `GObject metadata field \`static ${keyName}\` is declared after the \`GObject.registerClass\` ` +
+                            `static block — registerClass runs before it is assigned, so the metadata is ignored. ` +
+                            `Move it above the static block.`,
+                        node: field,
+                        // Attach the combined fix to the first report only.
+                        ...(idx === 0 ? { fix: combinedFix } : {}),
+                    });
+                });
+            },
+        };
+    },
+};

package/lib/spawn-node-binary.d.ts

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

package/lib/spawn-node-binary.js

@@ -0,0 +1,113 @@
+// `gjsify/spawn-node-binary` — spawning `process.execPath` assumes the CLI runs
+// under Node. Under the GJS bundle it does not, and the spawn starts the WRONG
+// interpreter.
+//
+// `spawn(process.execPath, […])` is the documented portable way to start a
+// second copy of the current runtime, and that is exactly what makes it wrong
+// here: this CLI is a DUAL-HOST program. Run from `lib/index.js` the current
+// runtime is Node; run from `dist/cli.gjs.mjs` it is GJS, where
+// `@gjsify/process` resolves `execPath` honestly to the interpreter binary
+// (`/proc/self/exe` → `/usr/bin/gjs-console` on Linux; `gjs` found on PATH on
+// macOS, which has no procfs — `@gjsify/utils`' `hostExecPath()`). Handing a Node script to that binary does not fail
+// with a missing-interpreter error — it RUNS, under the wrong engine, and dies
+// somewhere inside the payload.
+//
+// Measured on `gjsify workspace @gjsify/create-app build` with a GJS-hosted CLI
+// and `@gjsify/tsc`'s bundle not yet built (the normal state of a cold tree —
+// `build:infra` builds `@gjsify/create-app` fifth and `@gjsify/tsc` far later):
+//
+//     JS ERROR: ReferenceError: module is not defined
+//     @/…/node_modules/typescript/lib/tsc.js:8:1
+//     script "build" exited with code 1
+//
+// …because `commands/tsc.ts` spawned `process.execPath` for its upstream-`tsc`
+// fallback. On a host where `execPath` resolves to a gjsify launcher instead of
+// the raw interpreter, the same line re-executes the CLI and yargs reports the
+// tsc entry as `Unknown argument: …/typescript/lib/tsc.js`. One defect, two
+// faces, both invisible on Node.
+//
+// The fix is `nodeBinary()` from `utils/run-node.ts`: `process.execPath` when
+// `isNode()`, PATH `node` otherwise.
+//
+// WHY A RULE AND NOT A COMMENT. This was already the documented convention —
+// `oxc-resolve.ts`, `run-node.ts`, `test.ts`, `storybook.ts`, `showcase.ts` and
+// `install.ts` each carry a prose warning naming `nodeBinary()`, two of them in
+// capitals. Six copies of a rule and one file that never got it is the measured
+// outcome of enforcing an invariant with comments; `commands/tsc.ts` was that
+// file, for as long as the fallback existed.
+//
+// SCOPE — configured in `.oxlintrc.json` for `packages/infra/cli/src/**` only.
+// Everywhere else `process.execPath` is correct: Node-only build scripts
+// (`packages/infra/tsc/scripts/build-bundle.mjs`), Node-only test harnesses
+// (`packages/node-gi/**/test/*`) and `run-node.ts` itself, which is where the
+// one legitimate read lives. A repo-wide ban would flag all of those and would
+// be a rule about the wrong thing: the hazard is not the property, it is
+// spawning it from code that also runs under GJS.
+//
+// Flags only the COMMAND position (first argument). Passing the path as data —
+// `spawn(cmd, [process.execPath])`, `{ execPath: process.execPath }` — is fine
+// and stays silent. Not autofixable: `nodeBinary()` needs an import the rule
+// cannot place, and it is the wrong repair where the intent really was "this
+// interpreter" (`storybook.ts` re-dispatches in-process instead).
+/** `child_process` entry points whose first argument is the command to run. */
+const SPAWN_CALLEES = new Set(['spawn', 'spawnSync', 'execFile', 'execFileSync']);
+/** Is this node the member expression `process.execPath`? */
+function isProcessExecPath(node) {
+    if (!node || node.type !== 'MemberExpression' || node.computed === true)
+        return false;
+    const object = node.object;
+    const property = node.property;
+    return (object?.type === 'Identifier' &&
+        object.name === 'process' &&
+        property?.type === 'Identifier' &&
+        property.name === 'execPath');
+}
+/**
+ * The called name for `spawn(…)` and for `cp.spawn(…)` / `childProcess.spawn(…)`
+ * alike — the member form is how several call sites in this CLI spell it, and a
+ * rule that only understood the bare identifier would miss them.
+ */
+function calleeName(callee) {
+    if (!callee)
+        return undefined;
+    if (callee.type === 'Identifier')
+        return callee.name;
+    if (callee.type === 'MemberExpression' && callee.computed !== true) {
+        const property = callee.property;
+        if (property?.type === 'Identifier')
+            return property.name;
+    }
+    return undefined;
+}
+export const spawnNodeBinaryRule = {
+    meta: {
+        // No autofix — see the note in the file header.
+        fixable: false,
+    },
+    create(context) {
+        return {
+            CallExpression(node) {
+                const name = calleeName(node.callee);
+                if (!name || !SPAWN_CALLEES.has(name))
+                    return;
+                const args = node.arguments;
+                if (!Array.isArray(args) || args.length === 0)
+                    return;
+                const command = args[0];
+                if (!isProcessExecPath(command))
+                    return;
+                context.report({
+                    message: `\`${name}(process.execPath, …)\` assumes this CLI runs under Node. Under the GJS ` +
+                        'bundle `process.execPath` is the GJS interpreter (e.g. `gjs-console`), ' +
+                        'so this starts the wrong runtime — a Node script handed to GJS runs and then dies ' +
+                        'inside the payload (`ReferenceError: module is not defined`), which reads as a bug ' +
+                        'in the payload rather than in the spawn. Use `nodeBinary()` from ' +
+                        '`utils/run-node.ts` (`process.execPath` on Node, PATH `node` otherwise). If you ' +
+                        'genuinely mean "re-enter the CURRENT interpreter", say so in a reasoned ' +
+                        'oxlint-disable comment.',
+                    node: command,
+                });
+            },
+        };
+    },
+};

package/lib/todo-needs-anchor.d.ts

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

package/lib/todo-needs-anchor.js

@@ -0,0 +1,131 @@
+// `gjsify/todo-needs-anchor` — a deferral marker must name where it is tracked.
+//
+// A bare `// TODO` has no owner, no date and no retirement path. Nothing fails
+// when the work is done, nothing fails when it is abandoned, and it is invisible
+// until somebody happens to open the file. Measured on this repo at v0.29.0: of
+// 42 markers in source, 5 carried a reference and 37 did not — including
+// `// TODO: Fix this test`, i.e. a test documented as broken with no way for
+// anyone to notice it stayed that way.
+//
+// This is the ONE place the repo's own pattern was missing. Everywhere else a
+// deferral must state where it lives and dies on its own:
+//
+//   `it.failing(name, fn, reason)`        runs the test, FAILS the day it passes
+//   `unchecked-fields.mjs`                key → reason, FAILS when a rule claims it
+//   `gjsify.platformsUncommitted`         target → reason, FAILS when the dir appears
+//   `// fixed upstream in gjsify: …`      removed on the next version bump
+//
+// Each one is mandatory-reason plus self-retirement. A bare marker is neither.
+//
+// SCOPE — this rule does not ban deferral, it bans an UNTRACKED one. Three
+// anchors are accepted, matching the three channels in AGENTS.md:
+//
+//   `#123`                 a GitHub issue or PR — work needing discussion or a
+//                          third party
+//   `open-todos`           an entry under `status/open-todos/` (one file per
+//                          area), which the `status-data` conformance rule
+//                          already validates on every PR (it fails on
+//                          resolved-TODO corpses)
+//   `fixed upstream in …`  the cross-repo shim note, removed at the next bump
+//
+// The anchor must sit in the SAME comment as the marker: an anchor a reader has
+// to go find is not evidence, and a block comment is one comment, so a `#123`
+// anywhere in a JSDoc block covers a marker inside it.
+//
+// Comments are read through `sourceCode.getAllComments()` rather than by
+// scanning the source text, so a marker inside a STRING is not a finding — the
+// `--- outcomes:` style probe strings and this repo's own error messages contain
+// the words. A text scan cannot tell a comment from a quoted one; that is the
+// same distinction `gjs-bundle-guard.ts` documents for `node:` specifiers.
+//
+// Escape hatch is the ordinary lint one, and it carries a reason by convention:
+// `// oxlint-disable-next-line gjsify/todo-needs-anchor -- <why>`. `.oxlintrc.json`
+// already fails on a disable directive that suppresses nothing, so a stale
+// exemption cannot sit there quietly either.
+//
+// Reference: AGENTS.md § Deferrals must name where they are tracked.
+/**
+ * A deferral marker OPENS its line — `// TODO wire this up`, or the same after
+ * a block comment's leading `*`. Matched as a whole word so `TODOS` and an
+ * identifier like `todoCount` are not findings, and case-sensitively, because
+ * the convention is upper-case.
+ *
+ * Line-start is what separates a marker from PROSE ABOUT one. This file, the
+ * `status-data` conformance rule and `generate-status.mjs` all discuss TODOs in
+ * sentences ("a bare `// TODO` has no owner"), and flagging those would make the
+ * rule unable to document itself — measured: 5 of the first 31 findings were
+ * exactly that, three of them in this file. The cost is a mid-sentence deferral
+ * ("handle the empty case. TODO") going unseen; that shape is rare, and the
+ * false positives it would buy are not worth it.
+ */
+const MARKER = /^(TODO|FIXME|HACK|XXX)\b/;
+/** Strip a block comment's leading `*` and indentation from one line. */
+function openingWord(line) {
+    return line.replace(/^\s*\*?\s*/, '');
+}
+/**
+ * An anchor that makes the deferral trackable. `#123` covers this repo's issues
+ * and PRs; a forge issue URL covers an UPSTREAM defect (GNOME GitLab, another
+ * GitHub repo) that no local number can name; `open-todos` covers the ledger
+ * under `status/`; `fixed upstream in` covers the temporary shim note.
+ *
+ * The URL form is not optional politeness — `error-handler.spec.ts` cites
+ * https://gitlab.gnome.org/GNOME/gjs/-/issues/523 for an object-identity gap,
+ * which is BETTER tracked than a local issue would be. A rule that flagged it
+ * would be teaching people to delete the most useful reference in the file.
+ */
+const ANCHOR = /#\d+|\/(?:issues|pull|merge_requests)\/\d+|open-todos|fixed upstream in/i;
+export const todoNeedsAnchorRule = {
+    meta: {
+        // No autofix — only a human knows whether the right repair is fixing it
+        // now, filing an issue, or adding a ledger entry.
+        fixable: false,
+    },
+    create(context) {
+        // `getAllComments` is not in the local typings (they model only what the
+        // other two rules need) and is absent on older oxlint hosts. Degrade to
+        // a no-op rather than throwing: a lint rule that crashes the run is
+        // worse than one that reports nothing.
+        const source = context.sourceCode;
+        if (typeof source.getAllComments !== 'function')
+            return {};
+        let checked = false;
+        const check = () => {
+            if (checked)
+                return;
+            checked = true;
+            for (const comment of source.getAllComments()) {
+                if (comment.type === 'Shebang')
+                    continue;
+                // The anchor may sit anywhere in the comment — a `#123` in a
+                // JSDoc block covers a marker inside it — so it is tested
+                // against the whole value, the marker only per line.
+                if (ANCHOR.test(comment.value))
+                    continue;
+                let marker = null;
+                for (const line of comment.value.split('\n')) {
+                    marker = MARKER.exec(openingWord(line));
+                    if (marker)
+                        break;
+                }
+                if (!marker)
+                    continue;
+                context.report({
+                    message: `Untracked \`${marker[1]}\`. A deferral marker must name where it is tracked, or ` +
+                        'nothing fails when the work is finished and nothing fails when it is dropped. ' +
+                        'Pick the channel: fix it in THIS PR (the root-cause rule — preferred, and the ' +
+                        'reason this codebase has few of these); add an entry under `status/open-todos/` ' +
+                        'and cite it here, which the `status-data` conformance rule then validates every ' +
+                        'PR; or open an issue and cite `#<number>` when the work needs discussion or ' +
+                        'somebody else. A cross-repo shim writes `// fixed upstream in gjsify: <one-line>` ' +
+                        'instead. If the marker is prose rather than a deferral, rewrite it — the word is ' +
+                        'the signal.',
+                    node: comment,
+                });
+            }
+        };
+        // Comments are file-scoped, so one pass per file. `Program` fires once
+        // and is present in every parse, including an empty file.
+        return { Program: check };
+    },
+};

package/lib/types.d.ts

@@ -0,0 +1,78 @@
+/** Half-open byte range `[start, end)` over the source text. */
+export type Range = [number, number];
+/** Anything the fixer can target — a node or token with a `range`. */
+export interface Ranged {
+    range: Range;
+}
+/** Generic AST node. Only the fields the rule touches are modelled. */
+export interface Node extends Ranged {
+    type: string;
+    start: number;
+    end: number;
+    parent?: Node;
+    [key: string]: unknown;
+}
+export interface ClassBody extends Node {
+    type: 'ClassBody';
+    body: ClassElement[];
+}
+export interface ClassElement extends Node {
+    type: string;
+    static?: boolean;
+}
+export interface PropertyDefinition extends Node {
+    type: 'PropertyDefinition' | 'TSAbstractPropertyDefinition';
+    static: boolean;
+    computed: boolean;
+    key: Node;
+    value: Node | null;
+}
+export interface StaticBlock extends Node {
+    type: 'StaticBlock';
+    body: Node[];
+}
+/** A single fix produced by the {@link Fixer}. */
+export interface Fix {
+    range: Range;
+    text: string;
+}
+/** Frozen fixer handed to a `fix` function. Subset of oxlint's full Fixer. */
+export interface Fixer {
+    insertTextBefore(nodeOrToken: Ranged, text: string): Fix;
+    insertTextAfter(nodeOrToken: Ranged, text: string): Fix;
+    replaceText(nodeOrToken: Ranged, text: string): Fix;
+    remove(nodeOrToken: Ranged): Fix;
+    insertTextBeforeRange(range: Range, text: string): Fix;
+    removeRange(range: Range): Fix;
+}
+export type FixFn = (fixer: Fixer) => Fix | Fix[] | null;
+export interface Diagnostic {
+    message: string;
+    node: Node;
+    fix?: FixFn;
+}
+export interface SourceCode {
+    text: string;
+    getText(node?: Ranged | null, beforeCount?: number | null, afterCount?: number | null): string;
+}
+export interface Context {
+    filename: string;
+    sourceCode: SourceCode;
+    report(diagnostic: Diagnostic): void;
+}
+/** Visitor object: maps AST node type → handler. */
+export type Visitor = Record<string, (node: Node) => void>;
+export interface RuleMeta {
+    fixable?: 'code' | 'whitespace' | boolean;
+    [key: string]: unknown;
+}
+export interface Rule {
+    meta?: RuleMeta;
+    create(context: Context): Visitor;
+}
+export interface Plugin {
+    meta: {
+        name: string;
+    };
+    rules: Record<string, Rule>;
+}

package/lib/types.js

@@ -0,0 +1,10 @@
+// Minimal local typings for the subset of the oxlint JS-plugin API this
+// plugin uses. The published `oxlint` package (1.66/1.67) does not export the
+// `Plugin` / `Rule` / `Context` / `Fixer` types yet, so we declare just what
+// `register-class-order` needs. Shapes mirror
+// `refs/oxc/apps/oxlint/src-js/plugins/{load,context,fix,report}.ts` and the
+// ESTree nodes in `refs/oxc/apps/oxlint/src-js/generated/types.d.ts`.
+//
+// Reference: refs/oxc/apps/oxlint/src-js/plugins/*. Copyright (c) oxc
+// contributors. MIT.
+export {};

package/lib/walk.d.ts

@@ -0,0 +1,26 @@
+import type { Node } from './types.ts';
+/**
+ * True for a plain object that carries the shape of an AST node.
+ *
+ * Exported because a rule that needs its OWN traversal state (a scope stack, say) cannot express
+ * it through {@link walk}'s flat visitor, and re-deriving this test per rule is how two answers to
+ * "is this a node" drift apart. The structural caveat in {@link walk} applies to every caller.
+ */
+export declare function isNode(value: unknown): value is Node;
+/**
+ * Depth-first walk over every node in `root`'s subtree, `root` included.
+ *
+ * THREE keys are skipped, for two different reasons. `parent`, because where the host populates it,
+ * following it walks back out of the subtree and loops forever. `tokens` and `comments`, because
+ * oxlint hangs both off the Program node and `isNode` is a STRUCTURAL sniff — a token object has a
+ * `type` string, so it looks exactly like a node. Measured: walking them accounted for the large
+ * majority of these rules' wall-clock and visited nothing either rule can act on.
+ *
+ * That structural sniff is the general hazard: anything with a string `type` is followed. Hand this
+ * function the smallest root that contains what you need, not the Program node.
+ */
+export declare function walk(root: Node, visit: (node: Node) => void): void;
+/** `new Gtk.Label(…)` / `new Adw.ActionRow(…)` → `"Gtk.Label"` / `"Adw.ActionRow"`; else null. */
+export declare function newGtkAdwType(node: Node): string | null;
+/** The method name of `x.foo(…)`, or null for anything that is not a plain member call. */
+export declare function memberCallName(node: Node): string | null;

package/lib/walk.js

@@ -0,0 +1,73 @@
+// Shared subtree walker for the class-scoped rules.
+//
+// oxlint's JS-plugin visitor dispatches per node TYPE, which is enough for a rule that only
+// inspects a class's DIRECT children (`register-class-order`). A rule that asks "does this class
+// build widgets anywhere inside it" needs the whole subtree, and `Node.parent` is not something
+// the plugin host guarantees to populate — so the traversal is owned here rather than inferred
+// from a parent chain that may not exist.
+/**
+ * True for a plain object that carries the shape of an AST node.
+ *
+ * Exported because a rule that needs its OWN traversal state (a scope stack, say) cannot express
+ * it through {@link walk}'s flat visitor, and re-deriving this test per rule is how two answers to
+ * "is this a node" drift apart. The structural caveat in {@link walk} applies to every caller.
+ */
+export function isNode(value) {
+    return typeof value === 'object' && value !== null && typeof value.type === 'string';
+}
+/**
+ * Depth-first walk over every node in `root`'s subtree, `root` included.
+ *
+ * THREE keys are skipped, for two different reasons. `parent`, because where the host populates it,
+ * following it walks back out of the subtree and loops forever. `tokens` and `comments`, because
+ * oxlint hangs both off the Program node and `isNode` is a STRUCTURAL sniff — a token object has a
+ * `type` string, so it looks exactly like a node. Measured: walking them accounted for the large
+ * majority of these rules' wall-clock and visited nothing either rule can act on.
+ *
+ * That structural sniff is the general hazard: anything with a string `type` is followed. Hand this
+ * function the smallest root that contains what you need, not the Program node.
+ */
+export function walk(root, visit) {
+    visit(root);
+    for (const key of Object.keys(root)) {
+        if (key === 'parent' || key === 'tokens' || key === 'comments')
+            continue;
+        const value = root[key];
+        if (Array.isArray(value)) {
+            for (const item of value)
+                if (isNode(item))
+                    walk(item, visit);
+        }
+        else if (isNode(value)) {
+            walk(value, visit);
+        }
+    }
+}
+/** `new Gtk.Label(…)` / `new Adw.ActionRow(…)` → `"Gtk.Label"` / `"Adw.ActionRow"`; else null. */
+export function newGtkAdwType(node) {
+    if (node.type !== 'NewExpression')
+        return null;
+    const callee = node.callee;
+    if (!callee || callee.type !== 'MemberExpression' || callee.computed === true)
+        return null;
+    const object = callee.object;
+    const property = callee.property;
+    if (object?.type !== 'Identifier' || property?.type !== 'Identifier')
+        return null;
+    const ns = object.name;
+    if (ns !== 'Gtk' && ns !== 'Adw')
+        return null;
+    return `${ns}.${property.name}`;
+}
+/** The method name of `x.foo(…)`, or null for anything that is not a plain member call. */
+export function memberCallName(node) {
+    if (node.type !== 'CallExpression')
+        return null;
+    const callee = node.callee;
+    if (!callee || callee.type !== 'MemberExpression' || callee.computed === true)
+        return null;
+    const property = callee.property;
+    if (property?.type !== 'Identifier')
+        return null;
+    return property.name;
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+    "name": "@gjsify/oxlint-plugin-gjsify",
+    "version": "0.53.0",
+    "description": "oxlint JS plugin with gjsify's own lint rules for GJS/GTK code — Blueprint templates, translatable widget labels, GObject.registerClass field order, GJS-correct process exit, anchored deferral markers, and the CSS side-effect import that tree-shakes away. Wire it through `jsPlugins` in `.oxlintrc.json`.",
+    "type": "module",
+    "main": "lib/index.js",
+    "module": "lib/index.js",
+    "types": "lib/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./lib/index.d.ts",
+            "default": "./lib/index.js"
+        },
+        "./package.json": "./package.json"
+    },
+    "files": [
+        "lib"
+    ],
+    "scripts": {
+        "clear": "gjsify clear lib tsconfig.tsbuildinfo",
+        "check": "gjsify tsc --noEmit",
+        "build": "gjsify tsc -p tsconfig.build.json"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/gjsify/gjsify.git",
+        "directory": "packages/infra/oxlint-plugin-gjsify"
+    },
+    "bugs": {
+        "url": "https://github.com/gjsify/gjsify/issues"
+    },
+    "homepage": "https://github.com/gjsify/gjsify/tree/main/packages/infra/oxlint-plugin-gjsify#readme",
+    "keywords": [
+        "oxlint",
+        "oxc",
+        "plugin",
+        "gjs",
+        "gtk",
+        "blueprint",
+        "gobject",
+        "lint"
+    ],
+    "license": "MIT",
+    "peerDependencies": {
+        "oxlint": "^1.72.0"
+    },
+    "devDependencies": {
+        "@gjsify/cli": "^0.53.0",
+        "@types/node": "^25.9.2",
+        "typescript": "^6.0.3"
+    },
+    "gjsify": {
+        "tier": 1
+    }
+}