@venizia/dev-configs 0.4.6 → 0.4.7-0

package/dist/linters/house/configs.js

@@ -1,14 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.reactHouseConfigs = exports.houseConfigs = void 0;
+exports.reactAsyncStyleConfigs = exports.asyncStyleConfigs = exports.reactHouseConfigs = exports.houseConfigs = void 0;
 const eslint_1 = require("../eslint");
 const jsx_files_1 = require("../jsx-files");
 const react_eslint_1 = require("../react-eslint");
 const common_1 = require("./common");
 const const_class_values_rule_1 = require("./const-class-values.rule");
+const effect_cleanup_consistency_rule_1 = require("./effect-cleanup-consistency.rule");
 const max_params_own_rule_1 = require("./max-params-own.rule");
+const no_async_hook_callback_rule_1 = require("./no-async-hook-callback.rule");
+const no_inline_await_rule_1 = require("./no-inline-await.rule");
 const no_leaked_render_rule_1 = require("./no-leaked-render.rule");
 const no_new_error_rule_1 = require("./no-new-error.rule");
+const no_return_await_rule_1 = require("./no-return-await.rule");
 const plugin_1 = require("./plugin");
 const SOURCE_FILES = ['**/*.{ts,tsx,mts,cts}'];
 const TEST_FILES = ['**/__tests__/**', '**/*.test.{ts,tsx}', '**/*.spec.{ts,tsx}'];
@@ -75,4 +79,45 @@ exports.reactHouseConfigs = [
     ...houseRuleConfigs,
     ...reactRuleConfigs,
 ];
+/**
+ * The async style rules, opt-in until every Venizia repository has been swept (the owner's rollout: the option in
+ * one release, the default in the next). Spread it next to `houseConfigs`:
+ *
+ * ```js
+ * export default [...houseConfigs, ...asyncStyleConfigs];
+ * ```
+ *
+ * `await` stands alone as a statement or as the whole initializer of a declaration (`no-inline-await`), and a
+ * function returns the promise instead of `return await` (`no-return-await`). They apply to test files too.
+ */
+exports.asyncStyleConfigs = [
+    {
+        files: SOURCE_FILES,
+        plugins: { [common_1.HOUSE_PLUGIN_NAMESPACE]: plugin_1.houseEslintPlugin },
+        rules: {
+            [no_inline_await_rule_1.NoInlineAwaitRule.NAME]: no_inline_await_rule_1.NoInlineAwaitRule.build(),
+            [no_return_await_rule_1.NoReturnAwaitRule.NAME]: no_return_await_rule_1.NoReturnAwaitRule.build(),
+        },
+    },
+];
+/**
+ * The hook async rules, opt-in like `asyncStyleConfigs`. Spread it next to `reactHouseConfigs`:
+ *
+ * ```js
+ * export default [...reactHouseConfigs, ...reactAsyncStyleConfigs];
+ * ```
+ *
+ * A hook never gets an async function (`no-async-hook-callback`), and an effect callback returns a cleanup on every
+ * path or on none (`effect-cleanup-consistency`). Hooks live in `.ts` files too, so it covers all source files.
+ */
+exports.reactAsyncStyleConfigs = [
+    {
+        files: SOURCE_FILES,
+        plugins: { [common_1.HOUSE_PLUGIN_NAMESPACE]: plugin_1.houseEslintPlugin },
+        rules: {
+            [no_async_hook_callback_rule_1.NoAsyncHookCallbackRule.NAME]: no_async_hook_callback_rule_1.NoAsyncHookCallbackRule.build(),
+            [effect_cleanup_consistency_rule_1.EffectCleanupConsistencyRule.NAME]: effect_cleanup_consistency_rule_1.EffectCleanupConsistencyRule.build(),
+        },
+    },
+];
 //# sourceMappingURL=configs.js.map

package/dist/linters/house/configs.js.map

