kensington-eslint-plugin 0.2.2 → 0.3.0

package/rules/_utils.js

@@ -0,0 +1,138 @@
+// Shared helpers used by the formatting rules.
+
+// HTML boolean attributes per the WHATWG HTML spec. Kebab-case form is the
+// attribute name; camelCase keys (e.g. `formNoValidate`) also match because the
+// tag-call check looks at the key text after camel-to-kebab conversion.
+export const HTML_BOOLEAN_ATTRS = new Set([
+  'allowfullscreen',
+  'async',
+  'autofocus',
+  'autoplay',
+  'checked',
+  'controls',
+  'default',
+  'defer',
+  'disabled',
+  'formnovalidate',
+  'hidden',
+  'inert',
+  'ismap',
+  'itemscope',
+  'loop',
+  'multiple',
+  'muted',
+  'nomodule',
+  'novalidate',
+  'open',
+  'playsinline',
+  'readonly',
+  'required',
+  'reversed',
+  'selected',
+  'shadowrootclonable',
+  'shadowrootdelegatesfocus',
+  'shadowrootserializable',
+]);
+
+export function camelToKebab(str) {
+  return str.replace(/[A-Z]+(?![a-z])|[A-Z]/g, ($, ofs) => (ofs ? '-' : '') + $.toLowerCase());
+}
+
+export function kebabToCamel(str) {
+  return str.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+
+// `name` may be a quoted-kebab string ('aria-label') or a camelCase identifier
+// (ariaLabel). Returns the kebab-case form.
+export function normalizeAttrName(name) {
+  return name.includes('-') ? name : camelToKebab(name);
+}
+
+// Returns true when an identifier name is a safe JS identifier.
+const IDENT_RE = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+export function isValidIdentifier(str) {
+  return IDENT_RE.test(str);
+}
+
+// Tag-method matcher: callee is `<obj>.<lowercaseMethod>(...)` where `<obj>` is
+// in `objectNames` (default `['t']`, the documented Kensington convention).
+// Returns the call's first ObjectExpression argument (the attributes object) or
+// null when the call doesn't look like a tag call with attributes.
+export function isTagCall(node, objectNames = ['t']) {
+  if (node.type !== 'CallExpression') { return false; }
+  if (node.callee.type !== 'MemberExpression') { return false; }
+  if (node.callee.object.type !== 'Identifier') { return false; }
+  if (!objectNames.includes(node.callee.object.name)) { return false; }
+  if (node.callee.property.type !== 'Identifier') { return false; }
+  if (!/^[a-z][a-zA-Z0-9]*$/.test(node.callee.property.name)) { return false; }
+  return true;
+}
+
+export function getTagAttrsObject(node, objectNames) {
+  if (!isTagCall(node, objectNames)) { return null; }
+  const first = node.arguments[0];
+  if (!first || first.type !== 'ObjectExpression') { return null; }
+  return first;
+}
+
+// Standard rule schema entry for the `objectNames` option.
+export const objectNamesSchema = {
+  type: 'array',
+  items: { type: 'string' },
+  uniqueItems: true,
+};
+
+// Resolve `objectNames` from per-rule options first, then from plugin-level
+// settings (`settings.kensington.objectNames`). Returns undefined when neither
+// is set, letting the helpers fall back to the built-in default of `['t']`.
+export function getObjectNames(context) {
+  return context.options[0]?.objectNames ?? context.settings?.kensington?.objectNames;
+}
+
+// Returns the property key as a string, or null if computed/unrecognised.
+export function getPropertyKey(prop) {
+  if (prop.type !== 'Property') { return null; }
+  if (prop.computed) { return null; }
+  if (prop.key.type === 'Identifier') { return prop.key.name; }
+  if (prop.key.type === 'Literal' && typeof prop.key.value === 'string') { return prop.key.value; }
+  return null;
+}
+
+// Split a CSS declaration string ("color: red; z-index: 2") into entries.
+// Respects quoted values so semicolons inside strings don't split.
+export function splitCssDeclarations(css) {
+  const result = [];
+  let current = '';
+  let inStr = null;
+  for (const c of css) {
+    if (inStr) {
+      current += c;
+      if (c === inStr) { inStr = null; }
+    } else if (c === '"' || c === "'") {
+      inStr = c;
+      current += c;
+    } else if (c === ';') {
+      result.push(current);
+      current = '';
+    } else {
+      current += c;
+    }
+  }
+  if (current.trim()) { result.push(current); }
+  return result;
+}
+
+// Parse a CSS string into { property, value } entries. Returns null if any
+// declaration is malformed.
+export function parseStyleString(css) {
+  const entries = [];
+  for (const decl of splitCssDeclarations(css)) {
+    const i = decl.indexOf(':');
+    if (i === -1) { continue; }
+    const prop = decl.slice(0, i).trim();
+    const val = decl.slice(i + 1).trim();
+    if (!prop || !val) { continue; }
+    entries.push({ property: prop, value: val });
+  }
+  return entries.length ? entries : null;
+}

package/rules/attrs-canonical-shape.js

@@ -0,0 +1,102 @@
+import { getTagAttrsObject, getObjectNames, objectNamesSchema } from './_utils.js';
+
+// An attributes object must be in one of two canonical forms:
+//   inline:   { a: 1, b: 2 }            — every token on the same line.
+//   stacked:  {                         — `{` ends its line,
+//               a: 1,                     each property on its own line,
+//               b: 2,                     `}` begins its line.
+//             }
+// Any mixed form (open brace adjacent to first prop in a multi-line body, close
+// brace adjacent to last prop, or two props sharing a line) is reported.
+
+export default {
+  meta: {
+    type: 'layout',
+    fixable: 'whitespace',
+    docs: {
+      description: 'attributes object must be inline or in canonical stacked form',
+    },
+    schema: [{
+      type: 'object',
+      properties: { objectNames: objectNamesSchema },
+      additionalProperties: false,
+    }],
+    messages: {
+      mixedLayout: 'Attribute properties must all be on the same line or each on its own line.',
+      openBraceMustEndLine: 'Opening brace of a multi-line attributes object must end its line.',
+      closeBraceMustStartLine: 'Closing brace of a multi-line attributes object must start its line.',
+    },
+  },
+
+  create(context) {
+    const sourceCode = context.sourceCode;
+    const objectNames = getObjectNames(context);
+
+    function leadingIndent(node) {
+      const line = sourceCode.lines[node.loc.start.line - 1];
+      const match = line.match(/^(\s*)/);
+      return match ? match[1] : '';
+    }
+
+    function buildStackedText(attrs, baseIndent) {
+      const propIndent = `${baseIndent}  `;
+      const props = attrs.properties.map(p => sourceCode.getText(p));
+      return `{\n${props.map(t => `${propIndent}${t},`).join('\n')}\n${baseIndent}}`;
+    }
+
+    function hasInteriorComments(attrs) {
+      return sourceCode.getCommentsInside(attrs).length > 0;
+    }
+
+    return {
+      CallExpression(node) {
+        const attrs = getTagAttrsObject(node, objectNames);
+        if (!attrs) { return; }
+        if (attrs.properties.length < 2) { return; }
+
+        const props = attrs.properties;
+        const openLine = attrs.loc.start.line;
+        const closeLine = attrs.loc.end.line;
+        const first = props[0];
+        const last = props[props.length - 1];
+
+        const allInline =
+          openLine === closeLine &&
+          props.every(p => p.loc.start.line === openLine && p.loc.end.line === openLine);
+
+        if (allInline) { return; }
+
+        const openBraceOk = first.loc.start.line > openLine;
+        const closeBraceOk = last.loc.end.line < closeLine;
+
+        let propsLayoutOk = true;
+        for (let i = 1; i < props.length; i++) {
+          if (props[i].loc.start.line <= props[i - 1].loc.end.line) {
+            propsLayoutOk = false;
+            break;
+          }
+        }
+
+        if (openBraceOk && closeBraceOk && propsLayoutOk) { return; }
+
+        const baseIndent = leadingIndent(node);
+        const canFix = !hasInteriorComments(attrs);
+        const fix = canFix
+          ? (fixer => fixer.replaceText(attrs, buildStackedText(attrs, baseIndent)))
+          : null;
+
+        if (!propsLayoutOk) {
+          context.report({ node: attrs, messageId: 'mixedLayout', fix });
+          return;
+        }
+        if (!openBraceOk) {
+          context.report({ node: attrs, messageId: 'openBraceMustEndLine', fix });
+          return;
+        }
+        if (!closeBraceOk) {
+          context.report({ node: attrs, messageId: 'closeBraceMustStartLine', fix });
+        }
+      },
+    };
+  },
+};

package/rules/attrs-on-call-line.js

@@ -0,0 +1,82 @@
+import { getTagAttrsObject, getObjectNames, objectNamesSchema } from './_utils.js';
+
+// The attributes object hugs the call on both ends:
+//   - the opening `{` sits on the same line as the call's `(`, and
+//   - the closing `}` sits on the same line as the content (or its `[`) when
+//     there is a content arg, or on the same line as the call's `)` when there
+//     is not.
+
+export default {
+  meta: {
+    type: 'layout',
+    fixable: 'whitespace',
+    docs: {
+      description: 'attributes object must hug the tag call on both ends',
+    },
+    schema: [{
+      type: 'object',
+      properties: { objectNames: objectNamesSchema },
+      additionalProperties: false,
+    }],
+    messages: {
+      attrsMustStartOnCallLine: 'Attributes object must start on the same line as the tag call.',
+      attrsMustEndOnContentLine: 'Closing brace of attributes object must be on the same line as the content.',
+      attrsMustEndOnCloseParenLine: 'Closing brace of attributes object must be on the same line as the closing parenthesis.',
+    },
+  },
+
+  create(context) {
+    const sourceCode = context.sourceCode;
+    const objectNames = getObjectNames(context);
+
+    return {
+      CallExpression(node) {
+        const attrs = getTagAttrsObject(node, objectNames);
+        if (!attrs) { return; }
+
+        // Open-brace check: `{` on the same line as `(`.
+        const openParen = sourceCode.getTokenAfter(node.callee);
+        if (openParen && attrs.loc.start.line > openParen.loc.end.line) {
+          const between = sourceCode.text.slice(openParen.range[1], attrs.range[0]);
+          const hasComment = /\/\/|\/\*/.test(between);
+          context.report({
+            node: attrs,
+            messageId: 'attrsMustStartOnCallLine',
+            fix: hasComment
+              ? null
+              : (fixer => fixer.replaceTextRange([openParen.range[1], attrs.range[0]], '')),
+          });
+        }
+
+        // Close-brace check: `}` on the same line as the next anchor.
+        if (node.arguments.length === 2) {
+          const content = node.arguments[1];
+          if (attrs.loc.end.line < content.loc.start.line) {
+            const between = sourceCode.text.slice(attrs.range[1], content.range[0]);
+            const hasComment = /\/\/|\/\*/.test(between);
+            context.report({
+              node: attrs,
+              messageId: 'attrsMustEndOnContentLine',
+              fix: hasComment
+                ? null
+                : (fixer => fixer.replaceTextRange([attrs.range[1], content.range[0]], ', ')),
+            });
+          }
+        } else if (node.arguments.length === 1) {
+          const closeParen = sourceCode.getLastToken(node);
+          if (closeParen && closeParen.value === ')' && attrs.loc.end.line < closeParen.loc.start.line) {
+            const between = sourceCode.text.slice(attrs.range[1], closeParen.range[0]);
+            const hasComment = /\/\/|\/\*/.test(between);
+            context.report({
+              node: attrs,
+              messageId: 'attrsMustEndOnCloseParenLine',
+              fix: hasComment
+                ? null
+                : (fixer => fixer.replaceTextRange([attrs.range[1], closeParen.range[0]], '')),
+            });
+          }
+        }
+      },
+    };
+  },
+};

package/rules/consistent-content-layout.js

@@ -0,0 +1,109 @@
+import { isTagCall, getObjectNames, objectNamesSchema } from './_utils.js';
+
+// Tag content (or its opening `[`) must begin on the same line as the anchor
+// before it — the attrs object's `}` for two-arg calls, or the call's `(` for
+// one-arg calls. Content must also end on the same line as the call's `)`.
+
+export default {
+  meta: {
+    type: 'layout',
+    fixable: 'whitespace',
+    docs: {
+      description: 'tag content must start on the call/attrs line and end on the closing-paren line',
+    },
+    schema: [{
+      type: 'object',
+      properties: { objectNames: objectNamesSchema },
+      additionalProperties: false,
+    }],
+    messages: {
+      contentMustStartOnAnchorLine: 'Tag content must start on the same line as {{anchor}}.',
+      contentMustEndOnClosingParenLine: 'Tag content must end on the same line as the closing parenthesis.',
+    },
+  },
+
+  create(context) {
+    const sourceCode = context.sourceCode;
+    const objectNames = getObjectNames(context);
+
+    function getContentArg(node) {
+      if (node.arguments.length === 1) {
+        const arg = node.arguments[0];
+        if (arg.type === 'ObjectExpression') { return null; }
+        return arg;
+      }
+      if (node.arguments.length === 2) {
+        if (node.arguments[0].type !== 'ObjectExpression') { return null; }
+        return node.arguments[1];
+      }
+      return null;
+    }
+
+    return {
+      CallExpression(node) {
+        if (!isTagCall(node, objectNames)) { return; }
+
+        const content = getContentArg(node);
+        if (!content) { return; }
+        if (content.type === 'SpreadElement') { return; }
+
+        const closeParen = sourceCode.getLastToken(node);
+        if (!closeParen || closeParen.value !== ')') { return; }
+
+        // Start check: content must begin on the anchor's line.
+        if (node.arguments.length === 2) {
+          const attrs = node.arguments[0];
+          if (content.loc.start.line > attrs.loc.end.line) {
+            const commaToken = sourceCode.getTokenAfter(attrs);
+            if (commaToken && commaToken.value === ',') {
+              const between = sourceCode.text.slice(commaToken.range[1], content.range[0]);
+              const hasComment = /\/\/|\/\*/.test(between);
+              context.report({
+                node: content,
+                messageId: 'contentMustStartOnAnchorLine',
+                data: { anchor: "the attributes object's closing brace" },
+                fix: hasComment
+                  ? null
+                  : (fixer => fixer.replaceTextRange([commaToken.range[1], content.range[0]], ' ')),
+              });
+            }
+          }
+        } else {
+          const openParen = sourceCode.getTokenAfter(node.callee);
+          if (openParen && content.loc.start.line > openParen.loc.end.line) {
+            const between = sourceCode.text.slice(openParen.range[1], content.range[0]);
+            const hasComment = /\/\/|\/\*/.test(between);
+            context.report({
+              node: content,
+              messageId: 'contentMustStartOnAnchorLine',
+              data: { anchor: "the tag method call's opening parenthesis" },
+              fix: hasComment
+                ? null
+                : (fixer => fixer.replaceTextRange([openParen.range[1], content.range[0]], '')),
+            });
+          }
+        }
+
+        // End check: content must end on the closing paren's line. If there's a
+        // trailing comma right after content, treat that as part of the end.
+        const tokenAfterContent = sourceCode.getTokenAfter(content);
+        const endBoundary = tokenAfterContent && tokenAfterContent.value === ',' && tokenAfterContent.range[0] < closeParen.range[0]
+          ? tokenAfterContent
+          : content;
+        const endBoundaryLine = endBoundary === content ? content.loc.end.line : endBoundary.loc.end.line;
+
+        if (endBoundaryLine < closeParen.loc.start.line) {
+          const between = sourceCode.text.slice(endBoundary.range[1], closeParen.range[0]);
+          const hasComment = /\/\/|\/\*/.test(between);
+          context.report({
+            node: content,
+            messageId: 'contentMustEndOnClosingParenLine',
+            fix: hasComment
+              ? null
+              : (fixer => fixer.replaceTextRange([endBoundary.range[1], closeParen.range[0]], '')),
+          });
+        }
+      },
+    };
+  },
+};

package/rules/{no-set-in-transform.js → no-set-in-derivation.js}

@@ -1,14 +1,16 @@
-// Reports .set() calls inside a .transform() callback.
-// Stops searching when a nested effect() or computed() is reached (separate reactive context).
+// Reports .set() calls inside a derivation — a computed() callback or a
+// .transform() callback. Derivations must be pure; writing inside them causes
+// a write during a read pass. Stops searching when a nested effect() or
+// non-derivation function boundary is reached.
 export default {
   meta: {
     type: 'problem',
     docs: {
-      description: 'disallow .set() inside a .transform() callback',
+      description: 'disallow .set() inside a computed() body or .transform() callback',
     },
     messages: {
-      noSetInTransform:
-        '.set() called inside a .transform() callback. Transform functions must be pure derivations. ' +
+      noSetInDerivation:
+        '.set() called inside a {{kind}}. Derivations must be pure. ' +
         'Move the write into a separate effect() instead.',
     },
   },
@@ -16,7 +18,8 @@ export default {
   create(context) {
     const computedNames = new Set();
     const effectNames = new Set();
-    // Each entry is 'transform', 'computed', 'effect', or 'other' — innermost frame is last.
+    // Each entry is 'computed', 'transform', 'effect', 'handler', or 'other' —
+    // innermost frame is last.
     const fnStack = [];
 
     return {
@@ -72,11 +75,16 @@ export default {
         ) { return; }
 
         for (let i = fnStack.length - 1; i >= 0; i--) {
-          if (fnStack[i] === 'transform') {
-            context.report({ node, messageId: 'noSetInTransform' });
+          const frame = fnStack[i];
+          if (frame === 'computed') {
+            context.report({ node, messageId: 'noSetInDerivation', data: { kind: 'computed() body' } });
             return;
           }
-          if (fnStack[i] === 'effect' || fnStack[i] === 'computed' || fnStack[i] === 'handler') { return; }
+          if (frame === 'transform') {
+            context.report({ node, messageId: 'noSetInDerivation', data: { kind: '.transform() callback' } });
+            return;
+          }
+          if (frame === 'effect' || frame === 'handler') { return; }
         }
       },
     };

package/rules/no-set-on-derived-signal.js

@@ -0,0 +1,68 @@
+// Reports .set() on a variable that holds a derived signal — one produced by
+// computed() (imported from kensington) or by .transform() on any signal.
+// Derived signals are read-only; kensington throws at runtime, but this catches
+// it statically.
+export default {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'disallow .set() on a derived (computed or transform) signal',
+    },
+    messages: {
+      noSetOnDerived:
+        "'{{name}}' is a {{kind}} signal and cannot be written with .set(). " +
+        'Use signal() for writable state.',
+    },
+  },
+
+  create(context) {
+    const computedNames = new Set();
+    // name -> 'computed' | 'transform'
+    const derivedBindings = new Map();
+
+    return {
+      ImportDeclaration(node) {
+        if (node.source.value !== 'kensington') { return; }
+        for (const spec of node.specifiers) {
+          if (spec.type !== 'ImportSpecifier') { continue; }
+          if (spec.imported.name === 'computed') { computedNames.add(spec.local.name); }
+        }
+      },
+
+      VariableDeclarator(node) {
+        if (node.id.type !== 'Identifier' || !node.init) { return; }
+        const init = node.init;
+        if (init.type !== 'CallExpression') { return; }
+
+        if (init.callee.type === 'Identifier' && computedNames.has(init.callee.name)) {
+          derivedBindings.set(node.id.name, 'computed');
+          return;
+        }
+        if (
+          init.callee.type === 'MemberExpression' &&
+          init.callee.property.type === 'Identifier' &&
+          init.callee.property.name === 'transform'
+        ) {
+          derivedBindings.set(node.id.name, 'transform');
+        }
+      },
+
+      CallExpression(node) {
+        if (
+          node.callee.type !== 'MemberExpression' ||
+          node.callee.object.type !== 'Identifier' ||
+          node.callee.property.type !== 'Identifier' ||
+          node.callee.property.name !== 'set' ||
+          node.arguments.length !== 1
+        ) { return; }
+
+        const name = node.callee.object.name;
+        const kind = derivedBindings.get(name);
+        if (kind) {
+          const label = kind === 'computed' ? 'computed' : 'transform-derived';
+          context.report({ node, messageId: 'noSetOnDerived', data: { name, kind: label } });
+        }
+      },
+    };
+  },
+};

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

@@ -0,0 +1,83 @@
+// 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.
+
+import { isTagCall, getObjectNames, objectNamesSchema } from './_utils.js';
+
+export default {
+  meta: {
+    type: 'layout',
+    fixable: 'code',
+    docs: {
+      description: 'require array brackets around tag content that spans multiple lines',
+    },
+    schema: [{
+      type: 'object',
+      properties: { objectNames: objectNamesSchema },
+      additionalProperties: false,
+    }],
+    messages: {
+      wrapInArray: 'Tag content on a separate line must be wrapped in an array.',
+    },
+  },
+
+  create(context) {
+    const sourceCode = context.sourceCode;
+    const objectNames = getObjectNames(context);
+
+    function getContentArg(node) {
+      if (node.arguments.length === 1) {
+        const arg = node.arguments[0];
+        if (arg.type === 'ObjectExpression') { return null; } // attrs only
+        return arg;
+      }
+      if (node.arguments.length === 2) {
+        if (node.arguments[0].type !== 'ObjectExpression') { return null; }
+        return node.arguments[1];
+      }
+      return null;
+    }
+
+    return {
+      CallExpression(node) {
+        if (!isTagCall(node, objectNames)) { return; }
+
+        const content = getContentArg(node);
+        if (!content) { return; }
+        if (content.type === 'ArrayExpression') { return; }
+        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.
+        const openParenLine = node.callee.loc.end.line;
+        if (content.loc.start.line <= openParenLine) { return; }
+
+        context.report({
+          node: content,
+          messageId: 'wrapInArray',
+          *fix(fixer) {
+            const closeParen = sourceCode.getLastToken(node);
+            const tokenAfterContent = sourceCode.getTokenAfter(content);
+            const hasTrailingComma = tokenAfterContent
+              && tokenAfterContent.value === ','
+              && tokenAfterContent.range[0] < closeParen.range[0];
+
+            if (node.arguments.length === 2) {
+              const commaToken = sourceCode.getTokenAfter(node.arguments[0]);
+              yield fixer.insertTextAfter(commaToken, ' [');
+            } else {
+              const openParen = sourceCode.getTokenAfter(node.callee);
+              yield fixer.insertTextAfter(openParen, '[');
+            }
+
+            if (!hasTrailingComma) {
+              yield fixer.insertTextAfter(content, ',');
+            }
+
+            yield fixer.insertTextBefore(closeParen, ']');
+          },
+        });
+      },
+    };
+  },
+};

package/rules/prefer-boolean-attribute-true.js

@@ -0,0 +1,51 @@
+import { HTML_BOOLEAN_ATTRS, getTagAttrsObject, getPropertyKey, normalizeAttrName, getObjectNames, objectNamesSchema } from './_utils.js';
+
+export default {
+  meta: {
+    type: 'suggestion',
+    fixable: 'code',
+    docs: {
+      description: 'prefer `true` over an empty string for boolean HTML attributes',
+    },
+    schema: [{
+      type: 'object',
+      properties: {
+        extraBooleanAttrs: { type: 'array', items: { type: 'string' } },
+        objectNames: objectNamesSchema,
+      },
+      additionalProperties: false,
+    }],
+    messages: {
+      preferTrue: 'Boolean attribute `{{name}}` should be `true`, not an empty string.',
+    },
+  },
+
+  create(context) {
+    const opts = context.options[0] ?? {};
+    const extras = new Set((opts.extraBooleanAttrs ?? []).map(s => s.toLowerCase()));
+    const booleanAttrs = new Set([...HTML_BOOLEAN_ATTRS, ...extras]);
+    const objectNames = getObjectNames(context);
+
+    return {
+      CallExpression(node) {
+        const attrs = getTagAttrsObject(node, objectNames);
+        if (!attrs) { return; }
+
+        for (const prop of attrs.properties) {
+          const key = getPropertyKey(prop);
+          if (!key) { continue; }
+          const kebab = normalizeAttrName(key).toLowerCase();
+          if (!booleanAttrs.has(kebab)) { continue; }
+          if (prop.value.type !== 'Literal') { continue; }
+          if (prop.value.value !== '') { continue; }
+          context.report({
+            node: prop.value,
+            messageId: 'preferTrue',
+            data: { name: key },
+            fix: fixer => fixer.replaceText(prop.value, 'true'),
+          });
+        }
+      },
+    };
+  },
+};