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

package/src/eslint-rules/hyperscript-walk.cjs

@@ -0,0 +1,249 @@
+'use strict';
+
+const { NAMED_HTML_HELPER_SET } = require('./html-helpers.cjs');
+
+function isStringLiteral(node) {
+  return (
+    !!node &&
+    ((node.type === 'Literal' && typeof node.value === 'string') ||
+      (node.type === 'TemplateLiteral' &&
+        node.expressions.length === 0 &&
+        node.quasis.length === 1))
+  );
+}
+
+function stringLiteralValue(node) {
+  if (!node) return undefined;
+  if (node.type === 'Literal' && typeof node.value === 'string') return node.value;
+  if (
+    node.type === 'TemplateLiteral' &&
+    node.expressions.length === 0 &&
+    node.quasis.length === 1
+  ) {
+    return node.quasis[0].value.cooked;
+  }
+  return undefined;
+}
+
+function isNullLiteral(node) {
+  return (
+    !!node &&
+    (node.type === 'NullLiteral' ||
+      (node.type === 'Literal' && node.value === null))
+  );
+}
+
+function looksLikeChildren(node) {
+  if (!node) return true;
+  if (isNullLiteral(node) || node.type === 'Identifier' && node.name === 'undefined') {
+    return true;
+  }
+  if (
+    node.type === 'ArrayExpression' ||
+    node.type === 'CallExpression' ||
+    node.type === 'TemplateLiteral' ||
+    (node.type === 'Literal' && typeof node.value === 'string') ||
+    node.type === 'ArrowFunctionExpression' ||
+    node.type === 'FunctionExpression'
+  ) {
+    return true;
+  }
+  return false;
+}
+
+function property(object, name) {
+  if (!object || object.type !== 'ObjectExpression') return undefined;
+  return object.properties.find(
+    (entry) =>
+      entry.type === 'Property' &&
+      !entry.computed &&
+      ((entry.key.type === 'Identifier' && entry.key.name === name) ||
+        (entry.key.type === 'Literal' && entry.key.value === name)),
+  );
+}
+
+function staticPropString(object, name) {
+  const entry = property(object, name);
+  if (!entry) return undefined;
+  return stringLiteralValue(entry.value);
+}
+
+function hasProp(object, name) {
+  return !!property(object, name);
+}
+
+function parseHelperArgs(args) {
+  if (args.length === 0) {
+    return { name: undefined, props: undefined, children: undefined };
+  }
+  const first = args[0];
+  const second = args[1];
+  const third = args[2];
+  if (
+    isStringLiteral(first) &&
+    second &&
+    (second.type === 'ObjectExpression' || isNullLiteral(second))
+  ) {
+    return {
+      name: stringLiteralValue(first),
+      props: second.type === 'ObjectExpression' ? second : undefined,
+      children: third,
+    };
+  }
+  if (first && first.type === 'ObjectExpression') {
+    return { name: undefined, props: first, children: second };
+  }
+  return { name: undefined, props: undefined, children: first };
+}
+
+/**
+ * Recognise a Craft hyperscript call: named helpers, `h('tag', …)`, and
+ * `customElement('tag', …)`.
+ */
+function parseHyperscriptCall(node) {
+  if (!node || node.type !== 'CallExpression' || node.callee.type !== 'Identifier') {
+    return null;
+  }
+  const callee = node.callee.name;
+  if (callee === 'h' || callee === 'customElement') {
+    const tagNode = node.arguments[0];
+    const tag = stringLiteralValue(tagNode);
+    const rest = node.arguments.slice(1);
+    let props;
+    let children;
+    if (rest[0] && rest[0].type === 'ObjectExpression') {
+      props = rest[0];
+      children = rest[1];
+    } else if (rest[0] && looksLikeChildren(rest[0])) {
+      children = rest[0];
+    } else if (rest[0]) {
+      props = rest[0];
+      children = rest[1];
+    }
+    return {
+      tag,
+      tagNode,
+      props,
+      children,
+      name: undefined,
+      via: callee === 'h' ? 'h' : 'customElement',
+      node,
+      callee,
+    };
+  }
+  if (!NAMED_HTML_HELPER_SET.has(callee) && callee !== 'heading' && callee !== 'liveRegion') {
+    return null;
+  }
+  const parsed = parseHelperArgs(node.arguments);
+  return {
+    tag: callee === 'heading' ? 'heading' : callee === 'liveRegion' ? 'liveRegion' : callee,
+    tagNode: node.callee,
+    props: parsed.props,
+    children: parsed.children,
+    name: parsed.name,
+    via: 'helper',
+    node,
+    callee,
+  };
+}
+
+function walk(node, sourceCode, visit) {
+  if (!node || typeof node.type !== 'string') return;
+  const result = visit(node);
+  if (result === 'skip') return;
+  const keys = sourceCode.visitorKeys[node.type] ?? [];
+  for (const key of keys) {
+    const child = node[key];
+    if (Array.isArray(child)) {
+      child.forEach((item) => walk(item, sourceCode, visit));
+    } else {
+      walk(child, sourceCode, visit);
+    }
+  }
+}
+
+function staticTextContent(node) {
+  if (!node) return '';
+  if (isStringLiteral(node)) return stringLiteralValue(node) ?? '';
+  if (node.type === 'ArrayExpression') {
+    return node.elements.map((element) => staticTextContent(element)).join('');
+  }
+  if (node.type === 'CallExpression') {
+    const call = parseHyperscriptCall(node);
+    if (call) return staticTextContent(call.children);
+    if (node.callee.type === 'Identifier' && node.arguments.length > 0) {
+      return staticTextContent(node.arguments[node.arguments.length - 1]);
+    }
+  }
+  return '';
+}
+
+function hasDynamicAccessibleName(children) {
+  if (!children) return false;
+  if (
+    children.type === 'FunctionExpression' ||
+    children.type === 'ArrowFunctionExpression' ||
+    children.type === 'Identifier' ||
+    children.type === 'MemberExpression'
+  ) {
+    return true;
+  }
+  if (children.type === 'CallExpression') {
+    if (
+      children.callee.type === 'Identifier' &&
+      (children.callee.name === 'ifBlock' ||
+        children.callee.name === 'matchBlock' ||
+        children.callee.name === 'each')
+    ) {
+      return true;
+    }
+    return hasDynamicAccessibleName(
+      children.arguments[children.arguments.length - 1],
+    );
+  }
+  if (children.type === 'ArrayExpression') {
+    return children.elements.some((element) => hasDynamicAccessibleName(element));
+  }
+  return false;
+}
+
+function hasAccessibleName(call) {
+  if (!call) return false;
+  if (hasProp(call.props, 'aria-label') || hasProp(call.props, 'aria-labelledby')) {
+    const ariaLabel = staticPropString(call.props, 'aria-label');
+    if (ariaLabel === '') return false;
+    return true;
+  }
+  if (call.tag === 'img' || call.tag === 'area') {
+    return hasProp(call.props, 'alt');
+  }
+  if (call.tag === 'input') {
+    const type = staticPropString(call.props, 'type') ?? 'text';
+    if (type === 'hidden') return true;
+    if (type === 'image') return hasProp(call.props, 'alt');
+    if (hasProp(call.props, 'title') || hasProp(call.props, 'placeholder')) {
+      // placeholder-only is not a name; title can be
+      return hasProp(call.props, 'title');
+    }
+    return false;
+  }
+  const text = staticTextContent(call.children).trim();
+  if (text.length > 0) return true;
+  if (hasDynamicAccessibleName(call.children)) return true;
+  if (hasProp(call.props, 'title')) return true;
+  return false;
+}
+
+module.exports = {
+  isStringLiteral,
+  stringLiteralValue,
+  isNullLiteral,
+  property,
+  staticPropString,
+  hasProp,
+  parseHelperArgs,
+  parseHyperscriptCall,
+  walk,
+  staticTextContent,
+  hasAccessibleName,
+};

