@craft-ts/dev-tools 0.7.0-beta.13

package/src/eslint-rules/require-interactive-local-name.cjs

@@ -0,0 +1,105 @@
+'use strict';
+
+const { NAMED_HTML_HELPER_SET } = require('./html-helpers.cjs');
+const {
+  parseHyperscriptCall,
+  staticPropString,
+  hasProp,
+} = require('./hyperscript-walk.cjs');
+
+const ALWAYS_INTERACTIVE = new Set([
+  'a',
+  'button',
+  'input',
+  'select',
+  'textarea',
+]);
+
+const INTERACTIVE_HANDLERS = [
+  'click',
+  'onClick',
+  'input',
+  'onInput',
+  'change',
+  'onChange',
+  'submit',
+  'onSubmit',
+];
+
+const EXEMPT_HELPERS = new Set([
+  'option',
+  'iframe',
+  'img',
+  'heading',
+  'h1',
+  'h2',
+  'h3',
+  'h4',
+  'h5',
+  'h6',
+]);
+
+const NAMED_FORM_EXAMPLES = {
+  a: "a('docs', { href: '/guide' }, 'Docs')",
+  button: "button('save', { type: 'button' }, 'Save')",
+  input: "input('email', { type: 'email' })",
+  select: "select('country', {}, [])",
+  textarea: "textarea('bio', {}, [])",
+  div: "div('panel', {}, 'x')",
+};
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Require a string literal local name on interactive Craft hyperscript helpers.',
+    },
+    schema: [],
+    messages: {
+      missingLocalName:
+        '{{tag}}() must take a string literal local name as its first argument: {{example}}.',
+    },
+  },
+  create(context) {
+    return {
+      CallExpression(node) {
+        const call = parseHyperscriptCall(node);
+        if (!call || call.via !== 'helper' || !call.tag) return;
+        if (
+          !NAMED_HTML_HELPER_SET.has(call.tag) ||
+          EXEMPT_HELPERS.has(call.tag)
+        ) {
+          return;
+        }
+        const second = node.arguments[1];
+        const props =
+          call.props ??
+          (second?.type === 'ObjectExpression' ? second : undefined);
+        if (!isInteractiveCall(call.tag, props)) return;
+        if (typeof call.name === 'string') return;
+
+        context.report({
+          node,
+          messageId: 'missingLocalName',
+          data: {
+            tag: call.tag,
+            example: namedFormExample(call.tag),
+          },
+        });
+      },
+    };
+  },
+};
+
+function isInteractiveCall(tag, props) {
+  if (tag === 'input' && staticPropString(props, 'type') === 'hidden') {
+    return false;
+  }
+  if (ALWAYS_INTERACTIVE.has(tag)) return true;
+  return INTERACTIVE_HANDLERS.some((name) => hasProp(props, name));
+}
+
+function namedFormExample(tag) {
+  return NAMED_FORM_EXAMPLES[tag] ?? `${tag}('name', {}, [])`;
+}

package/src/eslint-rules/require-lazy-load-with-retry.cjs