@@ -1 +1 @@
-{"version":3,"file":"configs.js","sourceRoot":"","sources":["../../../src/linters/house/configs.ts"],"names":[],"mappings":";;;AACA,sCAAoD;AACpD,4CAAyC;AACzC,kDAA+D;AAC/D,qCAAkD;AAClD,uEAAiE;AACjE,+DAAyD;AACzD,mEAA6D;AAC7D,2DAAqD;AACrD,qCAA6C;AAE7C,MAAM,YAAY,GAAG,CAAC,uBAAuB,CAAC,CAAC;AAC/C,MAAM,UAAU,GAAG,CAAC,iBAAiB,EAAE,oBAAoB,EAAE,oBAAoB,CAAC,CAAC;AAEnF;;;GAGG;AACH,MAAM,YAAY,GAAG,+CAA+C,CAAC;AAErE;;;;;;;;GAQG;AACH,MAAM,gBAAgB,GAAoB;IACxC;QACE,KAAK,EAAE,YAAY;QACnB,OAAO,EAAE,EAAE,CAAC,+BAAsB,CAAC,EAAE,0BAAiB,EAAE;QACxD,KAAK,EAAE;YACL,CAAC,sCAAgB,CAAC,IAAI,CAAC,EAAE,sCAAgB,CAAC,KAAK,EAAE;YACjD,CAAC,kCAAc,CAAC,IAAI,CAAC,EAAE,kCAAc,CAAC,KAAK,EAAE;YAC7C,CAAC,8CAAoB,CAAC,IAAI,CAAC,EAAE,8CAAoB,CAAC,KAAK,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;YAC7E,CAAC,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,EAAE,cAAc,EAAE,OAAO,EAAE,CAAC;SACtD;KACF;IACD;QACE,KAAK,EAAE,UAAU;QACjB,KAAK,EAAE;YACL,CAAC,kCAAc,CAAC,IAAI,CAAC,EAAE,KAAK;YAC5B,CAAC,8CAAoB,CAAC,IAAI,CAAC,EAAE,KAAK;YAClC,CAAC,YAAY,CAAC,EAAE,KAAK;SACtB;KACF;CACF,CAAC;AAEF;;;;;;;;;;GAUG;AACU,QAAA,YAAY,GAAoB,CAAC,GAAG,gCAAuB,EAAE,GAAG,gBAAgB,CAAC,CAAC;AAE/F;;;GAGG;AACH,MAAM,gBAAgB,GAAoB;IACxC;QACE,KAAK,EAAE,qBAAS;QAChB,OAAO,EAAE,EAAE,CAAC,+BAAsB,CAAC,EAAE,0BAAiB,EAAE;QACxD,KAAK,EAAE,EAAE,CAAC,0CAAkB,CAAC,IAAI,CAAC,EAAE,0CAAkB,CAAC,KAAK,EAAE,EAAE;KACjE;CACF,CAAC;AAEF,kHAAkH;AACrG,QAAA,iBAAiB,GAAoB;IAChD,GAAG,2CAA4B;IAC/B,GAAG,gBAAgB;IACnB,GAAG,gBAAgB;CACpB,CAAC","sourcesContent":["import type { Linter } from 'eslint';\nimport { namingConventionConfigs } from '../eslint';\nimport { JSX_FILES } from '../jsx-files';\nimport { reactNamingConventionConfigs } from '../react-eslint';\nimport { HOUSE_PLUGIN_NAMESPACE } from './common';\nimport { ConstClassValuesRule } from './const-class-values.rule';\nimport { MaxParamsOwnRule } from './max-params-own.rule';\nimport { NoLeakedRenderRule } from './no-leaked-render.rule';\nimport { NoNewErrorRule } from './no-new-error.rule';\nimport { houseEslintPlugin } from './plugin';\n\nconst SOURCE_FILES = ['**/*.{ts,tsx,mts,cts}'];\nconst TEST_FILES = ['**/__tests__/**', '**/*.test.{ts,tsx}', '**/*.spec.{ts,tsx}'];\n\n/**\n * V-C-10: no explicit cast. `as const` is always allowed; `satisfies`, a generic or a narrower type\n * replaces the rest.\n */\nconst NO_CAST_RULE = '@typescript-eslint/consistent-type-assertions';\n\n/**\n * The house rules: at most 5 positional parameters on a function we write, and errors thrown through\n * `getError` only. Tests are exempt from `no-new-error`: a test throws a plain `Error` on purpose, to\n * stand in for what a driver or a third-party library throws.\n *\n * Two rules only warn, so a project adopts them without failing its lint: `const-class-values` (V-C-08, a\n * string-literal union in an exported declaration) and `consistent-type-assertions` (V-C-10, an `as X`\n * cast). Tests are exempt from both: a test stubs what it does not build.\n */\nconst houseRuleConfigs: Linter.Config[] = [\n  {\n    files: SOURCE_FILES,\n    plugins: { [HOUSE_PLUGIN_NAMESPACE]: houseEslintPlugin },\n    rules: {\n      [MaxParamsOwnRule.NAME]: MaxParamsOwnRule.build(),\n      [NoNewErrorRule.NAME]: NoNewErrorRule.build(),\n      [ConstClassValuesRule.NAME]: ConstClassValuesRule.build({ severity: 'warn' }),\n      [NO_CAST_RULE]: ['warn', { assertionStyle: 'never' }],\n    },\n  },\n  {\n    files: TEST_FILES,\n    rules: {\n      [NoNewErrorRule.NAME]: 'off',\n      [ConstClassValuesRule.NAME]: 'off',\n      [NO_CAST_RULE]: 'off',\n    },\n  },\n];\n\n/**\n * The ESLint side of a project that lints with oxlint: the naming convention plus the house rules -\n * everything oxlint cannot express. Run it next to `oxlintConfigs`.\n *\n * ```js\n * // .configs/lints/eslint.config.mjs\n * import { houseConfigs } from '@venizia/dev-configs/linters';\n *\n * export default houseConfigs;\n * ```\n */\nexport const houseConfigs: Linter.Config[] = [...namingConventionConfigs, ...houseRuleConfigs];\n\n/**\n * The React house rule: a JSX child is drawn with `cond ? <X /> : null`, never `cond && <X />`, which\n * draws `0` when `cond` is `0`.\n */\nconst reactRuleConfigs: Linter.Config[] = [\n  {\n    files: JSX_FILES,\n    plugins: { [HOUSE_PLUGIN_NAMESPACE]: houseEslintPlugin },\n    rules: { [NoLeakedRenderRule.NAME]: NoLeakedRenderRule.build() },\n  },\n];\n\n/** `houseConfigs` for a React project: `reactNamingConventionConfigs`, the house rules and `no-leaked-render`. */\nexport const reactHouseConfigs: Linter.Config[] = [\n  ...reactNamingConventionConfigs,\n  ...houseRuleConfigs,\n  ...reactRuleConfigs,\n];\n"]}
+{"version":3,"file":"configs.js","sourceRoot":"","sources":["../../../src/linters/house/configs.ts"],"names":[],"mappings":";;;AACA,sCAAoD;AACpD,4CAAyC;AACzC,kDAA+D;AAC/D,qCAAkD;AAClD,uEAAiE;AACjE,uFAAiF;AACjF,+DAAyD;AACzD,+EAAwE;AACxE,iEAA2D;AAC3D,mEAA6D;AAC7D,2DAAqD;AACrD,iEAA2D;AAC3D,qCAA6C;AAE7C,MAAM,YAAY,GAAG,CAAC,uBAAuB,CAAC,CAAC;AAC/C,MAAM,UAAU,GAAG,CAAC,iBAAiB,EAAE,oBAAoB,EAAE,oBAAoB,CAAC,CAAC;AAEnF;;;GAGG;AACH,MAAM,YAAY,GAAG,+CAA+C,CAAC;AAErE;;;;;;;;GAQG;AACH,MAAM,gBAAgB,GAAoB;IACxC;QACE,KAAK,EAAE,YAAY;QACnB,OAAO,EAAE,EAAE,CAAC,+BAAsB,CAAC,EAAE,0BAAiB,EAAE;QACxD,KAAK,EAAE;YACL,CAAC,sCAAgB,CAAC,IAAI,CAAC,EAAE,sCAAgB,CAAC,KAAK,EAAE;YACjD,CAAC,kCAAc,CAAC,IAAI,CAAC,EAAE,kCAAc,CAAC,KAAK,EAAE;YAC7C,CAAC,8CAAoB,CAAC,IAAI,CAAC,EAAE,8CAAoB,CAAC,KAAK,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC;YAC7E,CAAC,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,EAAE,cAAc,EAAE,OAAO,EAAE,CAAC;SACtD;KACF;IACD;QACE,KAAK,EAAE,UAAU;QACjB,KAAK,EAAE;YACL,CAAC,kCAAc,CAAC,IAAI,CAAC,EAAE,KAAK;YAC5B,CAAC,8CAAoB,CAAC,IAAI,CAAC,EAAE,KAAK;YAClC,CAAC,YAAY,CAAC,EAAE,KAAK;SACtB;KACF;CACF,CAAC;AAEF;;;;;;;;;;GAUG;AACU,QAAA,YAAY,GAAoB,CAAC,GAAG,gCAAuB,EAAE,GAAG,gBAAgB,CAAC,CAAC;AAE/F;;;GAGG;AACH,MAAM,gBAAgB,GAAoB;IACxC;QACE,KAAK,EAAE,qBAAS;QAChB,OAAO,EAAE,EAAE,CAAC,+BAAsB,CAAC,EAAE,0BAAiB,EAAE;QACxD,KAAK,EAAE,EAAE,CAAC,0CAAkB,CAAC,IAAI,CAAC,EAAE,0CAAkB,CAAC,KAAK,EAAE,EAAE;KACjE;CACF,CAAC;AAEF,kHAAkH;AACrG,QAAA,iBAAiB,GAAoB;IAChD,GAAG,2CAA4B;IAC/B,GAAG,gBAAgB;IACnB,GAAG,gBAAgB;CACpB,CAAC;AAEF;;;;;;;;;;GAUG;AACU,QAAA,iBAAiB,GAAoB;IAChD;QACE,KAAK,EAAE,YAAY;QACnB,OAAO,EAAE,EAAE,CAAC,+BAAsB,CAAC,EAAE,0BAAiB,EAAE;QACxD,KAAK,EAAE;YACL,CAAC,wCAAiB,CAAC,IAAI,CAAC,EAAE,wCAAiB,CAAC,KAAK,EAAE;YACnD,CAAC,wCAAiB,CAAC,IAAI,CAAC,EAAE,wCAAiB,CAAC,KAAK,EAAE;SACpD;KACF;CACF,CAAC;AAEF;;;;;;;;;GASG;AACU,QAAA,sBAAsB,GAAoB;IACrD;QACE,KAAK,EAAE,YAAY;QACnB,OAAO,EAAE,EAAE,CAAC,+BAAsB,CAAC,EAAE,0BAAiB,EAAE;QACxD,KAAK,EAAE;YACL,CAAC,qDAAuB,CAAC,IAAI,CAAC,EAAE,qDAAuB,CAAC,KAAK,EAAE;YAC/D,CAAC,8DAA4B,CAAC,IAAI,CAAC,EAAE,8DAA4B,CAAC,KAAK,EAAE;SAC1E;KACF;CACF,CAAC","sourcesContent":["import type { Linter } from 'eslint';\nimport { namingConventionConfigs } from '../eslint';\nimport { JSX_FILES } from '../jsx-files';\nimport { reactNamingConventionConfigs } from '../react-eslint';\nimport { HOUSE_PLUGIN_NAMESPACE } from './common';\nimport { ConstClassValuesRule } from './const-class-values.rule';\nimport { EffectCleanupConsistencyRule } from './effect-cleanup-consistency.rule';\nimport { MaxParamsOwnRule } from './max-params-own.rule';\nimport { NoAsyncHookCallbackRule } from './no-async-hook-callback.rule';\nimport { NoInlineAwaitRule } from './no-inline-await.rule';\nimport { NoLeakedRenderRule } from './no-leaked-render.rule';\nimport { NoNewErrorRule } from './no-new-error.rule';\nimport { NoReturnAwaitRule } from './no-return-await.rule';\nimport { houseEslintPlugin } from './plugin';\n\nconst SOURCE_FILES = ['**/*.{ts,tsx,mts,cts}'];\nconst TEST_FILES = ['**/__tests__/**', '**/*.test.{ts,tsx}', '**/*.spec.{ts,tsx}'];\n\n/**\n * V-C-10: no explicit cast. `as const` is always allowed; `satisfies`, a generic or a narrower type\n * replaces the rest.\n */\nconst NO_CAST_RULE = '@typescript-eslint/consistent-type-assertions';\n\n/**\n * The house rules: at most 5 positional parameters on a function we write, and errors thrown through\n * `getError` only. Tests are exempt from `no-new-error`: a test throws a plain `Error` on purpose, to\n * stand in for what a driver or a third-party library throws.\n *\n * Two rules only warn, so a project adopts them without failing its lint: `const-class-values` (V-C-08, a\n * string-literal union in an exported declaration) and `consistent-type-assertions` (V-C-10, an `as X`\n * cast). Tests are exempt from both: a test stubs what it does not build.\n */\nconst houseRuleConfigs: Linter.Config[] = [\n  {\n    files: SOURCE_FILES,\n    plugins: { [HOUSE_PLUGIN_NAMESPACE]: houseEslintPlugin },\n    rules: {\n      [MaxParamsOwnRule.NAME]: MaxParamsOwnRule.build(),\n      [NoNewErrorRule.NAME]: NoNewErrorRule.build(),\n      [ConstClassValuesRule.NAME]: ConstClassValuesRule.build({ severity: 'warn' }),\n      [NO_CAST_RULE]: ['warn', { assertionStyle: 'never' }],\n    },\n  },\n  {\n    files: TEST_FILES,\n    rules: {\n      [NoNewErrorRule.NAME]: 'off',\n      [ConstClassValuesRule.NAME]: 'off',\n      [NO_CAST_RULE]: 'off',\n    },\n  },\n];\n\n/**\n * The ESLint side of a project that lints with oxlint: the naming convention plus the house rules -\n * everything oxlint cannot express. Run it next to `oxlintConfigs`.\n *\n * ```js\n * // .configs/lints/eslint.config.mjs\n * import { houseConfigs } from '@venizia/dev-configs/linters';\n *\n * export default houseConfigs;\n * ```\n */\nexport const houseConfigs: Linter.Config[] = [...namingConventionConfigs, ...houseRuleConfigs];\n\n/**\n * The React house rule: a JSX child is drawn with `cond ? <X /> : null`, never `cond && <X />`, which\n * draws `0` when `cond` is `0`.\n */\nconst reactRuleConfigs: Linter.Config[] = [\n  {\n    files: JSX_FILES,\n    plugins: { [HOUSE_PLUGIN_NAMESPACE]: houseEslintPlugin },\n    rules: { [NoLeakedRenderRule.NAME]: NoLeakedRenderRule.build() },\n  },\n];\n\n/** `houseConfigs` for a React project: `reactNamingConventionConfigs`, the house rules and `no-leaked-render`. */\nexport const reactHouseConfigs: Linter.Config[] = [\n  ...reactNamingConventionConfigs,\n  ...houseRuleConfigs,\n  ...reactRuleConfigs,\n];\n\n/**\n * The async style rules, opt-in until every Venizia repository has been swept (the owner's rollout: the option in\n * one release, the default in the next). Spread it next to `houseConfigs`:\n *\n * ```js\n * export default [...houseConfigs, ...asyncStyleConfigs];\n * ```\n *\n * `await` stands alone as a statement or as the whole initializer of a declaration (`no-inline-await`), and a\n * function returns the promise instead of `return await` (`no-return-await`). They apply to test files too.\n */\nexport const asyncStyleConfigs: Linter.Config[] = [\n  {\n    files: SOURCE_FILES,\n    plugins: { [HOUSE_PLUGIN_NAMESPACE]: houseEslintPlugin },\n    rules: {\n      [NoInlineAwaitRule.NAME]: NoInlineAwaitRule.build(),\n      [NoReturnAwaitRule.NAME]: NoReturnAwaitRule.build(),\n    },\n  },\n];\n\n/**\n * The hook async rules, opt-in like `asyncStyleConfigs`. Spread it next to `reactHouseConfigs`:\n *\n * ```js\n * export default [...reactHouseConfigs, ...reactAsyncStyleConfigs];\n * ```\n *\n * A hook never gets an async function (`no-async-hook-callback`), and an effect callback returns a cleanup on every\n * path or on none (`effect-cleanup-consistency`). Hooks live in `.ts` files too, so it covers all source files.\n */\nexport const reactAsyncStyleConfigs: Linter.Config[] = [\n  {\n    files: SOURCE_FILES,\n    plugins: { [HOUSE_PLUGIN_NAMESPACE]: houseEslintPlugin },\n    rules: {\n      [NoAsyncHookCallbackRule.NAME]: NoAsyncHookCallbackRule.build(),\n      [EffectCleanupConsistencyRule.NAME]: EffectCleanupConsistencyRule.build(),\n    },\n  },\n];\n"]}

