kensington-eslint-plugin 0.3.0 → 0.3.2

package/README.md

@@ -470,7 +470,7 @@ Auto-fixable when the group's members are contiguous in the source. Non-contiguo
 
 ### `prefer-array-for-multiline-content`
 
-Mirrors what `html-to-kensington` emits: when a tag's content can't fit on the same line as the opening paren, it goes in an array, even when it's the only item. The array form makes line-by-line edits easier (no need to add `[ ]` when adding a sibling).
+Mirrors what `html-to-kensington` emits: when a tag's content occupies its own line(s) — separated from both the opening and closing paren — it goes in an array, even when it's the only item. The array form makes line-by-line edits easier (no need to add `[ ]` when adding a sibling).
 
 ```js
 // Bad
@@ -482,6 +482,12 @@ t.div({ class: 'x' },
 t.div({ class: 'x' }, [
   t.p('only'),
 ]);
+
+// Also good — content trails on the closing-paren line, no array needed
+t.a({
+  href: 'https://example.com',
+  target: '_blank',
+}, 'VS Code');
 ```
 
 Auto-fixable. Single-line calls (`t.div({…}, t.p('inner'))`) are left alone.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kensington-eslint-plugin",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "ESLint rules for kensington signal correctness",
   "type": "module",
   "main": "index.js",

package/rules/_utils.js

@@ -89,6 +89,28 @@ export function getObjectNames(context) {
   return context.options[0]?.objectNames ?? context.settings?.kensington?.objectNames;
 }
 
+// Default set of attribute namespaces — kebab prefixes whose hyphenated
+// children form an unbounded, namespaced family (data-*, aria-*). Mirrors the
+// Kensington `additionalNamespaces` defaults.
+export const DEFAULT_NAMESPACES = ['data', 'aria'];
+
+// Standard rule schema entry for the `namespaces` option.
+export const namespacesSchema = {
+  type: 'array',
+  items: { type: 'string' },
+  uniqueItems: true,
+};
+
+// Resolve `namespaces` from per-rule options first, then from plugin-level
+// settings (`settings.kensington.namespaces`), then from `DEFAULT_NAMESPACES`.
+export function getNamespaces(context) {
+  return (
+    context.options[0]?.namespaces
+    ?? context.settings?.kensington?.namespaces
+    ?? DEFAULT_NAMESPACES
+  );
+}
+
 // Returns the property key as a string, or null if computed/unrecognised.
 export function getPropertyKey(prop) {
   if (prop.type !== 'Property') { return null; }

package/rules/prefer-array-for-multiline-content.js

@@ -1,6 +1,8 @@
-// Tag content on a separate line from the call's opening paren must be wrapped
-// in an array, even when it's the only item. Mirrors what html-to-kensington
-// emits when a tag's content can't fit on a single line.
+// Tag content that occupies its own line(s) — separated from both the call's
+// opening paren and its closing paren — must be wrapped in an array, even when
+// it's the only item. Mirrors what html-to-kensington emits when a tag's
+// content can't fit on a single line. Content that trails on the closing-paren
+// line stays bare.
 
 import { isTagCall, getObjectNames, objectNamesSchema } from './_utils.js';
 
@@ -48,15 +50,18 @@ export default {
         if (content.type === 'SpreadElement') { return; }
 
         // The "opening line" is where the open paren sits — same line as the
-        // callee's last token. Content on that line stays bare.
+        // callee's last token. Content that touches either the opening-paren
+        // line or the closing-paren line stays bare.
         const openParenLine = node.callee.loc.end.line;
         if (content.loc.start.line <= openParenLine) { return; }
 
+        const closeParen = sourceCode.getLastToken(node);
+        if (closeParen && closeParen.value === ')' && content.loc.end.line >= closeParen.loc.start.line) { return; }
+
         context.report({
           node: content,
           messageId: 'wrapInArray',
           *fix(fixer) {
-            const closeParen = sourceCode.getLastToken(node);
             const tokenAfterContent = sourceCode.getTokenAfter(content);
             const hasTrailingComma = tokenAfterContent
               && tokenAfterContent.value === ','

package/rules/prefer-nested-attr-groups.js

@@ -1,29 +1,37 @@
-import { getTagAttrsObject, getPropertyKey, normalizeAttrName, kebabToCamel, isValidIdentifier, getObjectNames, objectNamesSchema } from './_utils.js';
+import { getTagAttrsObject, getPropertyKey, normalizeAttrName, kebabToCamel, isValidIdentifier, getObjectNames, getNamespaces, objectNamesSchema, namespacesSchema } from './_utils.js';
 
-// When two or more attribute keys share the same kebab-case prefix (e.g.
-// hxGet/hxTrigger/hxTarget or dataPageContent/dataPageNav), prefer the nested
-// object form: `hx: { get: ..., trigger: ..., target: ... }`.
+// When two or more attribute keys share the same namespace prefix (data-*,
+// aria-*, hx-*, etc.), prefer the nested object form. The default namespace
+// list is ['data', 'aria']; override via the `namespaces` option or
+// plugin-level `settings.kensington.namespaces`. The rule does NOT fire for
+// multi-word HTML/SVG attribute names that happen to share a word (e.g.
+// strokeWidth + strokeLinecap are separate attributes, not a "stroke
+// namespace").
 
 export default {
   meta: {
     type: 'suggestion',
     fixable: 'code',
     docs: {
-      description: 'prefer nested object form for attributes sharing a kebab-case prefix',
+      description: 'prefer nested object form for attributes sharing a namespace prefix',
     },
     schema: [{
       type: 'object',
-      properties: { objectNames: objectNamesSchema },
+      properties: {
+        objectNames: objectNamesSchema,
+        namespaces: namespacesSchema,
+      },
       additionalProperties: false,
     }],
     messages: {
-      preferNested: 'Attributes sharing the `{{prefix}}-` prefix should be nested under a single `{{prefix}}` key.',
+      preferNested: 'Attributes sharing the `{{prefix}}-` namespace should be nested under a single `{{prefix}}` key.',
     },
   },
 
   create(context) {
     const sourceCode = context.sourceCode;
     const objectNames = getObjectNames(context);
+    const namespaces = new Set(getNamespaces(context));
 
     return {
       CallExpression(node) {
@@ -40,6 +48,7 @@ export default {
           if (hy === -1) { continue; }
           const prefix = kebab.slice(0, hy);
           if (!isValidIdentifier(prefix)) { continue; }
+          if (!namespaces.has(prefix)) { continue; }
           if (!groups.has(prefix)) { groups.set(prefix, []); }
           groups.get(prefix).push({ prop, remainder: kebab.slice(hy + 1) });
         }