@next-friday/eslint-plugin-friday 0.0.0-stage → 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Next Friday
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,59 @@
-# Temporary Holding Version
+# @next-friday/eslint-plugin-friday
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![npm version](https://img.shields.io/npm/v/%40next-friday%2Feslint-plugin-friday.svg)](https://www.npmjs.com/package/@next-friday/eslint-plugin-friday) [![CI](https://github.com/next-friday/eslint-plugin-friday/actions/workflows/ci.yml/badge.svg)](https://github.com/next-friday/eslint-plugin-friday/actions/workflows/ci.yml) [![Codecov](https://codecov.io/gh/next-friday/eslint-plugin-friday/branch/main/graph/badge.svg)](https://codecov.io/gh/next-friday/eslint-plugin-friday/branch/main) [![License](https://img.shields.io/github/license/next-friday/eslint-plugin-friday.svg)](LICENSE)
+
+Next Friday-specific ESLint rules for structural constraints generic lint stacks do not encode.
+
+- Rules target module boundaries, React component structure, JSX layout, props shape, and identifier quality.
+- Rules expose focused behavior and documented options.
+- The plugin is intentionally narrow: it adds Next Friday-specific semantics instead of duplicating maintained ecosystem rules.
+
+## Usage
+
+Register the plugin in an ESLint Flat Config and enable the rules you need:
+
+```js
+import friday from "@next-friday/eslint-plugin-friday";
+
+export default [
+  {
+    plugins: {friday},
+    rules: {
+      "friday/no-lazy-identifiers": "error",
+    },
+  },
+];
+```
+
+The package exports rule implementations and their documented options.
+
+## Rules
+
+<!-- begin auto-generated rules list -->
+
+🔧 Automatically fixable by the [`--fix` CLI option](https://eslint.org/docs/user-guide/command-line-interface#--fix).
+
+| Name                                                                                     | Description                                                                                                                                                                                     | 🔧  |
+| :--------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :-- |
+| [component-module](docs/rules/component-module.md)                                       | require React component modules to contain only imports, directives, export lists or re-exports, TypeScript interfaces, React function components, and explicitly allowed exported declarations |     |
+| [index-export-only](docs/rules/index-export-only.md)                                     | require index files to contain only imports, exports without inline runtime implementation, directives, and type declarations                                                                   |     |
+| [jsx-newline-between-elements](docs/rules/jsx-newline-between-elements.md)               | require empty lines between adjacent JSX elements, fragments, or expression containers when either is multi-line                                                                                | 🔧  |
+| [jsx-no-newline-single-line-elements](docs/rules/jsx-no-newline-single-line-elements.md) | disallow empty lines between adjacent single-line JSX elements or fragments                                                                                                                     | 🔧  |
+| [named-props](docs/rules/named-props.md)                                                 | disallow inline intersections in the first parameter of React function components                                                                                                               |     |
+| [no-lazy-identifiers](docs/rules/no-lazy-identifiers.md)                                 | disallow lazy placeholder identifiers such as repeated characters and keyboard-row runs                                                                                                         |     |
+| [object-curly-newline](docs/rules/object-curly-newline.md)                               | require every non-empty object literal to use multiline braces                                                                                                                                  | 🔧  |
+| [props-in-body](docs/rules/props-in-body.md)                                             | disallow object destructuring in the first parameter of React function components                                                                                                               |     |
+
+<!-- end auto-generated rules list -->
+
+## Compatibility
+
+| Surface       | Supported contract |
+| :------------ | :----------------- |
+| Node.js       | `^22.13.0          |     | >=24.0.0` |
+| ESLint        | `^10.4.0`          |
+| Module format | ESM                |
+
+## License
+
+[MIT](LICENSE) © Next Friday

package/dist/index.d.mts

@@ -0,0 +1,20 @@
+//#region src/index.d.ts
+declare const plugin: {
+  meta: {
+    name: string;
+    namespace: string;
+    version: string;
+  };
+  rules: {
+    "component-module": import("eslint").Rule.RuleModule;
+    "index-export-only": import("eslint").Rule.RuleModule;
+    "jsx-newline-between-elements": import("eslint").Rule.RuleModule;
+    "jsx-no-newline-single-line-elements": import("eslint").Rule.RuleModule;
+    "named-props": import("eslint").Rule.RuleModule;
+    "no-lazy-identifiers": import("eslint").Rule.RuleModule;
+    "object-curly-newline": import("eslint").Rule.RuleModule;
+    "props-in-body": import("eslint").Rule.RuleModule;
+  };
+};
+//#endregion
+export { plugin as default };

package/dist/index.mjs

@@ -0,0 +1,590 @@
+import { getFunctionComponentCollector } from "@eslint-react/core";
+import path from "node:path";
+//#endregion
+//#region src/meta.ts
+const meta = {
+	name: "@next-friday/eslint-plugin-friday",
+	namespace: "friday",
+	version: "1.0.0"
+};
+//#endregion
+//#region src/utils/function-component-visitor.ts
+/**
+* Attach the React component collector to a rule and pass its results on program exit.
+* @param context ESLint rule context.
+* @param onProgramExit Rule-specific check for the program and detected components.
+* @returns The collector's visitors and the program exit handler.
+*/
+function createFunctionComponentVisitor(context, onProgramExit) {
+	const collector = getFunctionComponentCollector(context);
+	return {
+		...collector.visitor,
+		"Program:exit": (node) => {
+			const program = node;
+			onProgramExit(program, collector.api.getAllComponents(program));
+		}
+	};
+}
+//#endregion
+//#region src/utils/rule-doc-url.ts
+const RULE_DOC_BASE_URL = "https://github.com/next-friday/eslint-plugin-friday/blob/main/docs/rules";
+function getRuleDocumentationUrl(ruleName) {
+	return `${RULE_DOC_BASE_URL}/${ruleName}.md`;
+}
+//#endregion
+//#region src/rules/component-module.ts
+const MESSAGE_ID$6 = "componentModule";
+const ALLOWED_MODULE_STATEMENT_TYPES = /* @__PURE__ */ new Set([
+	"ExportAllDeclaration",
+	"ImportDeclaration",
+	"TSInterfaceDeclaration"
+]);
+const EXPORT_STATEMENT_TYPES = /* @__PURE__ */ new Set(["ExportDefaultDeclaration", "ExportNamedDeclaration"]);
+/**
+* Check whether a declaration contains only React function components.
+* @param node Declaration node to evaluate.
+* @param components React function components detected by the React detector.
+* @returns Whether the declaration contains only React function components.
+*/
+function isAllowedComponentDeclaration(node, components) {
+	switch (node.type) {
+		case "FunctionDeclaration": return components.some((component) => Object.is(component.node, node));
+		case "VariableDeclaration": return node.declarations !== void 0 && node.declarations.length > 0 && node.declarations.every((declarator) => components.some((component) => Object.is(component.initPath?.[1], declarator)));
+		default: return components.some((component) => Object.is(component.node, node));
+	}
+}
+/**
+* Check whether a declaration name is explicitly allowed by framework policy.
+* @param node Declaration node to evaluate.
+* @param allowedDeclarations Framework-owned declaration names.
+* @returns Whether every declaration name is allowed.
+*/
+function isAllowedDeclarationName(node, allowedDeclarations) {
+	switch (node.type) {
+		case "FunctionDeclaration": return node.id?.name !== void 0 && allowedDeclarations.has(node.id.name);
+		case "VariableDeclaration": return node.declarations !== void 0 && node.declarations.length > 0 && node.declarations.every((declaration) => declaration.id?.name !== void 0 && allowedDeclarations.has(declaration.id.name));
+		default: return false;
+	}
+}
+/**
+* Check whether an export contains only allowed declarations.
+* @param node Export statement to evaluate.
+* @param components React function components detected by the React detector.
+* @param allowedDeclarations Framework-owned declaration names.
+* @returns Whether the export belongs in the component module.
+*/
+function isAllowedExportStatement(node, components, allowedDeclarations) {
+	if (!EXPORT_STATEMENT_TYPES.has(node.type)) return false;
+	if (!node.declaration) return true;
+	const declaration = node.declaration;
+	return declaration.type === "TSInterfaceDeclaration" || isAllowedComponentDeclaration(declaration, components) || isAllowedDeclarationName(declaration, allowedDeclarations);
+}
+/**
+* Check whether the statement is permitted module syntax.
+* @param node Top-level program statement.
+* @returns Whether the statement is an import, re-export, interface, or directive.
+*/
+function isAllowedModuleSyntax(node) {
+	return ALLOWED_MODULE_STATEMENT_TYPES.has(node.type) || node.type === "ExpressionStatement" && node.directive !== void 0;
+}
+/**
+* Check whether a top-level statement is permitted in a React component module.
+* @param node Top-level program statement.
+* @param components React function components detected by the React detector.
+* @param allowedDeclarations Framework-owned declaration names.
+* @returns Whether the statement belongs in a JSX or TSX component module.
+*/
+function isAllowedStatement$1(node, components, allowedDeclarations) {
+	return isAllowedModuleSyntax(node) || isAllowedComponentDeclaration(node, components) || isAllowedExportStatement(node, components, allowedDeclarations);
+}
+const componentModule = {
+	create(context) {
+		const [options] = context.options;
+		const allowedDeclarations = new Set(options?.allowDeclarations);
+		return createFunctionComponentVisitor(context, (node, components) => {
+			let index = 0;
+			while (index < node.body.length) {
+				const statement = node.body[index];
+				index += 1;
+				if (!isAllowedStatement$1(statement, components, allowedDeclarations)) context.report({
+					messageId: MESSAGE_ID$6,
+					node: statement
+				});
+			}
+		});
+	},
+	meta: {
+		languages: ["js/js"],
+		type: "suggestion",
+		docs: {
+			description: "require React component modules to contain only imports, directives, export lists or re-exports, TypeScript interfaces, React function components, and explicitly allowed exported declarations",
+			url: getRuleDocumentationUrl("component-module")
+		},
+		defaultOptions: [{ allowDeclarations: [] }],
+		messages: { [MESSAGE_ID$6]: "Move non-component top-level code out of this React component module into a separate module." },
+		schema: [{
+			type: "object",
+			additionalProperties: false,
+			properties: { allowDeclarations: {
+				description: "Framework-owned declaration names allowed in component modules.",
+				type: "array",
+				uniqueItems: true,
+				items: { type: "string" }
+			} }
+		}]
+	}
+};
+//#endregion
+//#region src/rules/index-export-only.ts
+const MESSAGE_ID$5 = "indexExportOnly";
+/**
+* Check whether a named export contains only type declarations or re-exports.
+* @param node Export statement to inspect.
+* @returns Whether the named export is valid for an index barrel.
+*/
+function isAllowedNamedExport(node) {
+	return node.declaration === void 0 || node.declaration === null || node.declaration.type === "TSInterfaceDeclaration" || node.declaration.type === "TSTypeAliasDeclaration";
+}
+/**
+* Check whether a top-level statement is valid in an index barrel.
+* @param node Top-level statement to inspect.
+* @returns Whether the statement belongs in an index barrel.
+*/
+function isAllowedStatement(node) {
+	switch (node.type) {
+		case "ExportAllDeclaration": return true;
+		case "ExportDefaultDeclaration": return node.declaration?.type === "Identifier";
+		case "ExportNamedDeclaration": return isAllowedNamedExport(node);
+		case "ExpressionStatement": return node.directive !== void 0;
+		case "ImportDeclaration": return true;
+		case "TSImportEqualsDeclaration": return node.moduleReference?.type === "TSExternalModuleReference";
+		case "TSInterfaceDeclaration": return true;
+		case "TSTypeAliasDeclaration": return true;
+		default: return false;
+	}
+}
+/**
+* Check whether a filename belongs to an index barrel.
+* @param filename Filename reported by ESLint.
+* @returns Whether the filename without its final extension is exactly `index`.
+*/
+function isIndexFile(filename) {
+	return path.parse(filename).name === "index";
+}
+const indexExportOnly = {
+	create(context) {
+		if (!isIndexFile(context.filename)) return {};
+		const checkProgram = (node) => {
+			const program = node;
+			let index = 0;
+			while (index < program.body.length) {
+				const statement = program.body[index];
+				index += 1;
+				if (!isAllowedStatement(statement)) context.report({
+					messageId: MESSAGE_ID$5,
+					node: statement
+				});
+			}
+		};
+		return { Program: checkProgram };
+	},
+	meta: {
+		languages: ["js/js"],
+		type: "suggestion",
+		docs: {
+			description: "require index files to contain only imports, exports without inline runtime implementation, directives, and type declarations",
+			url: getRuleDocumentationUrl("index-export-only")
+		},
+		messages: { [MESSAGE_ID$5]: "Index files must contain only imports, exports without inline runtime implementation, directives, and type declarations. Move runtime implementation to a dedicated module and export it from the index." },
+		schema: []
+	}
+};
+//#endregion
+//#region src/utils/jsx-children.ts
+const IGNORABLE_JSX_TEXT = /^[\t\n\r ]*$/u;
+/**
+* Check whether a JSXText child contains only layout whitespace that React can ignore.
+* Unicode spacing characters such as non-breaking space remain significant content.
+* @param child JSX child to inspect.
+* @returns Whether the child is ignorable layout whitespace.
+*/
+function isIgnorableJsxText(child) {
+	return child.type === "JSXText" && IGNORABLE_JSX_TEXT.test(child.value ?? "");
+}
+/**
+* Create visitors for JSX elements and fragments that pass their children to a rule check.
+* @param checkChildren Rule-specific check for the parent's JSX children.
+* @returns JSX element and fragment visitors.
+*/
+function createJsxParentListener(checkChildren) {
+	const visitJsxParent = (node) => {
+		const { children } = node;
+		if (children.length > 0) checkChildren(children);
+	};
+	return {
+		JSXElement: visitJsxParent,
+		JSXFragment: visitJsxParent
+	};
+}
+//#endregion
+//#region src/rules/jsx-newline-between-elements.ts
+const MESSAGE_ID$4 = "requireNewline";
+const SIGNIFICANT_JSX_CHILD_TYPES = /* @__PURE__ */ new Set([
+	"JSXElement",
+	"JSXExpressionContainer",
+	"JSXFragment"
+]);
+/**
+* Check whether adjacent significant JSX children need a separating empty line.
+* @param current Previous significant JSX child.
+* @param next Next significant JSX child.
+* @returns Whether at least one child is multi-line and no empty line exists.
+*/
+function canRequireGap(current, next) {
+	if (!SIGNIFICANT_JSX_CHILD_TYPES.has(current.type) || !SIGNIFICANT_JSX_CHILD_TYPES.has(next.type)) return false;
+	const isCurrentMultiLine = current.loc.start.line !== current.loc.end.line;
+	const isNextMultiLine = next.loc.start.line !== next.loc.end.line;
+	const hasGap = next.loc.start.line - current.loc.end.line >= 2;
+	return (isCurrentMultiLine || isNextMultiLine) && !hasGap;
+}
+/**
+* Enforce blank lines around multi-line JSX siblings.
+* @param context Active ESLint rule context.
+* @param children JSX children belonging to one element or fragment.
+*/
+function checkSiblings$1(context, children) {
+	const siblings = children.filter((child) => !isIgnorableJsxText(child));
+	let index = 0;
+	while (index < siblings.length - 1) {
+		const current = siblings[index];
+		const next = siblings[index + 1];
+		if (current && next && canRequireGap(current, next)) context.report({
+			messageId: MESSAGE_ID$4,
+			fix(fixer) {
+				return fixer.insertTextAfter(current, "\n");
+			},
+			node: next
+		});
+		index += 1;
+	}
+}
+const jsxNewlineBetweenElements = {
+	create(context) {
+		return createJsxParentListener((children) => checkSiblings$1(context, children));
+	},
+	meta: {
+		languages: ["js/js"],
+		type: "layout",
+		docs: {
+			description: "require empty lines between adjacent JSX elements, fragments, or expression containers when either is multi-line",
+			url: getRuleDocumentationUrl("jsx-newline-between-elements")
+		},
+		fixable: "whitespace",
+		messages: { [MESSAGE_ID$4]: "Expected empty line between adjacent JSX elements, fragments, or expression containers." },
+		schema: []
+	}
+};
+//#endregion
+//#region src/rules/jsx-no-newline-single-line-elements.ts
+const MESSAGE_ID$3 = "forbidNewline";
+/**
+* Check whether two adjacent JSX children are single-line element siblings with an empty line.
+* @param current Previous significant JSX child.
+* @param next Next significant JSX child.
+* @returns Whether the gap should be collapsed.
+*/
+function canCollapseGap(current, next) {
+	const isCurrentElement = current.type === "JSXElement" || current.type === "JSXFragment";
+	const isNextElement = next.type === "JSXElement" || next.type === "JSXFragment";
+	if (!isCurrentElement || !isNextElement) return false;
+	const isCurrentSingleLine = current.loc.start.line === current.loc.end.line;
+	const isNextSingleLine = next.loc.start.line === next.loc.end.line;
+	return isCurrentSingleLine && isNextSingleLine && next.loc.start.line - current.loc.end.line >= 2;
+}
+/**
+* Enforce compact spacing between adjacent single-line JSX element siblings.
+* @param context Active ESLint rule context.
+* @param children JSX children belonging to one element or fragment.
+*/
+function checkSiblings(context, children) {
+	const elements = children.filter((child) => !isIgnorableJsxText(child));
+	let index = 1;
+	while (index < elements.length) {
+		const current = elements[index - 1];
+		const next = elements[index];
+		if (current && next && canCollapseGap(current, next)) context.report({
+			messageId: MESSAGE_ID$3,
+			fix(fixer) {
+				const indent = " ".repeat(next.loc.start.column);
+				return fixer.replaceTextRange([current.range[1], next.range[0]], `\n${indent}`);
+			},
+			node: next
+		});
+		index += 1;
+	}
+}
+const jsxNoNewlineSingleLineElements = {
+	create(context) {
+		return createJsxParentListener((children) => checkSiblings(context, children));
+	},
+	meta: {
+		languages: ["js/js"],
+		type: "layout",
+		docs: {
+			description: "disallow empty lines between adjacent single-line JSX elements or fragments",
+			url: getRuleDocumentationUrl("jsx-no-newline-single-line-elements")
+		},
+		fixable: "whitespace",
+		messages: { [MESSAGE_ID$3]: "Unexpected empty line between adjacent single-line JSX elements or fragments." },
+		schema: []
+	}
+};
+//#endregion
+//#region src/rules/named-props.ts
+const MESSAGE_ID$2 = "namedProperties";
+/**
+* Get the typed identifier behind a component parameter.
+* @param parameter Component parameter to inspect.
+* @returns Typed identifier parameter, including one wrapped by a default assignment.
+*/
+function getTypedParameter(parameter) {
+	if (parameter === void 0) return;
+	const typedParameter = parameter;
+	if (typedParameter.typeAnnotation !== void 0) return typedParameter;
+	return typedParameter.left?.typeAnnotation === void 0 ? void 0 : typedParameter.left;
+}
+const namedProps = {
+	create(context) {
+		return createFunctionComponentVisitor(context, (_node, components) => {
+			let index = 0;
+			while (index < components.length) {
+				const component = components[index];
+				index += 1;
+				const [parameter] = component.node.params;
+				if ((getTypedParameter(parameter)?.typeAnnotation?.typeAnnotation)?.type === "TSIntersectionType") context.report({
+					messageId: MESSAGE_ID$2,
+					node: parameter
+				});
+			}
+		});
+	},
+	meta: {
+		languages: ["js/js"],
+		type: "suggestion",
+		docs: {
+			description: "disallow inline intersections in the first parameter of React function components",
+			url: getRuleDocumentationUrl("named-props")
+		},
+		messages: { [MESSAGE_ID$2]: "Move the inline intersection props type into a named props type and use that type as the component parameter type." },
+		schema: []
+	}
+};
+//#endregion
+//#region src/rules/no-lazy-identifiers.ts
+const MESSAGE_ID$1 = "noLazyIdentifier";
+const MIN_LENGTH = 3;
+const MIN_SEQUENCE_LENGTH = 4;
+const CHECKED_DEFINITION_TYPES = /* @__PURE__ */ new Set([
+	"CatchClause",
+	"ClassName",
+	"FunctionName",
+	"Parameter",
+	"Type",
+	"Variable"
+]);
+const KEYBOARD_RUNS = [
+	"qwertyuiop",
+	"poiuytrewq",
+	"asdfghjkl",
+	"lkjhgfdsa",
+	"zxcvbnm",
+	"mnbvcxz",
+	"1234567890",
+	"0987654321"
+];
+/**
+* Split an identifier into semantic camel-case, acronym, numeric, and separator-delimited words.
+* @param name Identifier name to split.
+* @returns Identifier word segments used for keyboard-run detection.
+*/
+function getIdentifierWords(name) {
+	return name.replaceAll(/([a-z0-9])([A-Z])/g, "$1 $2").replaceAll(/([A-Z])([A-Z][a-z])/g, "$1 $2").replaceAll(/([a-z])(\d)/gi, "$1 $2").replaceAll(/(\d)([a-z])/gi, "$1 $2").split(/[^a-z0-9]+/i).filter((word) => word.length > 0);
+}
+/**
+* Check whether an identifier contains the same character three times consecutively.
+* @param name Identifier name to inspect.
+* @returns Whether the identifier contains a repeated-character run.
+*/
+function hasRepeatedCharacters(name) {
+	const characters = [...name];
+	return characters.some((character, index) => index <= characters.length - 3 && character === characters[index + 1] && character === characters[index + 2]);
+}
+/**
+* Check whether an identifier segment is a keyboard-row run in either direction.
+* @param segment Identifier segment to inspect.
+* @returns Whether the segment is a keyboard-row run.
+*/
+function isKeyboardRun(segment) {
+	const normalized = segment.toLowerCase();
+	return normalized.length >= MIN_SEQUENCE_LENGTH && KEYBOARD_RUNS.some((run) => run.includes(normalized));
+}
+/**
+* Determine whether an identifier is a lazy placeholder name.
+* @param name Identifier name to inspect.
+* @returns Whether the identifier should be rejected.
+*/
+function isLazyIdentifier(name) {
+	return name.length >= MIN_LENGTH && !name.startsWith("_") && (hasRepeatedCharacters(name) || getIdentifierWords(name).some((segment) => isKeyboardRun(segment)));
+}
+const noLazyIdentifiers = {
+	create(context) {
+		const [options] = context.options;
+		const allowed = new Set(options?.allow);
+		const sourceCode = context.sourceCode;
+		const checkIdentifier = (identifier) => {
+			if (!allowed.has(identifier.name) && isLazyIdentifier(identifier.name)) context.report({
+				messageId: MESSAGE_ID$1,
+				data: { name: identifier.name },
+				node: identifier
+			});
+		};
+		const checkProgram = () => {
+			const identifiers = (sourceCode.scopeManager?.scopes.flatMap((scope) => scope.variables) ?? []).filter((variable) => variable.defs.some((definition) => CHECKED_DEFINITION_TYPES.has(definition.type))).flatMap((variable) => variable.identifiers);
+			const uniqueIdentifiers = [...new Set(identifiers)];
+			let index = 0;
+			while (index < uniqueIdentifiers.length) {
+				const identifier = uniqueIdentifiers[index];
+				index += 1;
+				checkIdentifier(identifier);
+			}
+		};
+		return { "Program:exit": checkProgram };
+	},
+	meta: {
+		languages: ["js/js"],
+		type: "problem",
+		docs: {
+			description: "disallow lazy placeholder identifiers such as repeated characters and keyboard-row runs",
+			url: getRuleDocumentationUrl("no-lazy-identifiers")
+		},
+		defaultOptions: [{ allow: [] }],
+		messages: { [MESSAGE_ID$1]: "Avoid lazy identifier '{{name}}'. Use a descriptive name that clearly indicates its purpose." },
+		schema: [{
+			type: "object",
+			additionalProperties: false,
+			properties: { allow: {
+				description: "Identifier names explicitly exempt from this rule.",
+				type: "array",
+				uniqueItems: true,
+				items: { type: "string" }
+			} }
+		}]
+	}
+};
+//#endregion
+//#region src/rules/object-curly-newline.ts
+const REQUIRE_MULTILINE = "requireMultiline";
+/**
+* Enforce multiline braces for every non-empty object literal.
+* @param context Active ESLint rule context.
+* @param node Object expression to validate.
+*/
+function checkObjectExpression(context, node) {
+	if (node.properties.length === 0) return;
+	const openingBrace = context.sourceCode.getFirstToken(node);
+	const closingBrace = context.sourceCode.getLastToken(node);
+	const firstContent = context.sourceCode.getTokenAfter(openingBrace, { includeComments: true });
+	const lastContent = context.sourceCode.getTokenBefore(closingBrace, { includeComments: true });
+	const shouldAddOpeningNewline = firstContent.loc.start.line === openingBrace.loc.end.line;
+	const shouldAddClosingNewline = lastContent.loc.end.line === closingBrace.loc.start.line;
+	if (!shouldAddOpeningNewline && !shouldAddClosingNewline) return;
+	context.report({
+		messageId: REQUIRE_MULTILINE,
+		node,
+		fix(fixer) {
+			const fixes = [];
+			if (shouldAddOpeningNewline) fixes.push(fixer.insertTextAfter(openingBrace, "\n"));
+			if (shouldAddClosingNewline) fixes.push(fixer.insertTextBefore(closingBrace, "\n"));
+			return fixes;
+		}
+	});
+}
+const objectCurlyNewline = {
+	create(context) {
+		return { ObjectExpression(node) {
+			checkObjectExpression(context, node);
+		} };
+	},
+	meta: {
+		languages: ["js/js"],
+		type: "layout",
+		docs: {
+			description: "require every non-empty object literal to use multiline braces",
+			url: getRuleDocumentationUrl("object-curly-newline")
+		},
+		fixable: "whitespace",
+		messages: { [REQUIRE_MULTILINE]: "Non-empty object literals must use multiline braces." },
+		schema: []
+	}
+};
+//#endregion
+//#region src/rules/props-in-body.ts
+const MESSAGE_ID = "propertiesInBody";
+/**
+* Report React component parameters that destructure object props in the signature.
+* @param context ESLint rule context.
+* @param parameter First component parameter, when present.
+*/
+function reportDestructuredParameter(context, parameter) {
+	if (parameter === void 0) return;
+	if ("properties" in parameter) {
+		context.report({
+			messageId: MESSAGE_ID,
+			node: parameter
+		});
+		return;
+	}
+	if ("left" in parameter && "properties" in parameter.left) context.report({
+		messageId: MESSAGE_ID,
+		node: parameter.left
+	});
+}
+//#endregion
+//#region src/index.ts
+const plugin = {
+	meta,
+	rules: {
+		"component-module": componentModule,
+		"index-export-only": indexExportOnly,
+		"jsx-newline-between-elements": jsxNewlineBetweenElements,
+		"jsx-no-newline-single-line-elements": jsxNoNewlineSingleLineElements,
+		"named-props": namedProps,
+		"no-lazy-identifiers": noLazyIdentifiers,
+		"object-curly-newline": objectCurlyNewline,
+		"props-in-body": {
+			create(context) {
+				return createFunctionComponentVisitor(context, (_node, components) => {
+					let index = 0;
+					while (index < components.length) {
+						const component = components[index];
+						index += 1;
+						const [parameter] = component.node.params;
+						reportDestructuredParameter(context, parameter);
+					}
+				});
+			},
+			meta: {
+				languages: ["js/js"],
+				type: "suggestion",
+				docs: {
+					description: "disallow object destructuring in the first parameter of React function components",
+					url: getRuleDocumentationUrl("props-in-body")
+				},
+				messages: { [MESSAGE_ID]: "Accept props as a named parameter and destructure them inside the React function component body." },
+				schema: []
+			}
+		}
+	}
+};
+//#endregion
+export { plugin as default };

package/package.json

@@ -1,6 +1,106 @@
 {
   "name": "@next-friday/eslint-plugin-friday",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "1.0.0",
+  "description": "Next Friday-specific ESLint rules for shared engineering standards.",
+  "keywords": [
+    "eslint",
+    "eslint-plugin",
+    "eslintplugin",
+    "react",
+    "typescript",
+    "next-friday"
+  ],
+  "homepage": "https://github.com/next-friday/eslint-plugin-friday#readme",
+  "bugs": {
+    "url": "https://github.com/next-friday/eslint-plugin-friday/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/next-friday/eslint-plugin-friday.git"
+  },
+  "license": "MIT",
+  "author": "Next Friday",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    "types": "./dist/index.d.mts",
+    "import": "./dist/index.mjs",
+    "default": "./dist/index.mjs"
+  },
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@eslint-react/core": "5.21.0"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "0.18.5",
+    "@changesets/cli": "3.0.3",
+    "@commitlint/cli": "21.2.3",
+    "@commitlint/config-conventional": "21.2.3",
+    "@eslint/js": "10.0.1",
+    "@types/node": "26.6.3",
+    "@vitest/coverage-v8": "5.0.2",
+    "eslint": "10.11.0",
+    "eslint-config-prettier": "10.1.8",
+    "eslint-doc-generator": "3.7.1",
+    "eslint-plugin-eslint-plugin": "7.6.2",
+    "eslint-plugin-package-json": "1.10.1",
+    "eslint-plugin-unicorn": "76.0.0",
+    "husky": "9.1.7",
+    "knip": "6.38.0",
+    "lint-staged": "17.6.0",
+    "pkg-pr-new": "0.0.88",
+    "prettier": "3.9.9",
+    "publint": "0.3.24",
+    "sort-package-json": "4.0.0",
+    "tsdown": "0.23.0",
+    "typescript": "6.0.3",
+    "typescript-eslint": "8.70.1",
+    "vite": "8.3.1",
+    "vitest": "5.0.2"
+  },
+  "peerDependencies": {
+    "eslint": "^10.4.0"
+  },
+  "engines": {
+    "node": "^22.13.0 || >=24.0.0"
+  },
+  "devEngines": {
+    "runtime": {
+      "name": "node",
+      "version": "24.20.0",
+      "onFail": "download"
+    }
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "audit": "pnpm audit",
+    "build": "tsdown",
+    "changeset": "changeset",
+    "changeset:status": "changeset status --since main",
+    "check:attw": "attw --pack . --profile esm-only --ignore-rules cjs-resolves-to-esm --no-summary",
+    "check:publint": "publint",
+    "clean": "rm -rf dist coverage *.tsbuildinfo .eslintcache node_modules/.cache",
+    "dev": "tsdown --watch",
+    "docs:check": "pnpm build && eslint-doc-generator --check",
+    "docs:generate": "pnpm build && eslint-doc-generator",
+    "fix": "pnpm lint && pnpm format",
+    "format": "prettier --write --cache .",
+    "format:check": "prettier --check --cache .",
+    "knip": "knip",
+    "lint": "eslint . --fix --cache --max-warnings=0",
+    "lint:check": "eslint . --cache --max-warnings=0",
+    "sort-package-json": "sort-package-json package.json",
+    "sort-package-json:check": "sort-package-json --check package.json",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "verify": "pnpm lint:check && pnpm format:check && pnpm sort-package-json:check && pnpm docs:check && pnpm typecheck && pnpm test:coverage && pnpm knip && pnpm build && pnpm check:publint && pnpm check:attw"
+  }
 }