package/dist/linters/house/effect-cleanup-consistency.rule.d.ts

@@ -0,0 +1,17 @@
+import type { Rule } from 'eslint';
+import type { TRuleSeverity } from '../rules/common';
+/**
+ * `venizia/effect-cleanup-consistency`. The callback of `useEffect`, `useLayoutEffect` and `useInsertionEffect`
+ * returns a cleanup on every path or on none. An early `return;` beside a later `return () => {}` leaves React
+ * with a cleanup on some runs only; the early exit returns a no-op instead. A bare `return;` and falling off the
+ * end both mean "no value". It uses ESLint's code path analysis the way `consistent-return` does, so an
+ * unreachable end of the function is not a path. A nested function's own `return` is not counted.
+ */
+export declare class EffectCleanupConsistencyRule {
+    static readonly NAME = "venizia/effect-cleanup-consistency";
+    static readonly RULE: Rule.RuleModule;
+    static build(opts?: {
+        severity?: TRuleSeverity;
+    }): TRuleSeverity;
+}
+//# sourceMappingURL=effect-cleanup-consistency.rule.d.ts.map

package/dist/linters/house/effect-cleanup-consistency.rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect-cleanup-consistency.rule.d.ts","sourceRoot":"","sources":["../../../src/linters/house/effect-cleanup-consistency.rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AACnC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAarD;;;;;;GAMG;AACH,qBAAa,4BAA4B;IACvC,MAAM,CAAC,QAAQ,CAAC,IAAI,wCAA0D;IAE9E,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,UAAU,CA2EnC;IAEF,MAAM,CAAC,KAAK,CAAC,IAAI,GAAE;QAAE,QAAQ,CAAC,EAAE,aAAa,CAAA;KAAO,GAAG,aAAa;CAGrE"}

