pasika 0.10.65 → 0.10.67

package/dist/eslint/pasika/index.d.ts

@@ -210,6 +210,7 @@ declare const pasikaPlugin: {
         "value-extraction": eslint.Rule.RuleModule;
         "constant-casing": eslint.Rule.RuleModule;
         "prefer-enum": eslint.Rule.RuleModule;
+        "prefer-object-destructuring": eslint.Rule.RuleModule;
         "enum-placement": eslint.Rule.RuleModule;
         "type-extraction": eslint.Rule.RuleModule;
         "zod-schema-validation": eslint.Rule.RuleModule;

package/dist/eslint/pasika/index.js

@@ -5719,6 +5719,139 @@ var preferEnumRule = {
   }
 };
 
+// eslint/rules/prefer-object-destructuring.ts
+var DOC5 = "See docs/next-codebase-guide/rules/redundant-aliases-rule.md";
+function hasTypeAnnotation(identifier) {
+  return "typeAnnotation" in identifier && identifier.typeAnnotation !== void 0;
+}
+function directPropertyBinding(context, declarator) {
+  if (declarator.id.type !== "Identifier" || hasTypeAnnotation(declarator.id)) return void 0;
+  if (declarator.init?.type !== "MemberExpression") return void 0;
+  const member = declarator.init;
+  if (member.computed || member.optional || member.property.type !== "Identifier") return void 0;
+  if (!canGroupSource(member.object)) return void 0;
+  if (context.sourceCode.getCommentsInside(declarator).length > 0) return void 0;
+  const propertyName4 = member.property.name;
+  const localName = declarator.id.name;
+  const source = member.object;
+  const sourceText = context.sourceCode.getText(source);
+  return {
+    declarator,
+    member,
+    propertyName: propertyName4,
+    localName,
+    source,
+    sourceText,
+    bindingText: propertyName4 === localName ? propertyName4 : `${propertyName4}: ${localName}`
+  };
+}
+function canGroupSource(source) {
+  return source.type === "Identifier" || source.type === "ThisExpression";
+}
+function whitespaceKeepsStatementsAdjacent(text) {
+  if (text.trim() !== "") return false;
+  return (text.match(/\n/gu) ?? []).length <= 1;
+}
+function groupedDeclarations(context, declaration, firstBinding) {
+  if (declaration.declarations.length !== 1 || !canGroupSource(firstBinding.source)) {
+    return [{ declaration, binding: firstBinding }];
+  }
+  const parent = context.sourceCode.getAncestors(declaration).at(-1);
+  if (parent?.type !== "Program" && parent?.type !== "BlockStatement") {
+    return [{ declaration, binding: firstBinding }];
+  }
+  const body = parent.body;
+  const startIndex = body.indexOf(declaration);
+  if (startIndex < 0) return [{ declaration, binding: firstBinding }];
+  const group = [{ declaration, binding: firstBinding }];
+  const seenProperties = /* @__PURE__ */ new Set([firstBinding.propertyName]);
+  for (let index = startIndex + 1; index < body.length; index += 1) {
+    const nextNode = body[index];
+    const previous = group.at(-1)?.declaration;
+    if (!previous || nextNode?.type !== "VariableDeclaration" || nextNode.kind !== declaration.kind) break;
+    if (nextNode.declarations.length !== 1) break;
+    const nextDeclarator = nextNode.declarations[0];
+    if (!nextDeclarator) break;
+    const nextBinding = directPropertyBinding(context, nextDeclarator);
+    if (nextBinding?.sourceText !== firstBinding.sourceText) break;
+    if (!canGroupSource(nextBinding.source) || seenProperties.has(nextBinding.propertyName)) break;
+    const [, previousEnd] = context.sourceCode.getRange(previous);
+    const [nextStart] = context.sourceCode.getRange(nextNode);
+    const gap = context.sourceCode.text.slice(previousEnd, nextStart);
+    if (!whitespaceKeepsStatementsAdjacent(gap)) break;
+    group.push({ declaration: nextNode, binding: nextBinding });
+    seenProperties.add(nextBinding.propertyName);
+  }
+  return group;
+}
+function declarationTerminator(context, declaration) {
+  return context.sourceCode.getText(declaration).trimEnd().endsWith(";") ? ";" : "";
+}
+function singleMessage(binding) {
+  return `"${binding.localName}" is derived directly from "${binding.sourceText}.${binding.propertyName}". Use object destructuring. ${DOC5}`;
+}
+function groupMessage(bindings) {
+  const firstBinding = bindings[0];
+  if (!firstBinding) return `Use object destructuring. ${DOC5}`;
+  const names = bindings.map(({ localName }) => `"${localName}"`).join(", ");
+  return `${names} are derived directly from properties of "${firstBinding.sourceText}". Use object destructuring. ${DOC5}`;
+}
+var preferObjectDestructuringRule = {
+  meta: {
+    schema: [],
+    type: "problem",
+    fixable: "code",
+    docs: {
+      description: "Require locals derived directly from object properties to use object destructuring."
+    }
+  },
+  create(context) {
+    const grouped = /* @__PURE__ */ new Set();
+    return {
+      VariableDeclaration(node) {
+        if (grouped.has(node)) return;
+        const bindings = node.declarations.map((declarator) => directPropertyBinding(context, declarator)).filter((binding) => binding !== void 0);
+        if (bindings.length === 0) return;
+        const firstBinding = bindings[0];
+        if (!firstBinding) return;
+        if (node.declarations.length === 1 && bindings.length === 1) {
+          const group = groupedDeclarations(context, node, firstBinding);
+          if (group.length > 1) {
+            for (const item of group.slice(1)) grouped.add(item.declaration);
+            const groupBindings = group.map(({ binding }) => binding);
+            const lastDeclaration = group.at(-1)?.declaration;
+            if (!lastDeclaration) return;
+            context.report({
+              node,
+              message: groupMessage(groupBindings),
+              fix(fixer) {
+                const [start] = context.sourceCode.getRange(node);
+                const [, end] = context.sourceCode.getRange(lastDeclaration);
+                const terminator = declarationTerminator(context, lastDeclaration);
+                const pattern = groupBindings.map(({ bindingText }) => bindingText).join(", ");
+                return fixer.replaceTextRange(
+                  [start, end],
+                  `${node.kind} { ${pattern} } = ${firstBinding.sourceText}${terminator}`
+                );
+              }
+            });
+            return;
+          }
+        }
+        for (const binding of bindings) {
+          context.report({
+            node: binding.declarator,
+            message: singleMessage(binding),
+            fix(fixer) {
+              return fixer.replaceText(binding.declarator, `{ ${binding.bindingText} } = ${binding.sourceText}`);
+            }
+          });
+        }
+      }
+    };
+  }
+};
+
 // eslint/rules/pure-function-extract.ts
 import path43 from "path";
 var ROUTE_HANDLER_EXPORT_NAMES = /* @__PURE__ */ new Set([
@@ -8529,9 +8662,9 @@ var vulykRules = {
 // eslint/rules/with-response-helper.ts
 var HELPER3 = "withResponse";
 var ENTRY3 = "pasika/with-response";
-var DOC5 = "docs/pasika-adoption-guide/rules/with-response-helper-rule.md";
-var DECLARED3 = `A repository must not declare its own ${HELPER3}; import it from ${ENTRY3}. See ${DOC5}`;
-var IMPORTED3 = `${HELPER3} must be imported from ${ENTRY3}. See ${DOC5}`;
+var DOC6 = "docs/pasika-adoption-guide/rules/with-response-helper-rule.md";
+var DECLARED3 = `A repository must not declare its own ${HELPER3}; import it from ${ENTRY3}. See ${DOC6}`;
+var IMPORTED3 = `${HELPER3} must be imported from ${ENTRY3}. See ${DOC6}`;
 function isNamed3(node, name) {
   return node?.type === "Identifier" && node.name === name;
 }
@@ -8652,10 +8785,10 @@ function referencesZirka(sourceCode) {
 // eslint/rules/zod-fetch-helper.ts
 var HELPER4 = "zodFetch";
 var ENTRY4 = "pasika/zod-fetch";
-var DOC6 = "docs/pasika-adoption-guide/rules/zod-fetch-helper-rule.md";
-var FETCHED = `fetch must not be called; make the request through ${HELPER4} from ${ENTRY4}. See ${DOC6}`;
-var DECLARED4 = `A file must not declare its own ${HELPER4}; import it from ${ENTRY4}. See ${DOC6}`;
-var IMPORTED4 = `${HELPER4} must be imported from ${ENTRY4}. See ${DOC6}`;
+var DOC7 = "docs/pasika-adoption-guide/rules/zod-fetch-helper-rule.md";
+var FETCHED = `fetch must not be called; make the request through ${HELPER4} from ${ENTRY4}. See ${DOC7}`;
+var DECLARED4 = `A file must not declare its own ${HELPER4}; import it from ${ENTRY4}. See ${DOC7}`;
+var IMPORTED4 = `${HELPER4} must be imported from ${ENTRY4}. See ${DOC7}`;
 var GLOBAL_OBJECTS = /* @__PURE__ */ new Set(["globalThis", "window", "self", "global"]);
 var TEST_FILE2 = /(?:^|[\\/])(?:__tests__|tests)[\\/]|[.](?:test|spec)[.][cm]?[jt]sx?$/;
 function isNamed4(node, name) {
@@ -8842,6 +8975,7 @@ var pasikaNextjsAppRules = {
   "value-extraction": valueExtractionRule,
   "constant-casing": constantCasingRule,
   "prefer-enum": preferEnumRule,
+  "prefer-object-destructuring": preferObjectDestructuringRule,
   "enum-placement": enumPlacementRule,
   "type-extraction": typeExtractionRule,
   "zod-schema-validation": zodSchemaValidationRule,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pasika",
-  "version": "0.10.65",
+  "version": "0.10.67",
   "description": "Reusable agent setup package",
   "repository": {
     "type": "git",