package/src/eslint-rules/iframe-has-title.cjs

@@ -0,0 +1,26 @@
+'use strict';
+
+const { parseHyperscriptCall, hasProp } = require('./hyperscript-walk.cjs');
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Require title on iframe elements.',
+    },
+    schema: [],
+    messages: {
+      missingTitle: '<iframe> must have a title that describes the framed content.',
+    },
+  },
+  create(context) {
+    return {
+      CallExpression(node) {
+        const call = parseHyperscriptCall(node);
+        if (!call || call.tag !== 'iframe') return;
+        if (hasProp(call.props, 'title')) return;
+        context.report({ node, messageId: 'missingTitle' });
+      },
+    };
+  },
+};

package/src/eslint-rules/img-has-alt.cjs

@@ -0,0 +1,28 @@
+'use strict';
+
+const { parseHyperscriptCall, hasProp } = require('./hyperscript-walk.cjs');
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Require alt on img and area, including an empty string for decorative images.',
+    },
+    schema: [],
+    messages: {
+      missingAlt:
+        '<{{tag}}> must have an alt attribute (use alt: \'\' for decorative images).',
+    },
+  },
+  create(context) {
+    return {
+      CallExpression(node) {
+        const call = parseHyperscriptCall(node);
+        if (!call || (call.tag !== 'img' && call.tag !== 'area')) return;
+        if (hasProp(call.props, 'alt')) return;
+        context.report({ node, messageId: 'missingAlt', data: { tag: call.tag } });
+      },
+    };
+  },
+};