package/dist/linters/house/effect-cleanup-consistency.rule.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EffectCleanupConsistencyRule = void 0;
+const common_1 = require("./common");
+const hook_support_1 = require("./hook-support");
+/**
+ * `venizia/effect-cleanup-consistency`. The callback of `useEffect`, `useLayoutEffect` and `useInsertionEffect`
+ * returns a cleanup on every path or on none. An early `return;` beside a later `return () => {}` leaves React
+ * with a cleanup on some runs only; the early exit returns a no-op instead. A bare `return;` and falling off the
+ * end both mean "no value". It uses ESLint's code path analysis the way `consistent-return` does, so an
+ * unreachable end of the function is not a path. A nested function's own `return` is not counted.
+ */
+class EffectCleanupConsistencyRule {
+    static { this.NAME = `${common_1.HOUSE_PLUGIN_NAMESPACE}/effect-cleanup-consistency`; }
+    static { this.RULE = {
+        meta: {
+            type: 'problem',
+            schema: [],
+            messages: {
+                inconsistent: 'The callback of `{{hook}}` returns a cleanup on some paths only; return one on every path (a no-op `() => {}` for an early exit) or on none.',
+            },
+        },
+        create: (context) => {
+            const targets = new Map();
+            let frame;
+            const checkExit = (node) => {
+                const current = frame;
+                if (!current?.hook ||
+                    (0, common_1.nodeType)({ node: (0, common_1.readField)({ node, key: 'body' }) }) !== 'BlockStatement') {
+                    return;
+                }
+                const endIsReachable = [...current.segments].some((segment) => segment.reachable);
+                if (current.returnsValue && (current.returnsNothing || endIsReachable)) {
+                    context.report({ node, messageId: 'inconsistent', data: { hook: current.hook } });
+                }
+            };
+            return {
+                [common_1.AstNodeTypes.CALL_EXPRESSION]: (node) => {
+                    const hook = hook_support_1.HookSupport.calleeName({ call: node });
+                    const args = (0, common_1.readField)({ node, key: 'arguments' });
+                    if (!hook_support_1.HookSupport.isEffectHook({ name: hook }) ||
+                        hook === undefined ||
+                        !Array.isArray(args)) {
+                        return;
+                    }
+                    if (hook_support_1.HookSupport.isCallback({ node: args[0] })) {
+                        targets.set(args[0], hook);
+                    }
+                },
+                onCodePathStart: (_codePath, node) => {
+                    frame = {
+                        upper: frame,
+                        hook: targets.get(node),
+                        returnsValue: false,
+                        returnsNothing: false,
+                        segments: new Set(),
+                    };
+                },
+                onCodePathEnd: () => {
+                    frame = frame?.upper;
+                },
+                onCodePathSegmentStart: (segment) => frame?.segments.add(segment),
+                onCodePathSegmentEnd: (segment) => frame?.segments.delete(segment),
+                onUnreachableCodePathSegmentStart: (segment) => frame?.segments.add(segment),
+                onUnreachableCodePathSegmentEnd: (segment) => frame?.segments.delete(segment),
+                [common_1.AstNodeTypes.RETURN_STATEMENT]: (node) => {
+                    if (!frame) {
+                        return;
+                    }
+                    if ((0, common_1.readField)({ node, key: 'argument' })) {
+                        frame.returnsValue = true;
+                    }
+                    else {
+                        frame.returnsNothing = true;
+                    }
+                },
+                'FunctionExpression:exit': checkExit,
+                'ArrowFunctionExpression:exit': checkExit,
+            };
+        },
+    }; }
+    static build(opts = {}) {
+        return opts.severity ?? 'error';
+    }
+}
+exports.EffectCleanupConsistencyRule = EffectCleanupConsistencyRule;
+//# sourceMappingURL=effect-cleanup-consistency.rule.js.map

package/dist/linters/house/effect-cleanup-consistency.rule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"effect-cleanup-consistency.rule.js","sourceRoot":"","sources":["../../../src/linters/house/effect-cleanup-consistency.rule.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from 'eslint';\nimport type { TRuleSeverity } from '../rules/common';\nimport { AstNodeTypes, HOUSE_PLUGIN_NAMESPACE, nodeType, readField } from './common';\nimport { HookSupport } from './hook-support';\n\n/** What the rule knows about the function whose code path is open; one per function, so a nested function is its own. */\ninterface IFunctionFrame {\n  upper: IFunctionFrame | undefined;\n  hook: string | undefined;\n  returnsValue: boolean;\n  returnsNothing: boolean;\n  segments: Set<{ reachable: boolean }>;\n}\n\n/**\n * `venizia/effect-cleanup-consistency`. The callback of `useEffect`, `useLayoutEffect` and `useInsertionEffect`\n * returns a cleanup on every path or on none. An early `return;` beside a later `return () => {}` leaves React\n * with a cleanup on some runs only; the early exit returns a no-op instead. A bare `return;` and falling off the\n * end both mean \"no value\". It uses ESLint's code path analysis the way `consistent-return` does, so an\n * unreachable end of the function is not a path. A nested function's own `return` is not counted.\n */\nexport class EffectCleanupConsistencyRule {\n  static readonly NAME = `${HOUSE_PLUGIN_NAMESPACE}/effect-cleanup-consistency`;\n\n  static readonly RULE: Rule.RuleModule = {\n    meta: {\n      type: 'problem',\n      schema: [],\n      messages: {\n        inconsistent:\n          'The callback of `{{hook}}` returns a cleanup on some paths only; return one on every path (a no-op `() => {}` for an early exit) or on none.',\n      },\n    },\n    create: (context) => {\n      const targets = new Map<unknown, string>();\n      let frame: IFunctionFrame | undefined;\n\n      const checkExit = (node: Rule.Node) => {\n        const current = frame;\n        if (\n          !current?.hook ||\n          nodeType({ node: readField({ node, key: 'body' }) }) !== 'BlockStatement'\n        ) {\n          return;\n        }\n\n        const endIsReachable = [...current.segments].some((segment) => segment.reachable);\n        if (current.returnsValue && (current.returnsNothing || endIsReachable)) {\n          context.report({ node, messageId: 'inconsistent', data: { hook: current.hook } });\n        }\n      };\n\n      return {\n        [AstNodeTypes.CALL_EXPRESSION]: (node: Rule.Node) => {\n          const hook = HookSupport.calleeName({ call: node });\n          const args = readField({ node, key: 'arguments' });\n          if (\n            !HookSupport.isEffectHook({ name: hook }) ||\n            hook === undefined ||\n            !Array.isArray(args)\n          ) {\n            return;\n          }\n\n          if (HookSupport.isCallback({ node: args[0] })) {\n            targets.set(args[0], hook);\n          }\n        },\n        onCodePathStart: (_codePath, node) => {\n          frame = {\n            upper: frame,\n            hook: targets.get(node),\n            returnsValue: false,\n            returnsNothing: false,\n            segments: new Set(),\n          };\n        },\n        onCodePathEnd: () => {\n          frame = frame?.upper;\n        },\n        onCodePathSegmentStart: (segment) => frame?.segments.add(segment),\n        onCodePathSegmentEnd: (segment) => frame?.segments.delete(segment),\n        onUnreachableCodePathSegmentStart: (segment) => frame?.segments.add(segment),\n        onUnreachableCodePathSegmentEnd: (segment) => frame?.segments.delete(segment),\n        [AstNodeTypes.RETURN_STATEMENT]: (node: Rule.Node) => {\n          if (!frame) {\n            return;\n          }\n\n          if (readField({ node, key: 'argument' })) {\n            frame.returnsValue = true;\n          } else {\n            frame.returnsNothing = true;\n          }\n        },\n        'FunctionExpression:exit': checkExit,\n        'ArrowFunctionExpression:exit': checkExit,\n      };\n    },\n  };\n\n  static build(opts: { severity?: TRuleSeverity } = {}): TRuleSeverity {\n    return opts.severity ?? 'error';\n  }\n}\n"]}

package/dist/linters/house/hook-support.d.ts

