@conorroberts/utils 0.0.55 → 0.0.56

package/dist/oxlint/jsx-component-pascal-case.d.mts

@@ -1,20 +1,20 @@
-import * as oxlint41 from "oxlint";
+import * as oxlint4 from "oxlint";
 
 //#region src/oxlint-plugins/jsx-component-pascal-case.d.ts
-declare const jsxComponentPascalCaseRule: oxlint41.Rule;
+declare const jsxComponentPascalCaseRule: oxlint4.Rule;
 declare namespace _default {
   namespace meta {
     let name: string;
   }
   let rules: {
-    "conorroberts/jsx-component-pascal-case": oxlint41.Rule;
+    "conorroberts/jsx-component-pascal-case": oxlint4.Rule;
   };
 }
-type RuleContext = oxlint41.Context;
-type ESTNode = oxlint41.ESTree.Node;
-type ESTExpression = oxlint41.ESTree.Expression;
-type ReturnStatementNode = oxlint41.ESTree.ReturnStatement;
-type FunctionLikeNode = oxlint41.ESTree.Function | oxlint41.ESTree.ArrowFunctionExpression;
+type RuleContext = oxlint4.Context;
+type ESTNode = oxlint4.ESTree.Node;
+type ESTExpression = oxlint4.ESTree.Expression;
+type ReturnStatementNode = oxlint4.ESTree.ReturnStatement;
+type FunctionLikeNode = oxlint4.ESTree.Function | oxlint4.ESTree.ArrowFunctionExpression;
 type FunctionContext = {
   node: FunctionLikeNode;
   name: string;

package/dist/oxlint/no-component-date-instantiation.d.mts

@@ -1,20 +1,20 @@
-import * as oxlint33 from "oxlint";
+import * as oxlint22 from "oxlint";
 
 //#region src/oxlint-plugins/no-component-date-instantiation.d.ts
-declare const noComponentDateInstantiationRule: oxlint33.Rule;
+declare const noComponentDateInstantiationRule: oxlint22.Rule;
 declare namespace _default {
   namespace meta {
     let name: string;
   }
   let rules: {
-    "conorroberts/no-component-date-instantiation": oxlint33.Rule;
+    "conorroberts/no-component-date-instantiation": oxlint22.Rule;
   };
 }
-type RuleContext = oxlint33.Context;
-type ESTNode = oxlint33.ESTree.Node;
-type NewExpressionNode = oxlint33.ESTree.NewExpression;
-type ReturnStatementNode = oxlint33.ESTree.ReturnStatement;
-type FunctionLikeNode = oxlint33.ESTree.Function | oxlint33.ESTree.ArrowFunctionExpression;
+type RuleContext = oxlint22.Context;
+type ESTNode = oxlint22.ESTree.Node;
+type NewExpressionNode = oxlint22.ESTree.NewExpression;
+type ReturnStatementNode = oxlint22.ESTree.ReturnStatement;
+type FunctionLikeNode = oxlint22.ESTree.Function | oxlint22.ESTree.ArrowFunctionExpression;
 type FunctionContext = {
   node: FunctionLikeNode;
   parent: FunctionContext | null;

package/dist/oxlint/no-emoji.d.mts

@@ -1,16 +1,16 @@
-import * as oxlint19 from "oxlint";
+import * as oxlint33 from "oxlint";
 
 //#region src/oxlint-plugins/no-emoji.d.ts
-declare const noEmojiRule: oxlint19.Rule;
+declare const noEmojiRule: oxlint33.Rule;
 declare namespace _default {
   namespace meta {
     let name: string;
   }
   let rules: {
-    "conorroberts/no-emoji": oxlint19.Rule;
+    "conorroberts/no-emoji": oxlint33.Rule;
   };
 }
-type ESTNode = oxlint19.ESTree.Node;
+type ESTNode = oxlint33.ESTree.Node;
 //#endregion
 export { ESTNode, _default as default, noEmojiRule };
 //# sourceMappingURL=no-emoji.d.mts.map

package/dist/oxlint/no-finally.d.mts

@@ -1,16 +1,16 @@
-import * as oxlint7 from "oxlint";
+import * as oxlint30 from "oxlint";
 
 //#region src/oxlint-plugins/no-finally.d.ts
-declare const noFinallyRule: oxlint7.Rule;
+declare const noFinallyRule: oxlint30.Rule;
 declare namespace _default {
   namespace meta {
     let name: string;
   }
   let rules: {
-    "conorroberts/no-finally": oxlint7.Rule;
+    "conorroberts/no-finally": oxlint30.Rule;
   };
 }
-type ESTNode = oxlint7.ESTree.Node;
+type ESTNode = oxlint30.ESTree.Node;
 //#endregion
 export { ESTNode, _default as default, noFinallyRule };
 //# sourceMappingURL=no-finally.d.mts.map

package/dist/oxlint/no-function-call-in-jsx.d.mts

@@ -1,19 +1,19 @@
-import * as oxlint13 from "oxlint";
+import * as oxlint50 from "oxlint";
 
 //#region src/oxlint-plugins/no-function-call-in-jsx.d.ts
-declare const noFunctionCallInJsxRule: oxlint13.Rule;
+declare const noFunctionCallInJsxRule: oxlint50.Rule;
 declare namespace _default {
   namespace meta {
     let name: string;
   }
   let rules: {
-    "conorroberts/no-function-call-in-jsx": oxlint13.Rule;
+    "conorroberts/no-function-call-in-jsx": oxlint50.Rule;
   };
 }
-type RuleContext = oxlint13.Context;
-type ESTNode = oxlint13.ESTree.Node;
-type JSXExpressionContainer = oxlint13.ESTree.JSXExpressionContainer;
-type CallExpression = oxlint13.ESTree.CallExpression;
+type RuleContext = oxlint50.Context;
+type ESTNode = oxlint50.ESTree.Node;
+type JSXExpressionContainer = oxlint50.ESTree.JSXExpressionContainer;
+type CallExpression = oxlint50.ESTree.CallExpression;
 //#endregion
 export { CallExpression, ESTNode, JSXExpressionContainer, RuleContext, _default as default, noFunctionCallInJsxRule };
 //# sourceMappingURL=no-function-call-in-jsx.d.mts.map

package/dist/oxlint/no-inline-components.d.mts

@@ -1,27 +1,27 @@
-import * as oxlint22 from "oxlint";
+import * as oxlint36 from "oxlint";
 
 //#region src/oxlint-plugins/no-inline-components.d.ts
 declare function isComponentName(name: unknown): name is string;
 declare function isHookName(name: unknown): name is string;
 declare function getEnclosingFunction(node: ESTNode | null | undefined): FunctionLikeNode | null;
 declare function getFunctionName(node: FunctionLikeNode): string;
-declare const noInlineComponentsRule: oxlint22.Rule;
+declare const noInlineComponentsRule: oxlint36.Rule;
 declare namespace _default {
   namespace meta {
     let name: string;
   }
   let rules: {
-    "conorroberts/no-inline-components": oxlint22.Rule;
+    "conorroberts/no-inline-components": oxlint36.Rule;
   };
 }
-type RuleContext = oxlint22.Context;
-type ESTNode = oxlint22.ESTree.Node;
-type ESTExpression = oxlint22.ESTree.Expression;
-type ESTPattern = oxlint22.ESTree.Pattern;
-type ReturnStatementNode = oxlint22.ESTree.ReturnStatement;
-type VariableDeclaratorNode = oxlint22.ESTree.VariableDeclarator;
-type AssignmentExpressionNode = oxlint22.ESTree.AssignmentExpression;
-type FunctionLikeNode = oxlint22.ESTree.Function | oxlint22.ESTree.ArrowFunctionExpression;
+type RuleContext = oxlint36.Context;
+type ESTNode = oxlint36.ESTree.Node;
+type ESTExpression = oxlint36.ESTree.Expression;
+type ESTPattern = oxlint36.ESTree.Pattern;
+type ReturnStatementNode = oxlint36.ESTree.ReturnStatement;
+type VariableDeclaratorNode = oxlint36.ESTree.VariableDeclarator;
+type AssignmentExpressionNode = oxlint36.ESTree.AssignmentExpression;
+type FunctionLikeNode = oxlint36.ESTree.Function | oxlint36.ESTree.ArrowFunctionExpression;
 type RecordedAssignment = {
   node: ESTExpression;
   names: string[];

package/dist/oxlint/no-react-namespace.d.mts

@@ -1,16 +1,16 @@
-import * as oxlint4 from "oxlint";
+import * as oxlint1 from "oxlint";
 
 //#region src/oxlint-plugins/no-react-namespace.d.ts
-declare const noReactNamespaceRule: oxlint4.Rule;
+declare const noReactNamespaceRule: oxlint1.Rule;
 declare namespace _default {
   namespace meta {
     let name: string;
   }
   let rules: {
-    "conorroberts/no-react-namespace": oxlint4.Rule;
+    "conorroberts/no-react-namespace": oxlint1.Rule;
   };
 }
-type ESTNode = oxlint4.ESTree.Node;
+type ESTNode = oxlint1.ESTree.Node;
 //#endregion
 export { ESTNode, _default as default, noReactNamespaceRule };
 //# sourceMappingURL=no-react-namespace.d.mts.map

package/dist/oxlint/no-switch-plugin.d.mts

@@ -1,4 +1,4 @@
-import * as oxlint2 from "oxlint";
+import * as oxlint0 from "oxlint";
 
 //#region src/oxlint-plugins/no-switch-plugin.d.ts
 declare namespace _default {
@@ -6,10 +6,10 @@ declare namespace _default {
     let name: string;
   }
   let rules: {
-    "conorroberts/no-switch": oxlint2.Rule;
+    "conorroberts/no-switch": oxlint0.Rule;
   };
 }
-type ESTNode = oxlint2.ESTree.Node;
+type ESTNode = oxlint0.ESTree.Node;
 //#endregion
 export { ESTNode, _default as default };
 //# sourceMappingURL=no-switch-plugin.d.mts.map

package/dist/oxlint/no-top-level-let.d.mts

@@ -1,16 +1,16 @@
-import * as oxlint10 from "oxlint";
+import * as oxlint19 from "oxlint";
 
 //#region src/oxlint-plugins/no-top-level-let.d.ts
-declare const noTopLevelLetRule: oxlint10.Rule;
+declare const noTopLevelLetRule: oxlint19.Rule;
 declare namespace _default {
   namespace meta {
     let name: string;
   }
   let rules: {
-    "conorroberts/no-top-level-let": oxlint10.Rule;
+    "conorroberts/no-top-level-let": oxlint19.Rule;
   };
 }
-type ESTNode = oxlint10.ESTree.Node;
+type ESTNode = oxlint19.ESTree.Node;
 //#endregion
 export { ESTNode, _default as default, noTopLevelLetRule };
 //# sourceMappingURL=no-top-level-let.d.mts.map

package/dist/oxlint/no-type-cast.d.mts

@@ -1,16 +1,16 @@
-import * as oxlint0 from "oxlint";
+import * as oxlint47 from "oxlint";
 
 //#region src/oxlint-plugins/no-type-cast.d.ts
-declare const noTypeCastRule: oxlint0.Rule;
+declare const noTypeCastRule: oxlint47.Rule;
 declare namespace _default {
   namespace meta {
     let name: string;
   }
   let rules: {
-    "conorroberts/no-type-cast": oxlint0.Rule;
+    "conorroberts/no-type-cast": oxlint47.Rule;
   };
 }
-type ESTNode = oxlint0.ESTree.Node;
+type ESTNode = oxlint47.ESTree.Node;
 //#endregion
 export { ESTNode, _default as default, noTypeCastRule };
 //# sourceMappingURL=no-type-cast.d.mts.map

package/dist/oxlint/pretty-props.d.mts

@@ -0,0 +1,19 @@
+import * as oxlint12 from "oxlint";
+
+//#region src/oxlint-plugins/pretty-props.d.ts
+declare const prettyPropsRule: oxlint12.Rule;
+declare namespace _default {
+  namespace meta {
+    let name: string;
+  }
+  let rules: {
+    "conorroberts/pretty-props": oxlint12.Rule;
+  };
+}
+type RuleContext = oxlint12.Context;
+type ESTNode = oxlint12.ESTree.Node;
+type ESTExpression = oxlint12.ESTree.Expression;
+type FunctionLikeNode = oxlint12.ESTree.Function | oxlint12.ESTree.ArrowFunctionExpression;
+//#endregion
+export { ESTExpression, ESTNode, FunctionLikeNode, RuleContext, _default as default, prettyPropsRule };
+//# sourceMappingURL=pretty-props.d.mts.map

package/dist/oxlint/pretty-props.mjs

@@ -0,0 +1,131 @@
+import { defineRule } from "oxlint";
+
+//#region src/oxlint-plugins/pretty-props.js
+/**
+* @typedef {import("oxlint").Context} RuleContext
+* @typedef {import("oxlint").ESTree.Node} ESTNode
+* @typedef {import("oxlint").ESTree.Expression} ESTExpression
+* @typedef {import("oxlint").ESTree.Function | import("oxlint").ESTree.ArrowFunctionExpression} FunctionLikeNode
+*/
+const JSX_NODE_TYPES = new Set(["JSXElement", "JSXFragment"]);
+const FUNCTION_NODE_TYPES = new Set([
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"ArrowFunctionExpression"
+]);
+/**
+* @param {unknown} node
+* @returns {node is ESTNode & { type: string }}
+*/
+const isNode = (node) => Boolean(node && typeof node === "object" && "type" in node);
+/**
+* @param {unknown} node
+* @returns {node is FunctionLikeNode}
+*/
+const isFunctionLike = (node) => isNode(node) && FUNCTION_NODE_TYPES.has(node.type);
+/**
+* Check if an expression contains JSX
+* @param {ESTExpression | null | undefined} root
+*/
+const expressionContainsJsx = (root) => {
+	if (!root || !isNode(root)) return false;
+	const stack = [root];
+	while (stack.length > 0) {
+		const current = stack.pop();
+		if (!current || !isNode(current)) continue;
+		if (JSX_NODE_TYPES.has(current.type)) return true;
+		if (FUNCTION_NODE_TYPES.has(current.type) && current !== root) continue;
+		for (const key of Object.keys(current)) {
+			if (key === "parent") continue;
+			const value = current[key];
+			if (!value) continue;
+			if (Array.isArray(value)) {
+				for (const element of value) if (isNode(element)) stack.push(element);
+			} else if (isNode(value)) stack.push(value);
+		}
+	}
+	return false;
+};
+/**
+* Check if a function returns JSX
+* @param {FunctionLikeNode} node
+*/
+const functionReturnsJsx = (node) => {
+	if (node.type === "ArrowFunctionExpression" && node.body && node.body.type !== "BlockStatement") return expressionContainsJsx(node.body);
+	const body = node.body;
+	if (!body || body.type !== "BlockStatement") return false;
+	const stack = [body];
+	while (stack.length > 0) {
+		const current = stack.pop();
+		if (!current || !isNode(current)) continue;
+		if (current.type === "ReturnStatement") {
+			const argument = current.argument;
+			if (argument && expressionContainsJsx(argument)) return true;
+		}
+		if (FUNCTION_NODE_TYPES.has(current.type) && current !== body) continue;
+		for (const key of Object.keys(current)) {
+			if (key === "parent") continue;
+			const value = current[key];
+			if (!value) continue;
+			if (Array.isArray(value)) {
+				for (const element of value) if (isNode(element)) stack.push(element);
+			} else if (isNode(value)) stack.push(value);
+		}
+	}
+	return false;
+};
+const rule = defineRule({
+	meta: {
+		type: "problem",
+		docs: {
+			description: "Enforce consistent props parameter naming and disallow destructuring in component parameters.",
+			recommended: false
+		},
+		schema: []
+	},
+	createOnce(context) {
+		/**
+		* @param {FunctionLikeNode} node
+		*/
+		const checkFunction = (node) => {
+			if (!functionReturnsJsx(node)) return;
+			const params = node.params;
+			if (!params || params.length === 0) return;
+			const firstParam = params[0];
+			if (!firstParam || !isNode(firstParam)) return;
+			if (firstParam.type === "ObjectPattern" || firstParam.type === "ArrayPattern") {
+				context.report({
+					node: firstParam,
+					message: "Props should not be destructured in the component parameter. Use 'props' instead and destructure inside the component body."
+				});
+				return;
+			}
+			if (firstParam.type === "Identifier") {
+				if (firstParam.name !== "props") context.report({
+					node: firstParam,
+					message: `Props parameter should be named 'props', not '${firstParam.name}'.`
+				});
+			}
+		};
+		return {
+			FunctionDeclaration(node) {
+				if (isFunctionLike(node)) checkFunction(node);
+			},
+			FunctionExpression(node) {
+				if (isFunctionLike(node)) checkFunction(node);
+			},
+			ArrowFunctionExpression(node) {
+				if (isFunctionLike(node)) checkFunction(node);
+			}
+		};
+	}
+});
+const prettyPropsRule = rule;
+var pretty_props_default = {
+	meta: { name: "conorroberts/pretty-props" },
+	rules: { "conorroberts/pretty-props": rule }
+};
+
+//#endregion
+export { pretty_props_default as default, prettyPropsRule };
+//# sourceMappingURL=pretty-props.mjs.map

package/dist/oxlint/pretty-props.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pretty-props.mjs","names":[],"sources":["../../src/oxlint-plugins/pretty-props.js"],"sourcesContent":["import { defineRule } from \"oxlint\";\n\n/**\n * @typedef {import(\"oxlint\").Context} RuleContext\n * @typedef {import(\"oxlint\").ESTree.Node} ESTNode\n * @typedef {import(\"oxlint\").ESTree.Expression} ESTExpression\n * @typedef {import(\"oxlint\").ESTree.Function | import(\"oxlint\").ESTree.ArrowFunctionExpression} FunctionLikeNode\n */\n\nconst JSX_NODE_TYPES = new Set([\"JSXElement\", \"JSXFragment\"]);\nconst FUNCTION_NODE_TYPES = new Set([\"FunctionDeclaration\", \"FunctionExpression\", \"ArrowFunctionExpression\"]);\n\n/**\n * @param {unknown} node\n * @returns {node is ESTNode & { type: string }}\n */\nconst isNode = (node) => Boolean(node && typeof node === \"object\" && \"type\" in node);\n\n/**\n * @param {unknown} node\n * @returns {node is FunctionLikeNode}\n */\nconst isFunctionLike = (node) => isNode(node) && FUNCTION_NODE_TYPES.has(node.type);\n\n/**\n * Check if an expression contains JSX\n * @param {ESTExpression | null | undefined} root\n */\nconst expressionContainsJsx = (root) => {\n  if (!root || !isNode(root)) return false;\n\n  const stack = [root];\n\n  while (stack.length > 0) {\n    const current = stack.pop();\n    if (!current || !isNode(current)) continue;\n\n    if (JSX_NODE_TYPES.has(current.type)) {\n      return true;\n    }\n\n    if (FUNCTION_NODE_TYPES.has(current.type) && current !== root) {\n      continue;\n    }\n\n    for (const key of Object.keys(current)) {\n      if (key === \"parent\") continue;\n\n      const value = current[key];\n      if (!value) continue;\n\n      if (Array.isArray(value)) {\n        for (const element of value) {\n          if (isNode(element)) {\n            stack.push(element);\n          }\n        }\n      } else if (isNode(value)) {\n        stack.push(value);\n      }\n    }\n  }\n\n  return false;\n};\n\n/**\n * Check if a function returns JSX\n * @param {FunctionLikeNode} node\n */\nconst functionReturnsJsx = (node) => {\n  // Check arrow functions with expression body\n  if (node.type === \"ArrowFunctionExpression\" && node.body && node.body.type !== \"BlockStatement\") {\n    return expressionContainsJsx(node.body);\n  }\n\n  // Check for return statements in function body\n  const body = node.body;\n  if (!body || body.type !== \"BlockStatement\") return false;\n\n  const stack = [body];\n  while (stack.length > 0) {\n    const current = stack.pop();\n    if (!current || !isNode(current)) continue;\n\n    if (current.type === \"ReturnStatement\") {\n      const argument = current.argument;\n      if (argument && expressionContainsJsx(argument)) {\n        return true;\n      }\n    }\n\n    // Don't traverse into nested functions\n    if (FUNCTION_NODE_TYPES.has(current.type) && current !== body) {\n      continue;\n    }\n\n    for (const key of Object.keys(current)) {\n      if (key === \"parent\") continue;\n\n      const value = current[key];\n      if (!value) continue;\n\n      if (Array.isArray(value)) {\n        for (const element of value) {\n          if (isNode(element)) {\n            stack.push(element);\n          }\n        }\n      } else if (isNode(value)) {\n        stack.push(value);\n      }\n    }\n  }\n\n  return false;\n};\n\nconst rule = defineRule({\n  meta: {\n    type: \"problem\",\n    docs: {\n      description: \"Enforce consistent props parameter naming and disallow destructuring in component parameters.\",\n      recommended: false,\n    },\n    schema: [],\n  },\n\n  createOnce(context) {\n    /**\n     * @param {FunctionLikeNode} node\n     */\n    const checkFunction = (node) => {\n      // Only check functions that return JSX (React components)\n      if (!functionReturnsJsx(node)) {\n        return;\n      }\n\n      const params = node.params;\n      if (!params || params.length === 0) {\n        return;\n      }\n\n      const firstParam = params[0];\n      if (!firstParam || !isNode(firstParam)) {\n        return;\n      }\n\n      // Check if the first parameter is destructured\n      if (firstParam.type === \"ObjectPattern\" || firstParam.type === \"ArrayPattern\") {\n        context.report({\n          node: firstParam,\n          message:\n            \"Props should not be destructured in the component parameter. Use 'props' instead and destructure inside the component body.\",\n        });\n        return;\n      }\n\n      // Check if the first parameter is an Identifier and is named 'props'\n      if (firstParam.type === \"Identifier\") {\n        if (firstParam.name !== \"props\") {\n          context.report({\n            node: firstParam,\n            message: `Props parameter should be named 'props', not '${firstParam.name}'.`,\n          });\n        }\n      }\n    };\n\n    return /** @type {import(\"oxlint\").VisitorWithHooks} */ ({\n      FunctionDeclaration(node) {\n        if (isFunctionLike(node)) checkFunction(node);\n      },\n      FunctionExpression(node) {\n        if (isFunctionLike(node)) checkFunction(node);\n      },\n      ArrowFunctionExpression(node) {\n        if (isFunctionLike(node)) checkFunction(node);\n      },\n    });\n  },\n});\n\nexport const prettyPropsRule = rule;\n\nexport default {\n  meta: { name: \"conorroberts/pretty-props\" },\n  rules: { \"conorroberts/pretty-props\": rule },\n};\n"],"mappings":"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"}

package/package.json

@@ -90,7 +90,7 @@
     "typescript": "5.9.3",
     "vitest": "4.0.15"
   },
-  "version": "0.0.55",
+  "version": "0.0.56",
   "scripts": {
     "dev": "tsdown --watch",
     "build": "tsc --noEmit && tsdown",