package/src/eslint-rules/index.cjs

@@ -0,0 +1,209 @@
+const appStartRegistryMatch = require('./app-start-registry-match.cjs');
+const globalExceptionRegistryMatch = require('./global-exception-registry-match.cjs');
+const craftMethodNameMatch = require('./craft-method-name-match.cjs');
+const craftComputedNameMatch = require('./craft-computed-name-match.cjs');
+const craftSourceNameMatch = require('./craft-source-name-match.cjs');
+const craftSignalSourceNameMatch = require('./craft-signal-source-name-match.cjs');
+const noCraftComputedSideEffects = require('./no-craft-computed-side-effects.cjs');
+const provideHostNameMatchComponent = require('./provide-host-name-match-component.cjs');
+const preferCraftHttpTransport = require('./prefer-craft-http-transport.cjs');
+const preferBrowserBoundaries = require('./prefer-browser-boundaries.cjs');
+const requireComponentMonitoring = require('./require-component-monitoring.cjs');
+const requirePrimitiveGeneratorUnwrap = require('./require-primitive-generator-unwrap.cjs');
+const requireYieldableTemplateMethod = require('./require-yieldable-template-method.cjs');
+const requireCraftMethodForYieldableCallback = require('./require-craft-method-for-yieldable-callback.cjs');
+const requireYieldableReactiveRead = require('./require-yieldable-reactive-read.cjs');
+const requireYieldableInsertionWrite = require('./require-yieldable-insertion-write.cjs');
+const preferDirectYieldableCallback = require('./prefer-direct-yieldable-callback.cjs');
+const noCraftUseInTemplate = require('./no-craft-use-in-template.cjs');
+const noCraftUse = require('./no-craft-use.cjs');
+const noTypeAssertionsInTemplate = require('./no-type-assertions-in-template.cjs');
+const noEphemeralTemplateFormState = require('./no-ephemeral-template-form-state.cjs');
+const requireAssertExhaustiveRouteExceptions = require('./require-assert-exhaustive-route-exceptions.cjs');
+const requirePendingComponentDiCheck = require('./require-pending-component-di-check.cjs');
+const requireCraftExceptionHandler = require('./require-craft-exception-handler.cjs');
+const requireExceptionComponentDiCheck = require('./require-exception-component-di-check.cjs');
+const requireChildRouteMountCheck = require('./require-child-route-mount-check.cjs');
+const requireLazyLoadWithRetry = require('./require-lazy-load-with-retry.cjs');
+const requireCascadeRouteDiCheck = require('./require-cascade-route-di-check.cjs');
+const craftComponentNameMatch = require('./craft-component-name-match.cjs');
+const craftDirectiveNameMatch = require('./craft-directive-name-match.cjs');
+const templateElementNameUnique = require('./template-element-name-unique.cjs');
+const preferCraftTemplateBlocks = require('./prefer-craft-template-blocks.cjs');
+const noImperativeCraftResourceTrigger = require('./no-imperative-craft-resource-trigger.cjs');
+const noTransitionActions = require('./no-transition-actions.cjs');
+const requireCraftResourceTriggerYield = require('./require-craft-resource-trigger-yield.cjs');
+const noDirectTemporalGlobals = require('./no-direct-temporal-globals.cjs');
+const requirePrimitiveDerivedProperty = require('./require-primitive-derived-property.cjs');
+const noAsyncAwait = require('./no-async-await.cjs');
+const requirePrimitiveContext = require('./require-primitive-context.cjs');
+const noThrow = require('./no-throw.cjs');
+const noRenderWrites = require('./no-render-writes.cjs');
+const requireReactiveTemplateBindings = require('./require-reactive-template-bindings.cjs');
+const craftCssVarsContract = require('./craft-css-vars-contract.cjs');
+const craftStylesScopeSafe = require('./craft-styles-scope-safe.cjs');
+const craftCssVarNaming = require('./craft-css-var-naming.cjs');
+const craftCssTokenRegistry = require('./craft-css-token-registry.cjs');
+const noHardcodedDesignValues = require('./no-hardcoded-design-values.cjs');
+const noImportantInComponentStyles = require('./no-important-in-component-styles.cjs');
+const preferNamedHtmlHelpers = require('./prefer-named-html-helpers.cjs');
+const imgHasAlt = require('./img-has-alt.cjs');
+const controlHasAccessibleName = require('./control-has-accessible-name.cjs');
+const labelHasAssociatedControl = require('./label-has-associated-control.cjs');
+const noNoninteractiveElementInteractions = require('./no-noninteractive-element-interactions.cjs');
+const anchorHasHref = require('./anchor-has-href.cjs');
+const buttonHasType = require('./button-has-type.cjs');
+const requireInteractiveLocalName = require('./require-interactive-local-name.cjs');
+const iframeHasTitle = require('./iframe-has-title.cjs');
+const headingHasContent = require('./heading-has-content.cjs');
+const preferRelativeHeading = require('./prefer-relative-heading.cjs');
+const requireRouteHeadingOutline = require('./require-route-heading-outline.cjs');
+const requireOutletHeadingSection = require('./require-outlet-heading-section.cjs');
+const noHeadingLevelSkip = require('./no-heading-level-skip.cjs');
+const noPositiveTabindex = require('./no-positive-tabindex.cjs');
+const validAria = require('./valid-aria.cjs');
+const roleHasRequiredAria = require('./role-has-required-aria.cjs');
+const targetBlankNoopener = require('./target-blank-noopener.cjs');
+const requireFocusVisible = require('./require-focus-visible.cjs');
+const requireReducedMotion = require('./require-reduced-motion.cjs');
+const requireEffectAdapters = require('./require-effect-adapters.cjs');
+const serverFunctionClientMatch = require('./server-function-client-match.cjs');
+const noInvalidInsertionPipe = require('./no-invalid-insertion-pipe.cjs');
+const noRedundantPrimitiveInsertion = require('./no-redundant-primitive-insertion.cjs');
+const noEffectOutsideLoaders = require('./no-effect-outside-loaders.cjs');
+const preferQueryMethodOverStateTrigger = require('./prefer-query-method-over-state-trigger.cjs');
+const noInjectionToken = require('./no-injection-token.cjs');
+const noManualRouteProviderList = require('./no-manual-route-provider-list.cjs');
+const noWidenedRouteProviderContext = require('./no-widened-route-provider-context.cjs');
+const recommendedRules = require('./recommended-config.cjs');
+
+const plugin = {
+  rules: {
+    'app-start-registry-match': appStartRegistryMatch,
+    'global-exception-registry-match': globalExceptionRegistryMatch,
+    'craft-method-name-match': craftMethodNameMatch,
+    'craft-computed-name-match': craftComputedNameMatch,
+    'craft-source-name-match': craftSourceNameMatch,
+    'craft-signal-source-name-match': craftSignalSourceNameMatch,
+    'no-craft-computed-side-effects': noCraftComputedSideEffects,
+    'provide-host-name-match-component': provideHostNameMatchComponent,
+    'prefer-craft-http-transport': preferCraftHttpTransport,
+    'prefer-browser-boundaries': preferBrowserBoundaries,
+    'require-component-monitoring': requireComponentMonitoring,
+    'require-primitive-generator-unwrap': requirePrimitiveGeneratorUnwrap,
+    'require-yieldable-template-method': requireYieldableTemplateMethod,
+    'require-craft-method-for-yieldable-callback':
+      requireCraftMethodForYieldableCallback,
+    'require-yieldable-reactive-read': requireYieldableReactiveRead,
+    'require-yieldable-insertion-write': requireYieldableInsertionWrite,
+    'prefer-direct-yieldable-callback': preferDirectYieldableCallback,
+    'no-craft-use-in-template': noCraftUseInTemplate,
+    'no-craft-use': noCraftUse,
+    'no-type-assertions-in-template': noTypeAssertionsInTemplate,
+    'no-ephemeral-template-form-state': noEphemeralTemplateFormState,
+    'require-assert-exhaustive-route-exceptions':
+      requireAssertExhaustiveRouteExceptions,
+    'require-pending-component-di-check': requirePendingComponentDiCheck,
+    'require-craft-exception-handler': requireCraftExceptionHandler,
+    'require-exception-component-di-check': requireExceptionComponentDiCheck,
+    'require-child-route-mount-check': requireChildRouteMountCheck,
+    'require-lazy-load-with-retry': requireLazyLoadWithRetry,
+    'require-cascade-route-di-check': requireCascadeRouteDiCheck,
+    'craft-component-name-match': craftComponentNameMatch,
+    'craft-directive-name-match': craftDirectiveNameMatch,
+    'template-element-name-unique': templateElementNameUnique,
+    'prefer-craft-template-blocks': preferCraftTemplateBlocks,
+    'no-imperative-craft-resource-trigger': noImperativeCraftResourceTrigger,
+    'no-transition-actions': noTransitionActions,
+    'require-craft-resource-trigger-yield': requireCraftResourceTriggerYield,
+    'no-direct-temporal-globals': noDirectTemporalGlobals,
+    'require-primitive-derived-property': requirePrimitiveDerivedProperty,
+    'no-async-await': noAsyncAwait,
+    'require-primitive-context': requirePrimitiveContext,
+    'no-throw': noThrow,
+    'no-render-writes': noRenderWrites,
+    'require-reactive-template-bindings': requireReactiveTemplateBindings,
+    'craft-css-vars-contract': craftCssVarsContract,
+    'craft-styles-scope-safe': craftStylesScopeSafe,
+    'craft-css-var-naming': craftCssVarNaming,
+    'craft-css-token-registry': craftCssTokenRegistry,
+    'no-hardcoded-design-values': noHardcodedDesignValues,
+    'no-important-in-component-styles': noImportantInComponentStyles,
+    'prefer-named-html-helpers': preferNamedHtmlHelpers,
+    'img-has-alt': imgHasAlt,
+    'control-has-accessible-name': controlHasAccessibleName,
+    'label-has-associated-control': labelHasAssociatedControl,
+    'no-noninteractive-element-interactions':
+      noNoninteractiveElementInteractions,
+    'anchor-has-href': anchorHasHref,
+    'button-has-type': buttonHasType,
+    'require-interactive-local-name': requireInteractiveLocalName,
+    'iframe-has-title': iframeHasTitle,
+    'heading-has-content': headingHasContent,
+    'prefer-relative-heading': preferRelativeHeading,
+    'require-route-heading-outline': requireRouteHeadingOutline,
+    'require-outlet-heading-section': requireOutletHeadingSection,
+    'no-heading-level-skip': noHeadingLevelSkip,
+    'no-positive-tabindex': noPositiveTabindex,
+    'valid-aria': validAria,
+    'role-has-required-aria': roleHasRequiredAria,
+    'target-blank-noopener': targetBlankNoopener,
+    'require-focus-visible': requireFocusVisible,
+    'require-reduced-motion': requireReducedMotion,
+    'require-effect-adapters': requireEffectAdapters,
+    'server-function-client-match': serverFunctionClientMatch,
+    'no-invalid-insertion-pipe': noInvalidInsertionPipe,
+    'no-redundant-primitive-insertion': noRedundantPrimitiveInsertion,
+    'no-effect-outside-loaders': noEffectOutsideLoaders,
+    // Backwards-compatible alias; use no-effect-outside-loaders in new configs.
+    'no-effect-in-params': noEffectOutsideLoaders,
+    'prefer-query-method-over-state-trigger': preferQueryMethodOverStateTrigger,
+    'no-injection-token': noInjectionToken,
+    'no-manual-route-provider-list': noManualRouteProviderList,
+    'no-widened-route-provider-context': noWidenedRouteProviderContext,
+  },
+};
+
+const a11yRuleSeverity = {
+  'craft-ts/prefer-named-html-helpers': 'error',
+  'craft-ts/img-has-alt': 'error',
+  'craft-ts/control-has-accessible-name': 'error',
+  'craft-ts/label-has-associated-control': 'error',
+  'craft-ts/no-noninteractive-element-interactions': 'error',
+  'craft-ts/anchor-has-href': 'error',
+  'craft-ts/button-has-type': 'error',
+  'craft-ts/require-interactive-local-name': 'error',
+  'craft-ts/iframe-has-title': 'error',
+  'craft-ts/heading-has-content': 'error',
+  'craft-ts/prefer-relative-heading': 'error',
+  'craft-ts/require-route-heading-outline': 'error',
+  'craft-ts/require-outlet-heading-section': 'error',
+  'craft-ts/no-heading-level-skip': 'error',
+  'craft-ts/no-positive-tabindex': 'error',
+  'craft-ts/valid-aria': 'error',
+  'craft-ts/role-has-required-aria': 'error',
+  'craft-ts/target-blank-noopener': 'error',
+  'craft-ts/require-focus-visible': 'error',
+  'craft-ts/require-reduced-motion': 'error',
+};
+
+plugin.configs = {
+  recommended: {
+    plugins: { 'craft-ts': plugin },
+    rules: recommendedRules,
+  },
+  effect: {
+    plugins: { 'craft-ts': plugin },
+    rules: {
+      ...recommendedRules,
+      'craft-ts/require-effect-adapters': 'error',
+      'craft-ts/no-effect-outside-loaders': 'error',
+    },
+  },
+  a11y: {
+    plugins: { 'craft-ts': plugin },
+    rules: a11yRuleSeverity,
+  },
+};
+
+module.exports = plugin;

