New rule: isolated-functions

Author: mmkal

configs/recommended.js

@@ -22,6 +22,7 @@ module.exports = {
 		'unicorn/expiring-todo-comments': 'error',
 		'unicorn/explicit-length-check': 'error',
 		'unicorn/filename-case': 'error',
+		'unicorn/isolated-functions': 'error',
 		'unicorn/import-style': 'error',
 		'unicorn/new-for-builtins': 'error',
 		'unicorn/no-abusive-eslint-disable': 'error',

docs/rules/isolated-functions.md

@@ -0,0 +1,216 @@
+# Prevent usage of variables from outside the scope of isolated functions
+
+💼 This rule is enabled in the ✅ `recommended` [config](https://github.com/sindresorhus/eslint-plugin-unicorn#preset-configs).
+
+<!-- end auto-generated rule header -->
+<!-- Do not manually modify this header. Run: `npm run fix:eslint-docs` -->
+
+Some functions need to be isolated from their surrounding scope due to execution context constraints. For example, functions passed to `makeSynchronous()` are executed in a subprocess and cannot access variables from outside their scope. This rule helps identify when functions are using external variables that may cause runtime errors.
+
+Common scenarios where functions must be isolated:
+- Functions passed to `makeSynchronous()` (executed in subprocess)
+- Functions that will be serialized via `Function.prototype.toString()`
+- Server actions or other remote execution contexts
+- Functions with specific JSDoc annotations
+
+## Fail
+
+```js
+import makeSynchronous from 'make-synchronous';
+
+export const fetchSync = () => {
+	const url = 'https://example.com';
+	const getText = makeSynchronous(async () => {
+		const res = await fetch(url); // ❌ 'url' is not defined in isolated function scope
+		return res.text();
+	});
+	console.log(getText());
+};
+```
+
+```js
+const foo = 'hi';
+
+/** @isolated */
+function abc() {
+	return foo.slice(); // ❌ 'foo' is not defined in isolated function scope
+}
+```
+
+```js
+const foo = 'hi';
+
+/** @isolated */
+const abc = () => foo.slice(); // ❌ 'foo' is not defined in isolated function scope
+```
+
+## Pass
+
+```js
+import makeSynchronous from 'make-synchronous';
+
+export const fetchSync = () => {
+	const getText = makeSynchronous(async () => {
+		const url = 'https://example.com'; // ✅ Variable defined within function scope
+		const res = await fetch(url);
+		return res.text();
+	});
+	console.log(getText());
+};
+```
+
+```js
+import makeSynchronous from 'make-synchronous';
+
+export const fetchSync = () => {
+	const getText = makeSynchronous(async (url) => { // ✅ Variable passed as parameter
+		const res = await fetch(url);
+		return res.text();
+	});
+	console.log(getText('https://example.com'));
+};
+```
+
+```js
+/** @isolated */
+function abc() {
+	const foo = 'hi'; // ✅ Variable defined within function scope
+	return foo.slice();
+}
+```
+
+## Options
+
+Type: `object`
+
+### functions
+
+Type: `string[]`\
+Default: `['makeSynchronous']`
+
+Array of function names that create isolated execution contexts. Functions passed as arguments to these functions will be considered isolated.
+
+### selectors
+
+Type: `string[]`\
+Default: `[]`
+
+Array of [ESLint selectors](https://eslint.org/docs/developer-guide/selectors) to identify isolated functions. Useful for custom naming conventions or framework-specific patterns.
+
+```js
+{
+	'unicorn/isolated-functions': [
+		'error',
+		{
+			selectors: ['FunctionDeclaration[id.name=/lambdaHandler.*/]']
+		}
+	]
+}
+```
+
+### comments
+
+Type: `string[]`\
+Default: `['@isolated']`
+
+Array of comment strings that mark functions as isolated. Functions with JSDoc comments containing these strings will be considered isolated.
+
+```js
+{
+	'unicorn/isolated-functions': [
+		'error',
+		{
+			comments: ['@isolated', '@remote']
+		}
+	]
+}
+```
+
+### globals
+
+Type: `boolean | string[]`\
+Default: `false`
+
+Controls how global variables are handled:
+
+- `false` (default): Global variables are not allowed in isolated functions
+- `true`: All globals from ESLint's language options are allowed
+- `string[]`: Only the specified global variable names are allowed
+
+```js
+{
+	'unicorn/isolated-functions': [
+		'error',
+		{
+			globals: ['console', 'fetch'] // Only allow these globals
+		}
+	]
+}
+```
+
+## Examples
+
+### Custom function names
+
+```js
+{
+	'unicorn/isolated-functions': [
+		'error',
+		{
+			functions: ['makeSynchronous', 'createWorker', 'serializeFunction']
+		}
+	]
+}
+```
+
+### Lambda function naming convention
+
+```js
+{
+	'unicorn/isolated-functions': [
+		'error',
+		{
+			selectors: ['FunctionDeclaration[id.name=/lambdaHandler.*/]']
+		}
+	]
+}
+```
+
+```js
+const foo = 'hi';
+
+function lambdaHandlerFoo() { // ❌ Will be flagged as isolated
+	return foo.slice();
+}
+
+function someOtherFunction() { // ✅ Not flagged
+	return foo.slice();
+}
+
+createLambda({
+	name: 'fooLambda',
+	code: lambdaHandlerFoo.toString(), // Function will be serialized
+});
+```
+
+### Allowing specific globals
+
+```js
+{
+	'unicorn/isolated-functions': [
+		'error',
+		{
+			globals: ['console', 'fetch', 'URL']
+		}
+	]
+}
+```
+
+```js
+makeSynchronous(async () => {
+	console.log('Starting...'); // ✅ Allowed global
+	const response = await fetch('https://api.example.com'); // ✅ Allowed global
+	const url = new URL(response.url); // ✅ Allowed global
+	return response.text();
+});
+``` 

readme.md

@@ -67,6 +67,7 @@ If you don't use the preset, ensure you use the same `env` and `parserOptions` c
 | [explicit-length-check](docs/rules/explicit-length-check.md)                                     | Enforce explicitly comparing the `length` or `size` property of a value.                                                                                                                                          | ✅  | 🔧 | 💡 |
 | [filename-case](docs/rules/filename-case.md)                                                     | Enforce a case style for filenames.                                                                                                                                                                               | ✅  |    |    |
 | [import-style](docs/rules/import-style.md)                                                       | Enforce specific import styles per module.                                                                                                                                                                        | ✅  |    |    |
+| [isolated-functions](docs/rules/isolated-functions.md)                                           | Prevent usage of variables from outside the scope of isolated functions.                                                                                                                                          | ✅  |    |    |
 | [new-for-builtins](docs/rules/new-for-builtins.md)                                               | Enforce the use of `new` for all builtins, except `String`, `Number`, `Boolean`, `Symbol` and `BigInt`.                                                                                                           | ✅  | 🔧 |    |
 | [no-abusive-eslint-disable](docs/rules/no-abusive-eslint-disable.md)                             | Enforce specifying rules to disable in `eslint-disable` comments.                                                                                                                                                 | ✅  |    |    |
 | [no-array-callback-reference](docs/rules/no-array-callback-reference.md)                         | Prevent passing a function reference directly to iterator methods.                                                                                                                                                | ✅  |    | 💡 |