@@ -0,0 +1,29 @@
+/** The shared parts of the two hook rules: which call is a hook, and which argument is a function. */
+export declare class HookSupport {
+    /** `useX(...)` and `React.useX(...)`: the name the call is made through, or `undefined` when it is not a plain name. */
+    static calleeName(opts: {
+        call: unknown;
+    }): string | undefined;
+    static isHook(opts: {
+        name: string | undefined;
+    }): boolean;
+    static isEffectHook(opts: {
+        name: string | undefined;
+    }): boolean;
+    /** An arrow or a function expression: the two forms a hook callback is written in. */
+    static isCallback(opts: {
+        node: unknown;
+    }): boolean;
+    static isAsync(opts: {
+        node: unknown;
+    }): boolean;
+    /**
+     * The async functions an argument hands over: the argument itself, a property value of an object literal
+     * (`useMutation({ mutationFn: async () => {} })`, an async method too) and an element of an array literal, at any
+     * depth of literals. It does not look inside a function: what a sync callback builds is not an argument.
+     */
+    static asyncFunctionsIn(opts: {
+        node: unknown;
+    }): unknown[];
+}
+//# sourceMappingURL=hook-support.d.ts.map

package/dist/linters/house/hook-support.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hook-support.d.ts","sourceRoot":"","sources":["../../../src/linters/house/hook-support.ts"],"names":[],"mappings":"AAMA,sGAAsG;AACtG,qBAAa,WAAW;IACtB,wHAAwH;IACxH,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE;QAAE,IAAI,EAAE,OAAO,CAAA;KAAE,GAAG,MAAM,GAAG,SAAS;IAoB9D,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE;QAAE,IAAI,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,GAAG,OAAO;IAI1D,MAAM,CAAC,YAAY,CAAC,IAAI,EAAE;QAAE,IAAI,EAAE,MAAM,GAAG,SAAS,CAAA;KAAE,GAAG,OAAO;IAIhE,sFAAsF;IACtF,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE;QAAE,IAAI,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO;IAInD,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE;QAAE,IAAI,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO;IAIhD;;;;OAIG;IACH,MAAM,CAAC,gBAAgB,CAAC,IAAI,EAAE;QAAE,IAAI,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,EAAE;CA8B5D"}

package/dist/linters/house/hook-support.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HookSupport = void 0;
+const common_1 = require("./common");
+const HOOK_NAME = /^use[A-Z]/;
+const EFFECT_HOOKS = new Set(['useEffect', 'useLayoutEffect', 'useInsertionEffect']);
+const CALLBACK_TYPES = new Set(['ArrowFunctionExpression', 'FunctionExpression']);
+/** The shared parts of the two hook rules: which call is a hook, and which argument is a function. */
+class HookSupport {
+    /** `useX(...)` and `React.useX(...)`: the name the call is made through, or `undefined` when it is not a plain name. */
+    static calleeName(opts) {
+        const callee = (0, common_1.readField)({ node: opts.call, key: 'callee' });
+        const type = (0, common_1.nodeType)({ node: callee });
+        if (type === 'Identifier') {
+            const name = (0, common_1.readField)({ node: callee, key: 'name' });
+            return typeof name === 'string' ? name : undefined;
+        }
+        if (type === 'MemberExpression' && (0, common_1.readField)({ node: callee, key: 'computed' }) === false) {
+            const property = (0, common_1.readField)({ node: callee, key: 'property' });
+            const name = (0, common_1.readField)({ node: property, key: 'name' });
+            return (0, common_1.nodeType)({ node: property }) === 'Identifier' && typeof name === 'string'
+                ? name
+                : undefined;
+        }
+        return undefined;
+    }
+    static isHook(opts) {
+        return opts.name !== undefined && HOOK_NAME.test(opts.name);
+    }
+    static isEffectHook(opts) {
+        return opts.name !== undefined && EFFECT_HOOKS.has(opts.name);
+    }
+    /** An arrow or a function expression: the two forms a hook callback is written in. */
+    static isCallback(opts) {
+        return CALLBACK_TYPES.has((0, common_1.nodeType)({ node: opts.node }) ?? '');
+    }
+    static isAsync(opts) {
+        return HookSupport.isCallback(opts) && (0, common_1.readField)({ node: opts.node, key: 'async' }) === true;
+    }
+    /**
+     * The async functions an argument hands over: the argument itself, a property value of an object literal
+     * (`useMutation({ mutationFn: async () => {} })`, an async method too) and an element of an array literal, at any
+     * depth of literals. It does not look inside a function: what a sync callback builds is not an argument.
+     */
+    static asyncFunctionsIn(opts) {
+        const { node } = opts;
+        const type = (0, common_1.nodeType)({ node });
+        if (HookSupport.isAsync({ node })) {
+            return [node];
+        }
+        if (type === 'ObjectExpression') {
+            const properties = (0, common_1.readField)({ node, key: 'properties' });
+            return Array.isArray(properties)
+                ? properties.flatMap((property) => (0, common_1.nodeType)({ node: property }) === 'Property'
+                    ? HookSupport.asyncFunctionsIn({ node: (0, common_1.readField)({ node: property, key: 'value' }) })
+                    : [])
+                : [];
+        }
+        if (type === 'ArrayExpression') {
+            const elements = (0, common_1.readField)({ node, key: 'elements' });
+            return Array.isArray(elements)
+                ? elements.flatMap((element) => HookSupport.asyncFunctionsIn({ node: element }))
+                : [];
+        }
+        return [];
+    }
+}
+exports.HookSupport = HookSupport;
+//# sourceMappingURL=hook-support.js.map

package/dist/linters/house/hook-support.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hook-support.js","sourceRoot":"","sources":["../../../src/linters/house/hook-support.ts"],"names":[],"mappings":"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","sourcesContent":["import { nodeType, readField } from './common';\n\nconst HOOK_NAME = /^use[A-Z]/;\nconst EFFECT_HOOKS = new Set(['useEffect', 'useLayoutEffect', 'useInsertionEffect']);\nconst CALLBACK_TYPES = new Set(['ArrowFunctionExpression', 'FunctionExpression']);\n\n/** The shared parts of the two hook rules: which call is a hook, and which argument is a function. */\nexport class HookSupport {\n  /** `useX(...)` and `React.useX(...)`: the name the call is made through, or `undefined` when it is not a plain name. */\n  static calleeName(opts: { call: unknown }): string | undefined {\n    const callee = readField({ node: opts.call, key: 'callee' });\n    const type = nodeType({ node: callee });\n\n    if (type === 'Identifier') {\n      const name = readField({ node: callee, key: 'name' });\n      return typeof name === 'string' ? name : undefined;\n    }\n\n    if (type === 'MemberExpression' && readField({ node: callee, key: 'computed' }) === false) {\n      const property = readField({ node: callee, key: 'property' });\n      const name = readField({ node: property, key: 'name' });\n      return nodeType({ node: property }) === 'Identifier' && typeof name === 'string'\n        ? name\n        : undefined;\n    }\n\n    return undefined;\n  }\n\n  static isHook(opts: { name: string | undefined }): boolean {\n    return opts.name !== undefined && HOOK_NAME.test(opts.name);\n  }\n\n  static isEffectHook(opts: { name: string | undefined }): boolean {\n    return opts.name !== undefined && EFFECT_HOOKS.has(opts.name);\n  }\n\n  /** An arrow or a function expression: the two forms a hook callback is written in. */\n  static isCallback(opts: { node: unknown }): boolean {\n    return CALLBACK_TYPES.has(nodeType({ node: opts.node }) ?? '');\n  }\n\n  static isAsync(opts: { node: unknown }): boolean {\n    return HookSupport.isCallback(opts) && readField({ node: opts.node, key: 'async' }) === true;\n  }\n\n  /**\n   * The async functions an argument hands over: the argument itself, a property value of an object literal\n   * (`useMutation({ mutationFn: async () => {} })`, an async method too) and an element of an array literal, at any\n   * depth of literals. It does not look inside a function: what a sync callback builds is not an argument.\n   */\n  static asyncFunctionsIn(opts: { node: unknown }): unknown[] {\n    const { node } = opts;\n    const type = nodeType({ node });\n\n    if (HookSupport.isAsync({ node })) {\n      return [node];\n    }\n\n    if (type === 'ObjectExpression') {\n      const properties = readField({ node, key: 'properties' });\n\n      return Array.isArray(properties)\n        ? properties.flatMap((property) =>\n            nodeType({ node: property }) === 'Property'\n              ? HookSupport.asyncFunctionsIn({ node: readField({ node: property, key: 'value' }) })\n              : [],\n          )\n        : [];\n    }\n\n    if (type === 'ArrayExpression') {\n      const elements = readField({ node, key: 'elements' });\n\n      return Array.isArray(elements)\n        ? elements.flatMap((element) => HookSupport.asyncFunctionsIn({ node: element }))\n        : [];\n    }\n\n    return [];\n  }\n}\n"]}

