@foldkit/oxlint-plugin 0.9.0 → 0.10.0

package/all.json

@@ -20,6 +20,7 @@
     "foldkit/no-duplicate-onmount-per-element": "error",
     "foldkit/no-empty-children-array": "error",
     "foldkit/no-empty-commands-array": "error",
+    "foldkit/no-empty-to-parent-out-message": "error",
     "foldkit/no-empty-object-tagged-call": "error",
     "foldkit/no-hand-rolled-command-struct": "error",
     "foldkit/no-hardcoded-route-strings": "error",
@@ -74,6 +75,7 @@
         "foldkit/no-duplicate-onmount-per-element": "off",
         "foldkit/no-empty-children-array": "off",
         "foldkit/no-empty-commands-array": "off",
+        "foldkit/no-empty-to-parent-out-message": "off",
         "foldkit/no-empty-object-tagged-call": "off",
         "foldkit/no-hand-rolled-command-struct": "off",
         "foldkit/no-hardcoded-route-strings": "off",

package/dist/index.d.ts

@@ -30,6 +30,7 @@ declare const _default: {
         readonly 'no-duplicate-onmount-per-element': import("effect-oxlint").CreateRule;
         readonly 'no-empty-children-array': import("effect-oxlint").CreateRule;
         readonly 'no-empty-commands-array': import("effect-oxlint").CreateRule;
+        readonly 'no-empty-to-parent-out-message': import("effect-oxlint").CreateRule;
         readonly 'no-empty-object-tagged-call': import("effect-oxlint").CreateRule;
         readonly 'no-hand-rolled-command-struct': import("effect-oxlint").CreateRule;
         readonly 'no-hardcoded-route-strings': import("effect-oxlint").CreateRule;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AA+DtC,KAAK,QAAQ,GAAG,QAAQ,CAAC;IACvB,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IACpB,YAAY,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IAC5B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,YAAY,CAAC,CAAA;CAC3C,CAAC,CAAA;AAEF,KAAK,gBAAgB,GAAG,MAAM,CAAC,YAAY,GAAG;IAC5C,SAAS,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;CAC3B,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDD,wBAMC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AAiEtC,KAAK,QAAQ,GAAG,QAAQ,CAAC;IACvB,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IACpB,YAAY,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IAC5B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,YAAY,CAAC,CAAA;CAC3C,CAAC,CAAA;AAEF,KAAK,gBAAgB,GAAG,MAAM,CAAC,YAAY,GAAG;IAC5C,SAAS,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;CAC3B,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDD,wBAMC"}

package/dist/index.js

@@ -11792,7 +11792,7 @@ var staticPropertyName2 = (property) => {
   return staticStringValue(property.key);
 };
 var isEmptyCommandsProperty = (property) => Option_exports.contains(staticPropertyName2(property), COMMANDS_PROPERTY) && isArrayExpression(property.value) && Array_exports.isReadonlyArrayEmpty(property.value.elements);
-var removalRange = (object, property, index) => {
+var removalRange = (sourceText, object, property, index) => {
   const maybePrevious = Array_exports.get(object.properties, index - 1);
   if (Option_exports.isSome(maybePrevious)) {
     return [maybePrevious.value.end, property.end];
@@ -11801,7 +11801,15 @@ var removalRange = (object, property, index) => {
   if (Option_exports.isSome(maybeNext)) {
     return [property.start, maybeNext.value.start];
   }
-  return property.range;
+  const trailingComma = /^\s*,/.exec(sourceText.slice(property.end, object.end));
+  if (trailingComma === null) {
+    return property.range;
+  }
+  const maybeMatchedText = Array_exports.head(trailingComma);
+  if (Option_exports.isNone(maybeMatchedText)) {
+    return property.range;
+  }
+  return [property.start, property.end + maybeMatchedText.value.length];
 };
 var emptyCommandsMessage = "Return { model } instead of the literal { model, commands: [] }. Return a computed Commands collection directly, even when it may be empty.";
 var noEmptyCommandsArray = Rule_exports.define({
@@ -11822,6 +11830,10 @@ var noEmptyCommandsArray = Rule_exports.define({
           node.properties,
           (property) => property.type === "SpreadElement"
         );
+        const hasDynamicComputedProperty = Array_exports.some(
+          node.properties,
+          (property) => isObjectProperty(property) && property.computed && Option_exports.isNone(staticPropertyName2(property))
+        );
         const commandProperties = Array_exports.filter(
           node.properties,
           (property) => isObjectProperty(property) && Option_exports.contains(staticPropertyName2(property), COMMANDS_PROPERTY)
@@ -11839,13 +11851,15 @@ var noEmptyCommandsArray = Rule_exports.define({
               node: property,
               message: emptyCommandsMessage
             });
-            if (hasSpread || hasComments || Array_exports.isReadonlyArrayNonEmpty(Array_exports.drop(commandProperties, 1))) {
+            if (hasSpread || hasDynamicComputedProperty || hasComments || Array_exports.isReadonlyArrayNonEmpty(Array_exports.drop(commandProperties, 1))) {
               return ctx.report(diagnostic);
             }
             return ctx.report(
               Diagnostic_exports.withFix(
                 diagnostic,
-                (fixer) => fixer.removeRange(removalRange(node, property, index))
+                (fixer) => fixer.removeRange(
+                  removalRange(ctx.sourceCode.text, node, property, index)
+                )
               )
             );
           },
@@ -11936,6 +11950,135 @@ var noEmptyObjectTaggedCall = Rule_exports.define({
   }
 });
 
+// src/rules/no-empty-to-parent-out-message.ts
+var TO_PARENT_OUT_MESSAGE_PROPERTY = "toParentOutMessage";
+var isObjectProperty2 = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "Property";
+var staticPropertyName3 = (property) => {
+  if (!property.computed && isIdentifier(property.key)) {
+    return Option_exports.some(property.key.name);
+  }
+  return staticStringValue(property.key);
+};
+var isArrowFunctionExpression3 = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "ArrowFunctionExpression";
+var isFunctionExpression = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "FunctionExpression";
+var isMapperFunction = (node) => isArrowFunctionExpression3(node) && !node.async || isFunctionExpression(node) && !node.async && !node.generator;
+var isIdentifierReference = (node) => isIdentifier(node);
+var indexReferences = (scopes) => {
+  const references = /* @__PURE__ */ new WeakMap();
+  for (const scope3 of scopes) {
+    for (const reference of scope3.references) {
+      references.set(reference.identifier, reference);
+    }
+  }
+  return references;
+};
+var isUnshadowedUndefined = (references, node) => {
+  if (!isIdentifierReference(node) || node.name !== "undefined") {
+    return false;
+  }
+  if (references === void 0) {
+    return true;
+  }
+  const reference = references.get(node);
+  return reference !== void 0 && (reference.resolved === null || Array_exports.isArrayEmpty(reference.resolved.defs));
+};
+var directlyReturnsUndefined = (references, mapper) => {
+  if (mapper.body === null) {
+    return false;
+  }
+  if (mapper.body.type !== "BlockStatement") {
+    return isUnshadowedUndefined(references, mapper.body);
+  }
+  const [firstStatement, secondStatement] = mapper.body.body;
+  return firstStatement?.type === "ReturnStatement" && secondStatement === void 0 && isUnshadowedUndefined(references, firstStatement.argument);
+};
+var isEmptyMapperProperty = (references, property) => property.kind === "init" && Option_exports.contains(
+  staticPropertyName3(property),
+  TO_PARENT_OUT_MESSAGE_PROPERTY
+) && isMapperFunction(property.value) && directlyReturnsUndefined(references, property.value);
+var removalRange2 = (sourceText, object, property, index) => {
+  const maybePrevious = Array_exports.get(object.properties, index - 1);
+  if (Option_exports.isSome(maybePrevious)) {
+    return [maybePrevious.value.end, property.end];
+  }
+  const maybeNext = Array_exports.get(object.properties, index + 1);
+  if (Option_exports.isSome(maybeNext)) {
+    return [property.start, maybeNext.value.start];
+  }
+  const trailingComma = /^\s*,/.exec(sourceText.slice(property.end, object.end));
+  if (trailingComma === null) {
+    return property.range;
+  }
+  const maybeMatchedText = Array_exports.head(trailingComma);
+  if (Option_exports.isNone(maybeMatchedText)) {
+    return property.range;
+  }
+  return [property.start, property.end + maybeMatchedText.value.length];
+};
+var emptyMapperMessage = "Omit toParentOutMessage. This mapper directly returns undefined, so it forwards nothing to the parent.";
+var noEmptyToParentOutMessage = Rule_exports.define({
+  name: "no-empty-to-parent-out-message",
+  meta: Rule_exports.meta({
+    type: "suggestion",
+    description: "Omit an inline toParentOutMessage mapper that directly returns undefined.",
+    fixable: "code"
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext;
+    const scopes = ctx.sourceCode.scopeManager?.scopes;
+    const references = scopes === void 0 ? void 0 : indexReferences(scopes);
+    return {
+      ObjectExpression: (node) => {
+        if (!isObjectExpression(node)) {
+          return Effect_exports.void;
+        }
+        const hasSpread = Array_exports.some(
+          node.properties,
+          (property) => property.type === "SpreadElement"
+        );
+        const hasDynamicComputedProperty = Array_exports.some(
+          node.properties,
+          (property) => isObjectProperty2(property) && property.computed && Option_exports.isNone(staticPropertyName3(property))
+        );
+        const mapperProperties = Array_exports.filter(
+          node.properties,
+          (property) => isObjectProperty2(property) && Option_exports.contains(
+            staticPropertyName3(property),
+            TO_PARENT_OUT_MESSAGE_PROPERTY
+          )
+        );
+        const hasComments = Array_exports.isReadonlyArrayNonEmpty(
+          ctx.sourceCode.getCommentsInside(node)
+        );
+        return Effect_exports.forEach(
+          node.properties.entries(),
+          ([index, property]) => {
+            if (!isObjectProperty2(property) || !isEmptyMapperProperty(references, property)) {
+              return Effect_exports.void;
+            }
+            const diagnostic = Diagnostic_exports.make({
+              node: property,
+              message: emptyMapperMessage
+            });
+            if (hasSpread || hasDynamicComputedProperty || hasComments || Array_exports.isReadonlyArrayNonEmpty(Array_exports.drop(mapperProperties, 1))) {
+              return ctx.report(diagnostic);
+            }
+            return ctx.report(
+              Diagnostic_exports.withFix(
+                diagnostic,
+                (fixer) => fixer.removeRange(
+                  removalRange2(ctx.sourceCode.text, node, property, index)
+                )
+              )
+            );
+          },
+          { discard: true }
+        );
+      }
+    };
+  }
+});
+
 // src/rules/no-hand-rolled-command-struct.ts
 var COMMAND_STRUCT_SHAPES = [
   ["name", "effect"],
@@ -12151,7 +12294,7 @@ var staticMemberName = (node) => {
   }
   return void 0;
 };
-var staticPropertyName3 = (property) => {
+var staticPropertyName4 = (property) => {
   if (property.key.type === "Identifier") {
     return property.key.name;
   }
@@ -12178,7 +12321,7 @@ var restrictedGlobalDiagnostic = (node, name) => Diagnostic_exports.make({
   node,
   message: `Global \`${name}\` is not portable across Foldkit server targets. Use a server API available everywhere you deploy or pass the value into the entry.`
 });
-var indexReferences = (scopes) => {
+var indexReferences2 = (scopes) => {
   const references = /* @__PURE__ */ new WeakMap();
   for (const scope3 of scopes) {
     for (const reference of scope3.references) {
@@ -12199,7 +12342,7 @@ var noNonportableServerGlobals = Rule_exports.define({
   }),
   create: function* () {
     const ctx = yield* RuleContext;
-    const references = indexReferences(ctx.sourceCode.scopeManager.scopes);
+    const references = indexReferences2(ctx.sourceCode.scopeManager.scopes);
     return {
       Identifier: (node) => {
         if (node.type !== "Identifier" || !restrictedGlobalNames.has(node.name) || isInsideTypeQuery(node)) {
@@ -12229,7 +12372,7 @@ var noNonportableServerGlobals = Rule_exports.define({
           if (property.type !== "Property") {
             return [];
           }
-          const name = staticPropertyName3(property);
+          const name = staticPropertyName4(property);
           return name !== void 0 && restrictedGlobalNames.has(name) ? [{ name, property }] : [];
         });
         return isUnshadowedGlobalReference(references, source) ? Effect_exports.forEach(
@@ -12816,7 +12959,7 @@ var gotMessagePattern = /^Got\w*Message$/;
 var dynamicCalleeLabel = "<dynamic call>";
 var isWrapperExpression3 = (node) => typeof node === "object" && node !== null && "type" in node && typeof node.type === "string" && mapperWrapperTypes.includes(node.type) && "expression" in node;
 var unwrapExpression3 = (node) => isWrapperExpression3(node) ? unwrapExpression3(node.expression) : node;
-var isArrowFunctionExpression3 = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "ArrowFunctionExpression";
+var isArrowFunctionExpression4 = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "ArrowFunctionExpression";
 var isBlockStatement2 = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "BlockStatement";
 var isReturnStatement3 = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "ReturnStatement";
 var resolveMemberPath2 = (node) => {
@@ -12843,7 +12986,7 @@ var commandMapperArrow = (node) => pipe(
   Option_exports.filter((calleePath) => commandMapperPaths.includes(calleePath)),
   Option_exports.flatMap(() => {
     const [, mapperArgument] = node.arguments;
-    return isArrowFunctionExpression3(mapperArgument) ? Option_exports.some(mapperArgument) : Option_exports.none();
+    return isArrowFunctionExpression4(mapperArgument) ? Option_exports.some(mapperArgument) : Option_exports.none();
   })
 );
 var subscriptionLiftMapperArrow = (node) => {
@@ -12868,7 +13011,7 @@ var subscriptionLiftMapperArrow = (node) => {
       );
     }),
     Option_exports.flatMap(
-      (mapperValue) => isArrowFunctionExpression3(mapperValue) ? Option_exports.some(mapperValue) : Option_exports.none()
+      (mapperValue) => isArrowFunctionExpression4(mapperValue) ? Option_exports.some(mapperValue) : Option_exports.none()
     )
   );
 };
@@ -12970,6 +13113,7 @@ var basePlugin = Plugin_exports.define({
     "no-duplicate-onmount-per-element": noDuplicateOnmountPerElement,
     "no-empty-children-array": noEmptyChildrenArray,
     "no-empty-commands-array": noEmptyCommandsArray,
+    "no-empty-to-parent-out-message": noEmptyToParentOutMessage,
     "no-empty-object-tagged-call": noEmptyObjectTaggedCall,
     "no-hand-rolled-command-struct": noHandRolledCommandStruct,
     "no-hardcoded-route-strings": noHardcodedRouteStrings,

package/dist/rules/no-empty-commands-array.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"no-empty-commands-array.d.ts","sourceRoot":"","sources":["../../src/rules/no-empty-commands-array.ts"],"names":[],"mappings":"AAqDA;;;2EAG2E;AAC3E,eAAO,MAAM,oBAAoB,oCA+D/B,CAAA"}
+{"version":3,"file":"no-empty-commands-array.d.ts","sourceRoot":"","sources":["../../src/rules/no-empty-commands-array.ts"],"names":[],"mappings":"AA+DA;;;2EAG2E;AAC3E,eAAO,MAAM,oBAAoB,oCAyE/B,CAAA"}

package/dist/rules/no-empty-to-parent-out-message.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Flags an inline `toParentOutMessage` mapper that directly returns
+ * `undefined`. That mapper forwards nothing to the parent, so the property
+ * should be omitted. This syntax-only rule does not inspect async functions,
+ * generators, getters, setters, or mappers referenced by name.
+ */
+export declare const noEmptyToParentOutMessage: import("effect-oxlint").CreateRule;
+//# sourceMappingURL=no-empty-to-parent-out-message.d.ts.map

package/dist/rules/no-empty-to-parent-out-message.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-empty-to-parent-out-message.d.ts","sourceRoot":"","sources":["../../src/rules/no-empty-to-parent-out-message.ts"],"names":[],"mappings":"AAsJA;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,oCAgFpC,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foldkit/oxlint-plugin",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "Oxlint rules for Foldkit applications",
   "type": "module",
   "main": "./dist/index.js",

package/recommended.json

@@ -20,6 +20,7 @@
     "foldkit/no-duplicate-onmount-per-element": "error",
     "foldkit/no-empty-children-array": "error",
     "foldkit/no-empty-commands-array": "error",
+    "foldkit/no-empty-to-parent-out-message": "error",
     "foldkit/no-empty-object-tagged-call": "error",
     "foldkit/no-hand-rolled-command-struct": "error",
     "foldkit/no-hardcoded-route-strings": "error",
@@ -74,6 +75,7 @@
         "foldkit/no-duplicate-onmount-per-element": "off",
         "foldkit/no-empty-children-array": "off",
         "foldkit/no-empty-commands-array": "off",
+        "foldkit/no-empty-to-parent-out-message": "off",
         "foldkit/no-empty-object-tagged-call": "off",
         "foldkit/no-hand-rolled-command-struct": "off",
         "foldkit/no-hardcoded-route-strings": "off",