package/src/eslint-rules/index.d.cts

@@ -0,0 +1,5 @@
+import type { ESLint, Linter } from 'eslint';
+
+declare const plugin: ESLint.Plugin;
+
+export = plugin;

package/src/eslint-rules/label-has-associated-control.cjs

@@ -0,0 +1,67 @@
+'use strict';
+
+const { parseHyperscriptCall, hasProp, staticPropString, walk } = require('./hyperscript-walk.cjs');
+
+function isControlTag(tag) {
+  return tag === 'input' || tag === 'textarea' || tag === 'select';
+}
+
+function controlId(call) {
+  return staticPropString(call.props, 'id');
+}
+
+function wrapsControl(children, sourceCode) {
+  let found = false;
+  if (!children) return found;
+  walk(children, sourceCode, (candidate) => {
+    const call = parseHyperscriptCall(candidate);
+    if (call && isControlTag(call.tag)) {
+      found = true;
+      return 'skip';
+    }
+  });
+  return found;
+}
+
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Require every label to be associated with a form control via htmlFor or wrapping.',
+    },
+    schema: [],
+    messages: {
+      unassociated:
+        'label must be associated with a control: wrap the control or set htmlFor to match the control id.',
+    },
+  },
+  create(context) {
+    const sourceCode = context.sourceCode ?? context.getSourceCode();
+    const labels = [];
+    const controlIds = new Set();
+
+    return {
+      CallExpression(node) {
+        const call = parseHyperscriptCall(node);
+        if (!call) return;
+        if (call.tag === 'label') labels.push(call);
+        if (isControlTag(call.tag)) {
+          const id = controlId(call);
+          if (id) controlIds.add(id);
+        }
+      },
+      'Program:exit'() {
+        for (const label of labels) {
+          if (wrapsControl(label.children, sourceCode)) continue;
+          const htmlFor = staticPropString(label.props, 'htmlFor') ?? staticPropString(label.props, 'for');
+          if (htmlFor && controlIds.has(htmlFor)) continue;
+          if (hasProp(label.props, 'htmlFor') || hasProp(label.props, 'for')) {
+            // Dynamic htmlFor — give the author the benefit of the doubt.
+            continue;
+          }
+          context.report({ node: label.node, messageId: 'unassociated' });
+        }
+      },
+    };
+  },
+};