package/dist/linters/house/index.d.ts

@@ -1,8 +1,14 @@
+export * from './await-support';
 export * from './common';
 export * from './const-class-values.rule';
+export * from './effect-cleanup-consistency.rule';
+export * from './hook-support';
 export * from './max-params-own.rule';
+export * from './no-async-hook-callback.rule';
+export * from './no-inline-await.rule';
 export * from './no-leaked-render.rule';
 export * from './no-new-error.rule';
+export * from './no-return-await.rule';
 export * from './plugin';
 export * from './configs';
 //# sourceMappingURL=index.d.ts.map

package/dist/linters/house/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/linters/house/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAC;AACzB,cAAc,2BAA2B,CAAC;AAC1C,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,qBAAqB,CAAC;AACpC,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/linters/house/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,UAAU,CAAC;AACzB,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mCAAmC,CAAC;AAClD,cAAc,gBAAgB,CAAC;AAC/B,cAAc,uBAAuB,CAAC;AACtC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,qBAAqB,CAAC;AACpC,cAAc,wBAAwB,CAAC;AACvC,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC"}

package/dist/linters/house/index.js

@@ -14,11 +14,17 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./await-support"), exports);
 __exportStar(require("./common"), exports);
 __exportStar(require("./const-class-values.rule"), exports);
+__exportStar(require("./effect-cleanup-consistency.rule"), exports);
+__exportStar(require("./hook-support"), exports);
 __exportStar(require("./max-params-own.rule"), exports);
+__exportStar(require("./no-async-hook-callback.rule"), exports);
+__exportStar(require("./no-inline-await.rule"), exports);
 __exportStar(require("./no-leaked-render.rule"), exports);
 __exportStar(require("./no-new-error.rule"), exports);
+__exportStar(require("./no-return-await.rule"), exports);
 __exportStar(require("./plugin"), exports);
 __exportStar(require("./configs"), exports);
 //# sourceMappingURL=index.js.map

package/dist/linters/house/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/linters/house/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,2CAAyB;AACzB,4DAA0C;AAC1C,wDAAsC;AACtC,0DAAwC;AACxC,sDAAoC;AACpC,2CAAyB;AACzB,4CAA0B","sourcesContent":["export * from './common';\nexport * from './const-class-values.rule';\nexport * from './max-params-own.rule';\nexport * from './no-leaked-render.rule';\nexport * from './no-new-error.rule';\nexport * from './plugin';\nexport * from './configs';\n"]}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/linters/house/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,kDAAgC;AAChC,2CAAyB;AACzB,4DAA0C;AAC1C,oEAAkD;AAClD,iDAA+B;AAC/B,wDAAsC;AACtC,gEAA8C;AAC9C,yDAAuC;AACvC,0DAAwC;AACxC,sDAAoC;AACpC,yDAAuC;AACvC,2CAAyB;AACzB,4CAA0B","sourcesContent":["export * from './await-support';\nexport * from './common';\nexport * from './const-class-values.rule';\nexport * from './effect-cleanup-consistency.rule';\nexport * from './hook-support';\nexport * from './max-params-own.rule';\nexport * from './no-async-hook-callback.rule';\nexport * from './no-inline-await.rule';\nexport * from './no-leaked-render.rule';\nexport * from './no-new-error.rule';\nexport * from './no-return-await.rule';\nexport * from './plugin';\nexport * from './configs';\n"]}

package/dist/linters/house/no-async-hook-callback.rule.d.ts

@@ -0,0 +1,18 @@
+import type { Rule } from 'eslint';
+import type { TRuleSeverity } from '../rules/common';
+/**
+ * `venizia/no-async-hook-callback`. A hook never gets an async function: `useEffect(async () => {})` makes the
+ * callback return a promise where React expects a cleanup function or nothing. Pass a sync callback and handle
+ * the promise inside it with `.then`, `.catch` and `.finally`. Every argument of a `use[A-Z]...` call is checked,
+ * `React.useX` too: an async function as the argument, as the value of a property of an object literal
+ * (`useMutation({ mutationFn: async () => {} })`) and as an element of an array literal. A sync callback that
+ * builds an async function inside is not an argument and is left alone.
+ */
+export declare class NoAsyncHookCallbackRule {
+    static readonly NAME = "venizia/no-async-hook-callback";
+    static readonly RULE: Rule.RuleModule;
+    static build(opts?: {
+        severity?: TRuleSeverity;
+    }): TRuleSeverity;
+}
+//# sourceMappingURL=no-async-hook-callback.rule.d.ts.map

package/dist/linters/house/no-async-hook-callback.rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-async-hook-callback.rule.d.ts","sourceRoot":"","sources":["../../../src/linters/house/no-async-hook-callback.rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AACnC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAKrD;;;;;;;GAOG;AACH,qBAAa,uBAAuB;IAClC,MAAM,CAAC,QAAQ,CAAC,IAAI,oCAAsD;IAE1E,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,UAAU,CA8BnC;IAEF,MAAM,CAAC,KAAK,CAAC,IAAI,GAAE;QAAE,QAAQ,CAAC,EAAE,aAAa,CAAA;KAAO,GAAG,aAAa;CAGrE"}

package/dist/linters/house/no-async-hook-callback.rule.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoAsyncHookCallbackRule = void 0;
+const await_support_1 = require("./await-support");
+const common_1 = require("./common");
+const hook_support_1 = require("./hook-support");
+/**
+ * `venizia/no-async-hook-callback`. A hook never gets an async function: `useEffect(async () => {})` makes the
+ * callback return a promise where React expects a cleanup function or nothing. Pass a sync callback and handle
+ * the promise inside it with `.then`, `.catch` and `.finally`. Every argument of a `use[A-Z]...` call is checked,
+ * `React.useX` too: an async function as the argument, as the value of a property of an object literal
+ * (`useMutation({ mutationFn: async () => {} })`) and as an element of an array literal. A sync callback that
+ * builds an async function inside is not an argument and is left alone.
+ */
+class NoAsyncHookCallbackRule {
+    static { this.NAME = `${common_1.HOUSE_PLUGIN_NAMESPACE}/no-async-hook-callback`; }
+    static { this.RULE = {
+        meta: {
+            type: 'problem',
+            schema: [],
+            messages: {
+                asyncCallback: 'Do not pass an async function to `{{hook}}`; pass a sync callback and handle the promise inside it with .then/.catch/.finally.',
+            },
+        },
+        create: (context) => ({
+            [common_1.AstNodeTypes.CALL_EXPRESSION]: (node) => {
+                const hook = hook_support_1.HookSupport.calleeName({ call: node });
+                if (hook === undefined || !hook_support_1.HookSupport.isHook({ name: hook })) {
+                    return;
+                }
+                const args = (0, common_1.readField)({ node, key: 'arguments' });
+                if (!Array.isArray(args)) {
+                    return;
+                }
+                for (const argument of args) {
+                    for (const found of hook_support_1.HookSupport.asyncFunctionsIn({ node: argument })) {
+                        if (await_support_1.AwaitSupport.isNode(found)) {
+                            context.report({ node: found, messageId: 'asyncCallback', data: { hook } });
+                        }
+                    }
+                }
+            },
+        }),
+    }; }
+    static build(opts = {}) {
+        return opts.severity ?? 'error';
+    }
+}
+exports.NoAsyncHookCallbackRule = NoAsyncHookCallbackRule;
+//# sourceMappingURL=no-async-hook-callback.rule.js.map