@@ -0,0 +1,148 @@
+'use strict';
+
+const LAZY_PROPERTIES = new Set([
+  'loadComponent',
+  'loadChildren',
+]);
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Require lazy route imports to use the withRetry helper so browser-cached module failures can be retried.',
+    },
+    fixable: 'code',
+    schema: [],
+  },
+  create(context) {
+    const sourceCode = context.sourceCode ?? context.getSourceCode();
+    const importsByLoader = new Map();
+
+    return {
+      ImportExpression(node) {
+        const loader = enclosingLazyLoader(node);
+        if (!loader || isWrappedWithRetry(node)) return;
+
+        const imports = importsByLoader.get(loader) ?? [];
+        imports.push(node);
+        importsByLoader.set(loader, imports);
+      },
+      'Program:exit'() {
+        for (const [loader, imports] of importsByLoader) {
+          context.report({
+            node: imports[0],
+            message:
+              'Lazy route imports must be wrapped with withRetry(import(...)).',
+            fix(fixer) {
+              const parameterFixes = addWithRetryParameter(
+                fixer,
+                sourceCode,
+                loader,
+              );
+              if (!parameterFixes) return null;
+
+              return [
+                ...parameterFixes,
+                ...imports.flatMap((moduleImport) => [
+                  fixer.insertTextBefore(moduleImport, 'withRetry('),
+                  fixer.insertTextAfter(moduleImport, ')'),
+                ]),
+              ];
+            },
+          });
+        }
+      },
+    };
+  },
+};
+
+function enclosingLazyLoader(node) {
+  let current = node.parent;
+  while (current) {
+    if (
+      (current.type === 'ArrowFunctionExpression' ||
+        current.type === 'FunctionExpression') &&
+      current.parent?.type === 'Property' &&
+      LAZY_PROPERTIES.has(propertyName(current.parent)) &&
+      isInsideCraftRoute(current.parent)
+    ) {
+      return current;
+    }
+    if (current.type === 'Property' || current.type === 'Program') return null;
+    current = current.parent;
+  }
+  return null;
+}
+
+function isInsideCraftRoute(node) {
+  let current = node.parent;
+  while (current) {
+    if (
+      current.type === 'CallExpression' &&
+      current.callee.type === 'Identifier' &&
+      (current.callee.name === 'craftRoute' ||
+        current.callee.name === 'craftRoutes')
+    ) {
+      return true;
+    }
+    if (current.type === 'Program') return false;
+    current = current.parent;
+  }
+  return false;
+}
+
+function propertyName(property) {
+  if (property.computed) return undefined;
+  if (property.key.type === 'Identifier') return property.key.name;
+  if (property.key.type === 'Literal') return property.key.value;
+  return undefined;
+}
+
+function isWrappedWithRetry(node) {
+  return (
+    node.parent?.type === 'CallExpression' &&
+    node.parent.callee.type === 'Identifier' &&
+    node.parent.callee.name === 'withRetry' &&
+    node.parent.arguments[0] === node
+  );
+}
+
+function addWithRetryParameter(fixer, sourceCode, loader) {
+  if (loader.params.length === 0) {
+    const arrow = sourceCode.getTokenBefore(loader.body, {
+      filter: (token) => token.value === '=>',
+    });
+    if (!arrow) return null;
+
+    const closeParen = sourceCode.getTokenBefore(arrow);
+    const openParen = closeParen && sourceCode.getTokenBefore(closeParen);
+    if (openParen?.value !== '(' || closeParen?.value !== ')') return null;
+    return [
+      fixer.replaceTextRange(
+        [openParen.range[1], closeParen.range[0]],
+        '{ withRetry }',
+      ),
+    ];
+  }
+
+  if (loader.params.length !== 1 || loader.params[0].type !== 'ObjectPattern') {
+    return null;
+  }
+
+  const pattern = loader.params[0];
+  if (
+    pattern.properties.some(
+      (property) =>
+        property.type === 'Property' &&
+        property.key.type === 'Identifier' &&
+        property.key.name === 'withRetry',
+    )
+  ) {
+    return [];
+  }
+
+  const closingBrace = sourceCode.getLastToken(pattern);
+  const prefix = pattern.properties.length > 0 ? ', ' : '';
+  return [fixer.insertTextBefore(closingBrace, `${prefix}withRetry`)];
+}

package/src/eslint-rules/require-outlet-heading-section.cjs

@@ -0,0 +1,70 @@
+'use strict';
+
+const { walk } = require('./hyperscript-walk.cjs');
+
+function isCallNamed(node, name) {
+  return (
+    !!node &&
+    node.type === 'CallExpression' &&
+    node.callee.type === 'Identifier' &&
+    node.callee.name === name
+  );
+}
+
+function isInside(node, ancestorName, stopName) {
+  let current = node.parent;
+  while (current) {
+    if (isCallNamed(current, ancestorName)) return true;
+    if (isCallNamed(current, stopName)) return false;
+    current = current.parent;
+  }
+  return false;
+}
+
+function collectCalls(node, sourceCode, name) {
+  const found = [];
+  walk(node, sourceCode, (candidate) => {
+    if (isCallNamed(candidate, name)) found.push(candidate);
+  });
+  return found;
+}
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Layouts that call heading() must wrap CraftRouterOutlet in headingSection(); shells must not put heading() above the outlet.',
+    },
+    schema: [],
+    messages: {
+      wrapOutlet:
+        'A component that calls heading() and CraftRouterOutlet() must wrap the outlet in headingSection(...) so child routes inherit h2+. Shells must not put heading() above the outlet.',
+      layoutHeading:
+        'A layout that wraps CraftRouterOutlet() in headingSection(...) must also call heading() for the layout title.',
+    },
+  },
+  create(context) {
+    const sourceCode = context.sourceCode ?? context.getSourceCode();
+    return {
+      CallExpression(node) {
+        if (!isCallNamed(node, 'craftComponent')) return;
+        const template = node.arguments[3];
+        if (!template) return;
+        const outlets = collectCalls(template, sourceCode, 'CraftRouterOutlet');
+        if (outlets.length === 0) return;
+        const headings = collectCalls(template, sourceCode, 'heading');
+        const wrapped = outlets.every((outlet) =>
+          isInside(outlet, 'headingSection', 'craftComponent'),
+        );
+        if (headings.length > 0 && !wrapped) {
+          context.report({ node: outlets[0], messageId: 'wrapOutlet' });
+          return;
+        }
+        if (wrapped && headings.length === 0) {
+          context.report({ node: outlets[0], messageId: 'layoutHeading' });
+        }
+      },
+    };
+  },
+};