@jskit-ai/config-eslint 0.1.242 → 0.1.244

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/config-eslint",
-  "version": "0.1.242",
+  "version": "0.1.244",
   "description": "Shared flat ESLint presets for JSKIT projects.",
   "type": "module",
   "files": [

package/plugin/rules/actionExecuteShape.js

@@ -1,4 +1,4 @@
-import { createReporter, isActionExecute, keyName, ruleMeta } from "../support.js";
+import { createReporter, isActionExecute, keyName, ruleMeta, unwrapAwait, unwrapChain } from "../support.js";
 
 // A callee a reader follows in one step: a name or a member chain, with no
 // call inside it.
@@ -9,11 +9,6 @@ function isPlainCallee(node) {
   return node.type === "MemberExpression" && isPlainCallee(node.object);
 }
 
-function unwrapCall(node) {
-  const value = node.type === "AwaitExpression" ? node.argument : node;
-  return value.type === "ChainExpression" ? value.expression : value;
-}
-
 // The shape problem of an action's execute, or null for
 // `execute: (input, context) => service.method(…)`. Its parameters may
 // destructure what must not reach the service (`({ workspaceSlug, ...payload },
@@ -34,7 +29,7 @@ function shapeProblem(value) {
   if (value.type !== "ArrowFunctionExpression") {
     return "notArrow";
   }
-  const body = unwrapCall(value.body);
+  const body = unwrapChain(unwrapAwait(value.body));
   if (body.type !== "CallExpression" || !isPlainCallee(body.callee)) {
     return "notOneCall";
   }

package/plugin/rules/collaboratorProps.js

@@ -1,4 +1,4 @@
-import { ABSENT_DEFAULT, CLIENT_GUIDE_URL, compactText, createReporter, keyName, ruleMeta } from "../support.js";
+import { ABSENT_DEFAULT, CLIENT_GUIDE_URL, compactText, createReporter, keyName, ruleMeta, unwrapChain } from "../support.js";
 
 // Prop types whose values are data: a call on one (`items.map()`) is not a call on a collaborator.
 const DATA_TYPES = new Set(["Array", "String", "Number", "Boolean", "Date", "RegExp", "Symbol", "BigInt"]);
@@ -21,26 +21,22 @@ function declaredProps(node) {
   return null;
 }
 
-function unchain(node) {
-  return node?.type === "ChainExpression" ? node.expression : node;
-}
-
 // The prop a call reaches through, or "": `props.x()`, `props.x.y()` or `props.x?.y()` in the script, `x()` or
 // `x.y()` in the template.
 function calledProp(callee, propsBinding, inTemplate) {
-  const target = unchain(callee);
+  const target = unwrapChain(callee);
   if (inTemplate) {
-    const root = target.type === "MemberExpression" ? unchain(target.object) : target;
+    const root = target.type === "MemberExpression" ? unwrapChain(target.object) : target;
     return root.type === "Identifier" ? root.name : "";
   }
   if (target.type !== "MemberExpression") {
     return "";
   }
-  const owner = unchain(target.object);
+  const owner = unwrapChain(target.object);
   if (owner.type === "Identifier" && owner.name === propsBinding) {
     return target.computed ? "" : target.property.name;
   }
-  const root = owner.type === "MemberExpression" && !owner.computed ? unchain(owner.object) : null;
+  const root = owner.type === "MemberExpression" && !owner.computed ? unwrapChain(owner.object) : null;
   return root?.type === "Identifier" && root.name === propsBinding ? owner.property.name : "";
 }
 

package/plugin/rules/fixedResultShape.js

@@ -1,5 +1,5 @@
 import { FUNCTION_TYPES, definedName, definitionOf, enclosingFunction } from "../factoryResults.js";
-import { CLIENT_GUIDE_URL, createReporter, keyName, ruleMeta } from "../support.js";
+import { CLIENT_GUIDE_URL, createReporter, keyName, ruleMeta, unwrapAwait } from "../support.js";
 
 const RESULT_FACTORY = /^(create|use)[A-Z]/u;
 
@@ -25,10 +25,6 @@ function addsBehaviour(sourceCode, value) {
   return definition?.type === "FunctionName" || (definition?.type === "Variable" && FUNCTION_TYPES.has(definition.node.init?.type));
 }
 
-function unwrapAwait(node) {
-  return node?.type === "AwaitExpression" ? node.argument : node;
-}
-
 // The create*/use* call a wrapper's callback builds its result with, or null:
 // `app.runWithContext(() => createRuntime(readers))` returns that runtime.
 function callbackFactoryCall(call) {

package/plugin/rules/noDualShape.js

@@ -1,11 +1,7 @@
-import { createReporter, ruleMeta } from "../support.js";
+import { createReporter, ruleMeta, unwrapChain } from "../support.js";
 
 const REFERENCE_TYPES = new Set(["Identifier", "MemberExpression", "ThisExpression"]);
 
-function unwrapChain(node) {
-  return node?.type === "ChainExpression" ? node.expression : node;
-}
-
 // A reference's text with optional links read as plain ones, so `a?.b` and
 // `a.b` name the same value.
 function referenceText(sourceCode, node) {

package/plugin/rules/noFactorySpread.js

@@ -1,5 +1,5 @@
 import { CREATE_NAME, FUNCTION_TYPES, definedName, definitionOf, enclosingFunction, holdsBehaviour, localFunction, returnsOnlyData } from "../factoryResults.js";
-import { createReporter, isClientLint, isFreezeCall, ruleMeta } from "../support.js";
+import { createReporter, isClientLint, isFreezeCall, ruleMeta, unwrapAwait } from "../support.js";
 
 // A decorator over the JSKIT CRUD service or repository spreads it: its
 // members are the contract's.
@@ -7,17 +7,13 @@ const CRUD_DECORATOR = /^decorate\w*(?:Service|Repository)$/u;
 // In client code a composable's result is an API too.
 const CLIENT_FACTORY_NAME = /^(create|use)[A-Z]/u;
 
-function unwrap(node) {
-  return node?.type === "AwaitExpression" ? node.argument : node;
-}
-
 // The create* call a spread argument comes from: the call itself, or the call
 // that initialised the variable it reads.
 function factoryCall(sourceCode, argument) {
-  const value = unwrap(argument);
+  const value = unwrapAwait(argument);
   if (value.type === "Identifier") {
     const definition = definitionOf(sourceCode, value);
-    const init = unwrap(definition?.type === "Variable" ? definition.node.init : null);
+    const init = unwrapAwait(definition?.type === "Variable" ? definition.node.init : null);
     return init?.type === "CallExpression" ? { call: init, via: value.name } : null;
   }
   return value.type === "CallExpression" ? { call: value, via: "" } : null;

package/plugin/rules/requiredCollaborators.js

@@ -7,6 +7,7 @@ import {
   isFactory,
   receivingFunction,
   ruleMeta,
+  unwrapChain,
   walk
 } from "../support.js";
 
@@ -100,7 +101,7 @@ const requiredCollaborators = Object.freeze({
     }
     function checkProbe(node) {
       const probed = probedArgument(node);
-      const argument = probed?.type === "ChainExpression" ? probed.expression : probed;
+      const argument = unwrapChain(probed);
       const receiver = argument?.type === "Identifier" ? receivingFunction(context, node, argument.name) : null;
       if (argument?.type === "MemberExpression" || (receiver && isFactory(receiver, client))) {
         report(node, "method-probe", "methodProbe", { probe: sourceCode.getText(probed) });
@@ -109,7 +110,7 @@ const requiredCollaborators = Object.freeze({
     // A template has no parameters of its own, so only member probes are read there.
     function checkTemplateProbe(node) {
       const probed = probedArgument(node);
-      const argument = probed?.type === "ChainExpression" ? probed.expression : probed;
+      const argument = unwrapChain(probed);
       if (argument?.type === "MemberExpression") {
         report(node, "method-probe", "methodProbe", { probe: sourceCode.getText(probed) });
       }

package/plugin/rules/typedInject.js

@@ -33,16 +33,31 @@ function isTypedInjection(sourceCode, call) {
   return hasJsdocBefore(sourceCode, owner, RETURNS_TAG);
 }
 
+/**
+ * The `required` option of the function holding an inject() call, as in `useRuntime({ required = false } = {})`.
+ * @param {any} sourceCode
+ * @param {any} call
+ */
+function requiredOption(sourceCode, call) {
+  const first = sourceCode.getAncestors(call).findLast((ancestor) => FUNCTION_TYPES.has(ancestor.type))?.params[0];
+  const pattern = first?.type === "AssignmentPattern" ? first.left : first;
+  return pattern?.type === "ObjectPattern"
+    ? pattern.properties.find((property) => property.type === "Property" && property.key.name === "required")
+    : undefined;
+}
+
 // An injected value is a capability lookup: it takes the owner's exported key,
 // names its type, and resolves once, either required (`inject(KEY)`) or to the
 // owner's named default (`inject(KEY, NO_X)`), never to null or {} that is then
-// probed. A consumer that cannot depend on the key's owner writes the key in
-// place, typed and with a named NO_* default, as a server token is written.
+// probed, and never by a `required` mode that gives one key two outcomes. A
+// consumer that cannot depend on the key's owner writes the key in place, typed
+// and with a named NO_* default, as a server token is written.
 const typedInject = Object.freeze({
   meta: ruleMeta("Require inject() to take an exported key, name the injected type and never default to nothing.", {
     literalKey: "inject({{key}}) names its key in place. Import the owner's exported key constant.",
     absentDefault: "inject(…, {{fallback}}) resolves to nothing, so every use probes it. Inject it required, or default to the owner's named default.",
-    untypedInject: "inject({{key}}) has no type. Name it with a JSDoc @type on the binding, a cast, or the accessor's @returns."
+    untypedInject: "inject({{key}}) has no type. Name it with a JSDoc @type on the binding, a cast, or the accessor's @returns.",
+    requiredMode: "A required option gives inject({{key}}) two outcomes. Resolve it one way; a caller that cannot work without the value refuses where it receives it."
   }, "injected-values", CLIENT_GUIDE_URL),
   create(context) {
     const sourceCode = context.sourceCode;
@@ -69,6 +84,10 @@ const typedInject = Object.freeze({
         if (!isTypedInjection(sourceCode, node)) {
           report(node, "untyped-inject", "untypedInject", { key: keyText });
         }
+        const required = requiredOption(sourceCode, node);
+        if (required) {
+          report(required, "inject-required-mode", "requiredMode", { key: keyText });
+        }
       }
     };
   }

package/plugin/support.js

@@ -94,6 +94,16 @@ function keyName(property) {
   return property?.key?.name || property?.key?.value;
 }
 
+// The expression an optional chain wraps, so `a?.b` reads as `a.b`; any other node as it is.
+function unwrapChain(node) {
+  return node?.type === "ChainExpression" ? node.expression : node;
+}
+
+// The value an `await` waits for, so `await x` reads as `x`; any other node as it is.
+function unwrapAwait(node) {
+  return node?.type === "AwaitExpression" ? node.argument : node;
+}
+
 // The node a reader sees as the function: a method's property or class member,
 // otherwise the function itself.
 function functionSite(fn) {
@@ -373,5 +383,7 @@ export {
   keyName,
   receivingFunction,
   ruleMeta,
+  unwrapAwait,
+  unwrapChain,
   walk
 };