package/dist/linters/house/no-async-hook-callback.rule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-async-hook-callback.rule.js","sourceRoot":"","sources":["../../../src/linters/house/no-async-hook-callback.rule.ts"],"names":[],"mappings":";;;AAEA,mDAA+C;AAC/C,qCAA2E;AAC3E,iDAA6C;AAE7C;;;;;;;GAOG;AACH,MAAa,uBAAuB;aAClB,SAAI,GAAG,GAAG,+BAAsB,yBAAyB,CAAC;aAE1D,SAAI,GAAoB;QACtC,IAAI,EAAE;YACJ,IAAI,EAAE,SAAS;YACf,MAAM,EAAE,EAAE;YACV,QAAQ,EAAE;gBACR,aAAa,EACX,gIAAgI;aACnI;SACF;QACD,MAAM,EAAE,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC;YACpB,CAAC,qBAAY,CAAC,eAAe,CAAC,EAAE,CAAC,IAAe,EAAE,EAAE;gBAClD,MAAM,IAAI,GAAG,0BAAW,CAAC,UAAU,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,CAAC;gBACpD,IAAI,IAAI,KAAK,SAAS,IAAI,CAAC,0BAAW,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC,EAAE,CAAC;oBAC9D,OAAO;gBACT,CAAC;gBAED,MAAM,IAAI,GAAG,IAAA,kBAAS,EAAC,EAAE,IAAI,EAAE,GAAG,EAAE,WAAW,EAAE,CAAC,CAAC;gBACnD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;oBACzB,OAAO;gBACT,CAAC;gBAED,KAAK,MAAM,QAAQ,IAAI,IAAI,EAAE,CAAC;oBAC5B,KAAK,MAAM,KAAK,IAAI,0BAAW,CAAC,gBAAgB,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,EAAE,CAAC;wBACrE,IAAI,4BAAY,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;4BAC/B,OAAO,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,SAAS,EAAE,eAAe,EAAE,IAAI,EAAE,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC;wBAC9E,CAAC;oBACH,CAAC;gBACH,CAAC;YACH,CAAC;SACF,CAAC;KACH,CAAC;IAEF,MAAM,CAAC,KAAK,CAAC,OAAqC,EAAE;QAClD,OAAO,IAAI,CAAC,QAAQ,IAAI,OAAO,CAAC;IAClC,CAAC;;AArCH,0DAsCC","sourcesContent":["import type { Rule } from 'eslint';\nimport type { TRuleSeverity } from '../rules/common';\nimport { AwaitSupport } from './await-support';\nimport { AstNodeTypes, HOUSE_PLUGIN_NAMESPACE, readField } from './common';\nimport { HookSupport } from './hook-support';\n\n/**\n * `venizia/no-async-hook-callback`. A hook never gets an async function: `useEffect(async () => {})` makes the\n * callback return a promise where React expects a cleanup function or nothing. Pass a sync callback and handle\n * the promise inside it with `.then`, `.catch` and `.finally`. Every argument of a `use[A-Z]...` call is checked,\n * `React.useX` too: an async function as the argument, as the value of a property of an object literal\n * (`useMutation({ mutationFn: async () => {} })`) and as an element of an array literal. A sync callback that\n * builds an async function inside is not an argument and is left alone.\n */\nexport class NoAsyncHookCallbackRule {\n  static readonly NAME = `${HOUSE_PLUGIN_NAMESPACE}/no-async-hook-callback`;\n\n  static readonly RULE: Rule.RuleModule = {\n    meta: {\n      type: 'problem',\n      schema: [],\n      messages: {\n        asyncCallback:\n          'Do not pass an async function to `{{hook}}`; pass a sync callback and handle the promise inside it with .then/.catch/.finally.',\n      },\n    },\n    create: (context) => ({\n      [AstNodeTypes.CALL_EXPRESSION]: (node: Rule.Node) => {\n        const hook = HookSupport.calleeName({ call: node });\n        if (hook === undefined || !HookSupport.isHook({ name: hook })) {\n          return;\n        }\n\n        const args = readField({ node, key: 'arguments' });\n        if (!Array.isArray(args)) {\n          return;\n        }\n\n        for (const argument of args) {\n          for (const found of HookSupport.asyncFunctionsIn({ node: argument })) {\n            if (AwaitSupport.isNode(found)) {\n              context.report({ node: found, messageId: 'asyncCallback', data: { hook } });\n            }\n          }\n        }\n      },\n    }),\n  };\n\n  static build(opts: { severity?: TRuleSeverity } = {}): TRuleSeverity {\n    return opts.severity ?? 'error';\n  }\n}\n"]}

package/dist/linters/house/no-inline-await.rule.d.ts

@@ -0,0 +1,20 @@
+import type { Rule } from 'eslint';
+import type { TRuleSeverity } from '../rules/common';
+/**
+ * `venizia/no-inline-await`. `await` stands alone: as a whole statement (`await f();`) or as the whole initializer
+ * of a declaration (`const result = await f();`). Inside any other expression - a call argument, a spread, an
+ * array or object, a ternary, a logical operator, a template literal, a member access, an assignment - it is
+ * reported, and `return g(await f())` is the same report. `return await f()` is `no-return-await`'s.
+ *
+ * The fix moves the `await` into a `const` in front of the statement. It is made only when nothing that does more
+ * than read a value runs before the `await` inside the statement, and when the `await` is not in a branch, a loop
+ * test, an unbraced `if` branch or an arrow expression body; those cases are reported and left alone.
+ */
+export declare class NoInlineAwaitRule {
+    static readonly NAME = "venizia/no-inline-await";
+    static readonly RULE: Rule.RuleModule;
+    static build(opts?: {
+        severity?: TRuleSeverity;
+    }): TRuleSeverity;
+}
+//# sourceMappingURL=no-inline-await.rule.d.ts.map

package/dist/linters/house/no-inline-await.rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-inline-await.rule.d.ts","sourceRoot":"","sources":["../../../src/linters/house/no-inline-await.rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AACnC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAIrD;;;;;;;;;GASG;AACH,qBAAa,iBAAiB;IAC5B,MAAM,CAAC,QAAQ,CAAC,IAAI,6BAA+C;IAEnE,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,UAAU,CAgEnC;IAEF,MAAM,CAAC,KAAK,CAAC,IAAI,GAAE;QAAE,QAAQ,CAAC,EAAE,aAAa,CAAA;KAAO,GAAG,aAAa;CAGrE"}