package/src/eslint-rules/no-async-await.cjs

@@ -0,0 +1,46 @@
+module.exports = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Disallow async functions and await expressions in Craft code; use generators and yield-based Craft utilities instead.',
+    },
+    schema: [],
+    messages: {
+      async:
+        'Async functions are forbidden in Craft code. Use a generator function and yield* Craft utilities such as craftSleep, query, mutation, asyncProcess, or CraftHttpClient.',
+      await:
+        'await is forbidden in Craft code. Use yield* with a Craft generator or primitive instead.',
+      forAwait:
+        'for await...of is forbidden in Craft code. Use a yield-based Craft flow instead.',
+    },
+  },
+
+  create(context) {
+    return {
+      FunctionDeclaration(node) {
+        reportAsync(node);
+      },
+      FunctionExpression(node) {
+        reportAsync(node);
+      },
+      ArrowFunctionExpression(node) {
+        reportAsync(node);
+      },
+      AwaitExpression(node) {
+        context.report({ node, messageId: 'await' });
+      },
+      ForOfStatement(node) {
+        if (node.await) {
+          context.report({ node, messageId: 'forAwait' });
+        }
+      },
+    };
+
+    function reportAsync(node) {
+      if (node.async) {
+        context.report({ node, messageId: 'async' });
+      }
+    }
+  },
+};