package/dist/linters/house/no-inline-await.rule.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoInlineAwaitRule = void 0;
+const await_support_1 = require("./await-support");
+const common_1 = require("./common");
+/**
+ * `venizia/no-inline-await`. `await` stands alone: as a whole statement (`await f();`) or as the whole initializer
+ * of a declaration (`const result = await f();`). Inside any other expression - a call argument, a spread, an
+ * array or object, a ternary, a logical operator, a template literal, a member access, an assignment - it is
+ * reported, and `return g(await f())` is the same report. `return await f()` is `no-return-await`'s.
+ *
+ * The fix moves the `await` into a `const` in front of the statement. It is made only when nothing that does more
+ * than read a value runs before the `await` inside the statement, and when the `await` is not in a branch, a loop
+ * test, an unbraced `if` branch or an arrow expression body; those cases are reported and left alone.
+ */
+class NoInlineAwaitRule {
+    static { this.NAME = `${common_1.HOUSE_PLUGIN_NAMESPACE}/no-inline-await`; }
+    static { this.RULE = {
+        meta: {
+            type: 'suggestion',
+            fixable: 'code',
+            schema: [],
+            messages: {
+                inline: '`await` stands alone as a statement or as the whole initializer of a declaration (`const result = await f();`), not inside an expression.',
+            },
+        },
+        create: (context) => {
+            const { sourceCode } = context;
+            const taken = new Map();
+            return {
+                [common_1.AstNodeTypes.AWAIT_EXPRESSION]: (node) => {
+                    const parent = await_support_1.AwaitSupport.parentOf({ node });
+                    const parentType = (0, common_1.nodeType)({ node: parent });
+                    const isWhole = (parentType === 'ExpressionStatement' &&
+                        (0, common_1.readField)({ node: parent, key: 'expression' }) === node) ||
+                        (parentType === 'VariableDeclarator' &&
+                            (0, common_1.readField)({ node: parent, key: 'init' }) === node);
+                    const isReturned = (parentType === 'ReturnStatement' || parentType === 'ArrowFunctionExpression') &&
+                        ((0, common_1.readField)({ node: parent, key: 'argument' }) === node ||
+                            (0, common_1.readField)({ node: parent, key: 'body' }) === node);
+                    if (isWhole || isReturned) {
+                        return;
+                    }
+                    const statement = await_support_1.AwaitSupport.hoistTarget({ awaitNode: node });
+                    const canFix = statement !== undefined &&
+                        !await_support_1.AwaitSupport.hasEffectBefore({ statement, awaitNode: node, sourceCode });
+                    context.report({
+                        node,
+                        messageId: 'inline',
+                        fix: canFix
+                            ? (fixer) => {
+                                const name = await_support_1.AwaitSupport.freshName({
+                                    node,
+                                    base: 'result',
+                                    sourceCode,
+                                    taken,
+                                });
+                                const [start, end] = await_support_1.AwaitSupport.replaceRangeOf({ awaitNode: node, sourceCode });
+                                const indent = await_support_1.AwaitSupport.indentOf({ node: statement, sourceCode });
+                                return [
+                                    fixer.insertTextBefore(statement, `const ${name} = ${sourceCode.getText(node)};\n${indent}`),
+                                    fixer.replaceTextRange([start, end], name),
+                                ];
+                            }
+                            : null,
+                    });
+                },
+            };
+        },
+    }; }
+    static build(opts = {}) {
+        return opts.severity ?? 'error';
+    }
+}
+exports.NoInlineAwaitRule = NoInlineAwaitRule;
+//# sourceMappingURL=no-inline-await.rule.js.map

package/dist/linters/house/no-inline-await.rule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-inline-await.rule.js","sourceRoot":"","sources":["../../../src/linters/house/no-inline-await.rule.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from 'eslint';\nimport type { TRuleSeverity } from '../rules/common';\nimport { AwaitSupport } from './await-support';\nimport { AstNodeTypes, HOUSE_PLUGIN_NAMESPACE, nodeType, readField } from './common';\n\n/**\n * `venizia/no-inline-await`. `await` stands alone: as a whole statement (`await f();`) or as the whole initializer\n * of a declaration (`const result = await f();`). Inside any other expression - a call argument, a spread, an\n * array or object, a ternary, a logical operator, a template literal, a member access, an assignment - it is\n * reported, and `return g(await f())` is the same report. `return await f()` is `no-return-await`'s.\n *\n * The fix moves the `await` into a `const` in front of the statement. It is made only when nothing that does more\n * than read a value runs before the `await` inside the statement, and when the `await` is not in a branch, a loop\n * test, an unbraced `if` branch or an arrow expression body; those cases are reported and left alone.\n */\nexport class NoInlineAwaitRule {\n  static readonly NAME = `${HOUSE_PLUGIN_NAMESPACE}/no-inline-await`;\n\n  static readonly RULE: Rule.RuleModule = {\n    meta: {\n      type: 'suggestion',\n      fixable: 'code',\n      schema: [],\n      messages: {\n        inline:\n          '`await` stands alone as a statement or as the whole initializer of a declaration (`const result = await f();`), not inside an expression.',\n      },\n    },\n    create: (context) => {\n      const { sourceCode } = context;\n      const taken = new Map<unknown, Set<string>>();\n\n      return {\n        [AstNodeTypes.AWAIT_EXPRESSION]: (node: Rule.Node) => {\n          const parent = AwaitSupport.parentOf({ node });\n          const parentType = nodeType({ node: parent });\n          const isWhole =\n            (parentType === 'ExpressionStatement' &&\n              readField({ node: parent, key: 'expression' }) === node) ||\n            (parentType === 'VariableDeclarator' &&\n              readField({ node: parent, key: 'init' }) === node);\n          const isReturned =\n            (parentType === 'ReturnStatement' || parentType === 'ArrowFunctionExpression') &&\n            (readField({ node: parent, key: 'argument' }) === node ||\n              readField({ node: parent, key: 'body' }) === node);\n\n          if (isWhole || isReturned) {\n            return;\n          }\n\n          const statement = AwaitSupport.hoistTarget({ awaitNode: node });\n          const canFix =\n            statement !== undefined &&\n            !AwaitSupport.hasEffectBefore({ statement, awaitNode: node, sourceCode });\n\n          context.report({\n            node,\n            messageId: 'inline',\n            fix: canFix\n              ? (fixer) => {\n                  const name = AwaitSupport.freshName({\n                    node,\n                    base: 'result',\n                    sourceCode,\n                    taken,\n                  });\n                  const [start, end] = AwaitSupport.replaceRangeOf({ awaitNode: node, sourceCode });\n                  const indent = AwaitSupport.indentOf({ node: statement, sourceCode });\n\n                  return [\n                    fixer.insertTextBefore(\n                      statement,\n                      `const ${name} = ${sourceCode.getText(node)};\\n${indent}`,\n                    ),\n                    fixer.replaceTextRange([start, end], name),\n                  ];\n                }\n              : null,\n          });\n        },\n      };\n    },\n  };\n\n  static build(opts: { severity?: TRuleSeverity } = {}): TRuleSeverity {\n    return opts.severity ?? 'error';\n  }\n}\n"]}

package/dist/linters/house/no-return-await.rule.d.ts

@@ -0,0 +1,15 @@
+import type { Rule } from 'eslint';
+import type { TRuleSeverity } from '../rules/common';
+/**
+ * `venizia/no-return-await`. A function returns the promise (`return f()`), never `return await f()`. Where the
+ * `await` matters (inside `try`, `catch` or `finally`) it is written on its own line:
+ * `const result = await f(); return result;`. An arrow whose body is an `await` is the same: `() => f()`.
+ */
+export declare class NoReturnAwaitRule {
+    static readonly NAME = "venizia/no-return-await";
+    static readonly RULE: Rule.RuleModule;
+    static build(opts?: {
+        severity?: TRuleSeverity;
+    }): TRuleSeverity;
+}
+//# sourceMappingURL=no-return-await.rule.d.ts.map

package/dist/linters/house/no-return-await.rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-return-await.rule.d.ts","sourceRoot":"","sources":["../../../src/linters/house/no-return-await.rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AACnC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAyBrD;;;;GAIG;AACH,qBAAa,iBAAiB;IAC5B,MAAM,CAAC,QAAQ,CAAC,IAAI,6BAA+C;IAEnE,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,UAAU,CAwEnC;IAEF,MAAM,CAAC,KAAK,CAAC,IAAI,GAAE;QAAE,QAAQ,CAAC,EAAE,aAAa,CAAA;KAAO,GAAG,aAAa;CAGrE"}