@lexical/eslint-plugin 0.44.1-nightly.20260519.0 → 0.45.0

package/{LexicalEslintPlugin.dev.js → dist/LexicalEslintPlugin.dev.js}

@@ -25,7 +25,7 @@ function getDefaultExportFromCjs (x) {
 }
 
 var name = "@lexical/eslint-plugin";
-var version = "0.44.1-nightly.20260519.0";
+var version = "0.45.0";
 var require$$0 = {
 	name: name,
 	version: version};

package/{LexicalEslintPlugin.dev.mjs → dist/LexicalEslintPlugin.dev.mjs}

@@ -23,7 +23,7 @@ function getDefaultExportFromCjs (x) {
 }
 
 var name = "@lexical/eslint-plugin";
-var version = "0.44.1-nightly.20260519.0";
+var version = "0.45.0";
 var require$$0 = {
 	name: name,
 	version: version};

package/dist/LexicalEslintPlugin.prod.js

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+"use strict";function e(e,n){for(var t=0;t<n.length;t++){var r=n[t];if("string"!=typeof r&&!Array.isArray(r))for(var i in r)"default"===i||i in e||(e[i]=r[i])}return e}function n(e){return e&&e.__esModule&&Object.prototype.hasOwnProperty.call(e,"default")?e.default:e}var t,r,i={name:"@lexical/eslint-plugin",version:"0.45.0"},o={},s={},a={};function l(){return t||(t=1,a.getParentAssignmentName=function(e){const n=e.parent;if(null!=n)return"VariableDeclarator"===n.type&&n.init===e?n.id:"AssignmentExpression"===n.type&&n.right===e&&"="===n.operator?n.left:void 0}),a}function c(){if(r)return s;r=1;const{getParentAssignmentName:e}=l();return s.getFunctionName=function(n){return"FunctionDeclaration"===n.type||"FunctionExpression"===n.type&&n.id?n.id:"FunctionExpression"===n.type||"ArrowFunctionExpression"===n.type?e(n):void 0},s}var u,f,p,d,g={};function x(){if(u)return g;function e(e){return e.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}return u=1,g.buildMatcher=function(...n){const t=[],r=[];for(const i of n.flat(1))i&&("string"==typeof i?r.push(/^[(^]/.test(i)?i:`^${e(i)}$`):i&&i instanceof RegExp?i.flags?t.push(e=>i.test(e)):r.push(i.source):"function"==typeof i&&t.push(i));const i=r.map(e=>`(?:${e})`).join("|");if(i){const e=new RegExp(i);t.push(n=>e.test(n))}return e=>{if(e){if("Identifier"!==e.type)throw new Error(`Expecting Identifier, not ${e.type}`);for(const n of t)if(n(e.name,e))return!0}return!1}},g}function m(){if(f)return o;f=1;const{getFunctionName:e}=c(),{getParentAssignmentName:n}=l(),{buildMatcher:t}=x();const r={isDollarFunction:[/^\$[a-z_]/],isIgnoredFunction:[],isLexicalProvider:["parseEditorState","read","registerCommand","registerNodeTransform","update"],isSafeDollarFunction:[/^\$is[A-Z_]/]};function i(e){if(e)return"Identifier"===e.type?e:"MemberExpression"!==e.type||e.computed?void 0:i(e.property)}function s(e,n){const t=Array.isArray(e.options)?e.options[0]:void 0;return t&&n in t?t[n]:void 0}const a={oneOf:[{type:"string"},{contains:{type:"string"},type:"array"}]};return o.rulesOfLexical={create(o){const a=function(e){return e.sourceCode?e.sourceCode:e.getSourceCode()}(o),l=function(e){const n={};for(const i in r){const o=i;n[o]=t(r[o],s(e,o))}return n}(o),c=new Set,u=new Set,f=[],p=e=>c.add(e),d=e=>c.delete(e),g=t=>{const r=i(function(t){const r=e(t);if(r)return r;const o=t.parent;if(null!=o&&"CallExpression"===o.type&&o.arguments[0]===t&&function(e){return e&&"Identifier"===e.type&&/^use([A-Z]|$)/.test(e.name)}(i(o.callee)))return n(o)}(t));f.push({name:r,node:t}),(l.isDollarFunction(r)||l.isIgnoredFunction(r)||l.isLexicalProvider(r))&&p(t)},x=e=>{f.pop(),d(e)};return{ArrowFunctionExpression:g,"ArrowFunctionExpression:exit":x,CallExpression:e=>{if((()=>{if(c.size>0)return!0;const e=f[f.length-1];return e&&null!=e.node.parent&&"Property"===e.node.parent.type})())return;const n=i(e.callee);if(l.isLexicalProvider(n)||l.isSafeDollarFunction(n))return void p(e);if(!l.isDollarFunction(n))return;const t=(()=>{const e=f[f.length-1];return e?e.name:void 0})();if(!t||u.has(t))return;u.add(t);const r=function(e,n){const t=e.scopeManager;for(let e=n;e;e=e.parent){const r=t.getDeclaredVariables(e).find(e=>e.identifiers.includes(n));if(r)return r;const i=t.acquire(e);if(i)return i.set.get(n.name)||(i.upper?i.upper.set.get(n.name):void 0)}}(a,t),s=function(e,n){const t=function(e){return/^[a-z]/.test(e)?"$"+e:/^[A-Z][a-z]/.test(e)?"$"+e.slice(0,1).toLowerCase()+e.slice(1):`$_${e}`}(e.name);if(n)for(let e=n.scope;e;e=e.upper)if(e.set.has(t))return t+"_";return t}(t,r),d=function(e){if(e&&1===e.defs.length){const n=e.defs[0].node.parent;if(null!=n&&"ExportNamedDeclaration"===n.type)return n;if(null!=n&&"VariableDeclaration"===n.type&&null!=n.parent&&"ExportNamedDeclaration"===n.parent.type)return n.parent}}(r),g={callee:a.getText(e.callee),caller:a.getText(t),suggestName:s},x=e=>{const n=new Set,i=[],o=t=>{n.has(t)||(n.add(t),i.push(e.replaceText(t,s)))};if(o(t),d&&i.push(e.insertTextAfter(d,function({caller:e,suggestName:n}){return`\n/** @deprecated renamed to {@link ${n}} by @lexical/eslint-plugin rules-of-lexical */\nexport const ${e} = ${n};`}(g))),r)for(const e of r.references)o(e.identifier);return i};o.report({data:g,fix:x,messageId:"rulesOfLexicalReport",node:t,suggest:[{data:g,fix:x,messageId:"rulesOfLexicalSuggestion"}]})},"CallExpression:exit":d,ClassBody:p,"ClassBody:exit":d,FunctionDeclaration:g,"FunctionDeclaration:exit":x,FunctionExpression:g,"FunctionExpression:exit":x}},meta:{docs:{description:"enforces the Rules of Lexical",recommended:!0,url:"https://lexical.dev/docs/packages/lexical-eslint-plugin"},fixable:"code",hasSuggestions:!0,messages:{rulesOfLexicalReport:"{{ callee }} called from {{ caller }}, without $ prefix or read/update context",rulesOfLexicalSuggestion:"Rename {{ caller }} to {{ suggestName }}"},schema:[{additionalProperties:!1,properties:{isDollarFunction:a,isIgnoredFunction:a,isLexicalProvider:a,isSafeDollarFunction:a},type:"object"}],type:"suggestion"}},o}function y(){if(d)return p;d=1;const{name:e,version:n}=i,{rulesOfLexical:t}=m(),r={plugins:["@lexical"],rules:{"@lexical/rules-of-lexical":"warn"}},o={configs:{all:r,"flat/all":null,"flat/recommended":null,"legacy-all":r,"legacy-recommended":r,recommended:r},meta:{name:e,version:n},rules:{"rules-of-lexical":t}},s={plugins:{"@lexical":o},rules:{"@lexical/rules-of-lexical":"warn"}};return o.configs["flat/all"]=s,o.configs["flat/recommended"]=s,p=o}var h=y();const v=e({__proto__:null,default:n(h)},[h]);module.exports=v;

package/dist/LexicalEslintPlugin.prod.mjs

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+function e(e,n){for(var t=0;t<n.length;t++){var r=n[t];if("string"!=typeof r&&!Array.isArray(r))for(var i in r)"default"===i||i in e||(e[i]=r[i])}return e}function n(e){return e&&e.__esModule&&Object.prototype.hasOwnProperty.call(e,"default")?e.default:e}var t,r,i={name:"@lexical/eslint-plugin",version:"0.45.0"},o={},s={},a={};function l(){return t||(t=1,a.getParentAssignmentName=function(e){const n=e.parent;if(null!=n)return"VariableDeclarator"===n.type&&n.init===e?n.id:"AssignmentExpression"===n.type&&n.right===e&&"="===n.operator?n.left:void 0}),a}function c(){if(r)return s;r=1;const{getParentAssignmentName:e}=l();return s.getFunctionName=function(n){return"FunctionDeclaration"===n.type||"FunctionExpression"===n.type&&n.id?n.id:"FunctionExpression"===n.type||"ArrowFunctionExpression"===n.type?e(n):void 0},s}var u,f,p,d,g={};function x(){if(u)return g;function e(e){return e.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}return u=1,g.buildMatcher=function(...n){const t=[],r=[];for(const i of n.flat(1))i&&("string"==typeof i?r.push(/^[(^]/.test(i)?i:`^${e(i)}$`):i&&i instanceof RegExp?i.flags?t.push(e=>i.test(e)):r.push(i.source):"function"==typeof i&&t.push(i));const i=r.map(e=>`(?:${e})`).join("|");if(i){const e=new RegExp(i);t.push(n=>e.test(n))}return e=>{if(e){if("Identifier"!==e.type)throw new Error(`Expecting Identifier, not ${e.type}`);for(const n of t)if(n(e.name,e))return!0}return!1}},g}function m(){if(f)return o;f=1;const{getFunctionName:e}=c(),{getParentAssignmentName:n}=l(),{buildMatcher:t}=x();const r={isDollarFunction:[/^\$[a-z_]/],isIgnoredFunction:[],isLexicalProvider:["parseEditorState","read","registerCommand","registerNodeTransform","update"],isSafeDollarFunction:[/^\$is[A-Z_]/]};function i(e){if(e)return"Identifier"===e.type?e:"MemberExpression"!==e.type||e.computed?void 0:i(e.property)}function s(e,n){const t=Array.isArray(e.options)?e.options[0]:void 0;return t&&n in t?t[n]:void 0}const a={oneOf:[{type:"string"},{contains:{type:"string"},type:"array"}]};return o.rulesOfLexical={create(o){const a=function(e){return e.sourceCode?e.sourceCode:e.getSourceCode()}(o),l=function(e){const n={};for(const i in r){const o=i;n[o]=t(r[o],s(e,o))}return n}(o),c=new Set,u=new Set,f=[],p=e=>c.add(e),d=e=>c.delete(e),g=t=>{const r=i(function(t){const r=e(t);if(r)return r;const o=t.parent;if(null!=o&&"CallExpression"===o.type&&o.arguments[0]===t&&function(e){return e&&"Identifier"===e.type&&/^use([A-Z]|$)/.test(e.name)}(i(o.callee)))return n(o)}(t));f.push({name:r,node:t}),(l.isDollarFunction(r)||l.isIgnoredFunction(r)||l.isLexicalProvider(r))&&p(t)},x=e=>{f.pop(),d(e)};return{ArrowFunctionExpression:g,"ArrowFunctionExpression:exit":x,CallExpression:e=>{if((()=>{if(c.size>0)return!0;const e=f[f.length-1];return e&&null!=e.node.parent&&"Property"===e.node.parent.type})())return;const n=i(e.callee);if(l.isLexicalProvider(n)||l.isSafeDollarFunction(n))return void p(e);if(!l.isDollarFunction(n))return;const t=(()=>{const e=f[f.length-1];return e?e.name:void 0})();if(!t||u.has(t))return;u.add(t);const r=function(e,n){const t=e.scopeManager;for(let e=n;e;e=e.parent){const r=t.getDeclaredVariables(e).find(e=>e.identifiers.includes(n));if(r)return r;const i=t.acquire(e);if(i)return i.set.get(n.name)||(i.upper?i.upper.set.get(n.name):void 0)}}(a,t),s=function(e,n){const t=function(e){return/^[a-z]/.test(e)?"$"+e:/^[A-Z][a-z]/.test(e)?"$"+e.slice(0,1).toLowerCase()+e.slice(1):`$_${e}`}(e.name);if(n)for(let e=n.scope;e;e=e.upper)if(e.set.has(t))return t+"_";return t}(t,r),d=function(e){if(e&&1===e.defs.length){const n=e.defs[0].node.parent;if(null!=n&&"ExportNamedDeclaration"===n.type)return n;if(null!=n&&"VariableDeclaration"===n.type&&null!=n.parent&&"ExportNamedDeclaration"===n.parent.type)return n.parent}}(r),g={callee:a.getText(e.callee),caller:a.getText(t),suggestName:s},x=e=>{const n=new Set,i=[],o=t=>{n.has(t)||(n.add(t),i.push(e.replaceText(t,s)))};if(o(t),d&&i.push(e.insertTextAfter(d,function({caller:e,suggestName:n}){return`\n/** @deprecated renamed to {@link ${n}} by @lexical/eslint-plugin rules-of-lexical */\nexport const ${e} = ${n};`}(g))),r)for(const e of r.references)o(e.identifier);return i};o.report({data:g,fix:x,messageId:"rulesOfLexicalReport",node:t,suggest:[{data:g,fix:x,messageId:"rulesOfLexicalSuggestion"}]})},"CallExpression:exit":d,ClassBody:p,"ClassBody:exit":d,FunctionDeclaration:g,"FunctionDeclaration:exit":x,FunctionExpression:g,"FunctionExpression:exit":x}},meta:{docs:{description:"enforces the Rules of Lexical",recommended:!0,url:"https://lexical.dev/docs/packages/lexical-eslint-plugin"},fixable:"code",hasSuggestions:!0,messages:{rulesOfLexicalReport:"{{ callee }} called from {{ caller }}, without $ prefix or read/update context",rulesOfLexicalSuggestion:"Rename {{ caller }} to {{ suggestName }}"},schema:[{additionalProperties:!1,properties:{isDollarFunction:a,isIgnoredFunction:a,isLexicalProvider:a,isSafeDollarFunction:a},type:"object"}],type:"suggestion"}},o}function y(){if(d)return p;d=1;const{name:e,version:n}=i,{rulesOfLexical:t}=m(),r={plugins:["@lexical"],rules:{"@lexical/rules-of-lexical":"warn"}},o={configs:{all:r,"flat/all":null,"flat/recommended":null,"legacy-all":r,"legacy-recommended":r,recommended:r},meta:{name:e,version:n},rules:{"rules-of-lexical":t}},s={plugins:{"@lexical":o},rules:{"@lexical/rules-of-lexical":"warn"}};return o.configs["flat/all"]=s,o.configs["flat/recommended"]=s,p=o}var h=y();const v=e({__proto__:null,default:n(h)},[h]);export{v as default};

package/package.json

@@ -8,15 +8,15 @@
     "lexical",
     "editor"
   ],
-  "version": "0.44.1-nightly.20260519.0",
+  "version": "0.45.0",
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/facebook/lexical.git",
     "directory": "packages/lexical-eslint-plugin"
   },
-  "main": "LexicalEslintPlugin.js",
-  "types": "index.d.ts",
+  "main": "./dist/LexicalEslintPlugin.js",
+  "types": "./dist/index.d.ts",
   "bugs": {
     "url": "https://github.com/facebook/lexical/issues"
   },
@@ -27,18 +27,19 @@
   },
   "exports": {
     ".": {
+      "source": "./src/index.ts",
       "import": {
-        "types": "./index.d.ts",
-        "development": "./LexicalEslintPlugin.dev.mjs",
-        "production": "./LexicalEslintPlugin.prod.mjs",
-        "node": "./LexicalEslintPlugin.node.mjs",
-        "default": "./LexicalEslintPlugin.mjs"
+        "types": "./dist/index.d.ts",
+        "development": "./dist/LexicalEslintPlugin.dev.mjs",
+        "production": "./dist/LexicalEslintPlugin.prod.mjs",
+        "node": "./dist/LexicalEslintPlugin.node.mjs",
+        "default": "./dist/LexicalEslintPlugin.mjs"
       },
       "require": {
-        "types": "./index.d.ts",
-        "development": "./LexicalEslintPlugin.dev.js",
-        "production": "./LexicalEslintPlugin.prod.js",
-        "default": "./LexicalEslintPlugin.js"
+        "types": "./dist/index.d.ts",
+        "development": "./dist/LexicalEslintPlugin.dev.js",
+        "production": "./dist/LexicalEslintPlugin.prod.js",
+        "default": "./dist/LexicalEslintPlugin.js"
       }
     }
   },
@@ -46,5 +47,18 @@
     "@types/eslint": "^9.6.1",
     "@types/estree": "^1.0.6"
   },
-  "module": "LexicalEslintPlugin.mjs"
+  "module": "./dist/LexicalEslintPlugin.mjs",
+  "files": [
+    "dist",
+    "src",
+    "!src/__tests__",
+    "!src/__bench__",
+    "!src/__mocks__",
+    "!src/**/*.test.ts",
+    "!src/**/*.test.tsx",
+    "!src/**/*.bench.ts",
+    "!src/**/*.bench.tsx",
+    "README.md",
+    "LICENSE"
+  ]
 }

package/src/LexicalEslintPlugin.js

@@ -0,0 +1,53 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+// @ts-check
+
+const {name, version} = require('../package.json');
+const {rulesOfLexical} = require('./rules/rules-of-lexical.js');
+
+// Legacy config format (ESLint 7-8)
+const legacyAll = {
+  plugins: ['@lexical'],
+  rules: {
+    '@lexical/rules-of-lexical': /** @type {'warn'|'error'|'off'}*/ ('warn'),
+  },
+};
+
+const plugin = {
+  configs: {
+    // Legacy configs (ESLint 7-8) - available under multiple names for compatibility
+    all: legacyAll,
+    // Flat configs (ESLint 9-10+) - placeholders, will be set below
+    'flat/all': /** @type {any} */ (null),
+    'flat/recommended': /** @type {any} */ (null),
+    'legacy-all': legacyAll,
+    'legacy-recommended': legacyAll,
+    recommended: legacyAll,
+  },
+  meta: {name, version},
+  rules: {
+    'rules-of-lexical': rulesOfLexical,
+  },
+};
+
+// Flat config format (ESLint 9-10+)
+// Must be created after plugin is defined to avoid circular reference
+const flatAll = {
+  plugins: {
+    '@lexical': plugin,
+  },
+  rules: {
+    '@lexical/rules-of-lexical': 'warn' /** @type {'warn'|'error'|'off'}*/,
+  },
+};
+
+plugin.configs['flat/all'] = flatAll;
+plugin.configs['flat/recommended'] = flatAll;
+
+module.exports = plugin;

package/src/index.ts

@@ -0,0 +1,61 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+/**
+ * For bootstrapping reasons, this module is written in CJS JavaScript so no
+ * compilation is necessary
+ */
+
+import type {Rule} from 'eslint';
+
+import * as jsPlugin from './LexicalEslintPlugin.js';
+
+export type {RulesOfLexicalOptions} from './rules/rules-of-lexical.js';
+
+// Legacy config format (ESLint 7-8)
+export interface LegacyConfig {
+  plugins: string[];
+  rules: {
+    '@lexical/rules-of-lexical': 'warn' | 'error' | 'off';
+  };
+}
+
+// Flat config format (ESLint 9-10+)
+export interface FlatConfig {
+  plugins: {
+    '@lexical': Plugin;
+  };
+  rules: {
+    '@lexical/rules-of-lexical': 'warn' | 'error' | 'off';
+  };
+}
+
+export interface Plugin {
+  meta: {
+    name: string;
+    version: string;
+  };
+  rules: {
+    'rules-of-lexical': Rule.RuleModule;
+  };
+  configs: {
+    // Legacy configs (ESLint 7-8) - available under multiple names
+    all: LegacyConfig;
+    'legacy-all': LegacyConfig;
+    'legacy-recommended': LegacyConfig;
+    recommended: LegacyConfig;
+    // Flat configs (ESLint 9-10+)
+    'flat/all': FlatConfig;
+    'flat/recommended': FlatConfig;
+  };
+}
+
+const plugin: Plugin = jsPlugin;
+
+// eslint-disable-next-line no-restricted-exports
+export default plugin;

package/src/rules/rules-of-lexical.js

@@ -0,0 +1,431 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+// @ts-check
+
+const {getFunctionName} = require('../util/getFunctionName.js');
+const {getParentAssignmentName} = require('../util/getParentAssignmentName.js');
+const {buildMatcher} = require('../util/buildMatcher.js');
+
+/**
+ * @typedef {import('eslint').Rule.NodeParentExtension} NodeParentExtension
+ * @typedef {import('estree').CallExpression & NodeParentExtension} CallExpression
+ * @typedef {import('estree').Identifier & NodeParentExtension} Identifier
+ * @typedef {import('eslint').Rule.RuleContext} RuleContext
+ * @typedef {import('eslint').Rule.Fix} Fix
+ * @typedef {import('eslint').Rule.Node} Node
+ * @typedef {import('eslint').Rule.RuleModule} RuleModule
+ * @typedef {import('eslint').Rule.ReportFixer} ReportFixer
+ * @typedef {import('eslint').SourceCode} SourceCode
+ * @typedef {import('eslint').Scope.Variable} Variable
+ * @typedef {import('eslint').Scope.Scope} Scope
+ */
+
+/**
+ * Find the variable associated with the given Identifier
+ *
+ * @param {SourceCode} sourceCode
+ * @param {Identifier} identifier
+ */
+function getIdentifierVariable(sourceCode, identifier) {
+  const scopeManager = sourceCode.scopeManager;
+  for (
+    let node = /** @type {Node | null} */ (identifier);
+    node;
+    node = /** @type {Node | null}*/ (node.parent)
+  ) {
+    const variable = scopeManager
+      .getDeclaredVariables(node)
+      .find(v => v.identifiers.includes(identifier));
+    if (variable) {
+      return variable;
+    }
+    const scope = scopeManager.acquire(node);
+    if (scope) {
+      return (
+        scope.set.get(identifier.name) ||
+        (scope.upper ? scope.upper.set.get(identifier.name) : undefined)
+      );
+    }
+  }
+  return undefined;
+}
+
+/**
+ * @typedef {import('../util/buildMatcher.js').ToMatcher} ToMatcher
+ * @typedef {import('../util/buildMatcher.js').IdentifierMatcher} IdentifierMatcher
+ */
+
+/**
+ * @template T
+ * @typedef {Object} BaseMatchers<T>
+ * @property {T} isDollarFunction Catch all identifiers that begin with '$' or 'INTERNAL_$' followed by a lowercase Latin character or underscore
+ * @property {T} isIgnoredFunction These functions may call any $functions even though they do not have the isDollarFunction naming convention
+ * @property {T} isLexicalProvider Certain calls through the editor or editorState allow for implicit access to call $functions: read, registerCommand, registerNodeTransform, update.
+ * @property {T} isSafeDollarFunction It's usually safe to call $isNode functions, so any '$is' or 'INTERNAL_$is' function may be called in any context.
+ */
+
+/** @type {BaseMatchers<Exclude<ToMatcher, undefined>[]>} */
+const BaseMatchers = {
+  isDollarFunction: [/^\$[a-z_]/],
+  isIgnoredFunction: [],
+  isLexicalProvider: [
+    'parseEditorState',
+    'read',
+    'registerCommand',
+    'registerNodeTransform',
+    'update',
+  ],
+  isSafeDollarFunction: [/^\$is[A-Z_]/],
+};
+
+/**
+ * @typedef {Partial<BaseMatchers<ToMatcher | ToMatcher[]>>} RulesOfLexicalOptions
+ * @typedef {BaseMatchers<IdentifierMatcher>} Matchers
+ */
+
+/**
+ * @param {RuleContext} context
+ * @returns {Matchers}
+ */
+function compileMatchers(context) {
+  const rval = /** @type {Matchers} */ ({});
+  for (const k_ in BaseMatchers) {
+    const k = /** @type {keyof Matchers} */ (k_);
+    rval[k] = buildMatcher(BaseMatchers[k], parseMatcherOption(context, k));
+  }
+  return rval;
+}
+
+/**
+ * Hook functions start with use followed by a capital latin letter.
+ *
+ * @param {Node | undefined} node
+ */
+function isHookFunctionIdentifier(node) {
+  return node && node.type === 'Identifier' && /^use([A-Z]|$)/.test(node.name);
+}
+
+/**
+ * Return this node if is an Identifier, otherwise if it is a MemberExpression such as
+ * `editor.read` return the Identifier of its property ('read' in this case).
+ *
+ * @param {Node | undefined} node
+ * @returns {Identifier | undefined}
+ */
+function getFunctionNameIdentifier(node) {
+  if (!node) {
+    return;
+  } else if (node.type === 'Identifier') {
+    return node;
+  } else if (node.type === 'MemberExpression' && !node.computed) {
+    return getFunctionNameIdentifier(/** @type {Node} */ (node.property));
+  }
+}
+
+/**
+ * Get the function's name, or if it is defined with a hook
+ * (e.g. useMemo, useCallback), then get the name of the variable the result
+ * is assigned to.
+ *
+ * @param {Node} node
+ */
+function getLexicalFunctionName(node) {
+  const name = getFunctionName(node);
+  if (name) {
+    return name;
+  }
+  const nodeParent = node.parent;
+  if (
+    nodeParent != null &&
+    nodeParent.type === 'CallExpression' &&
+    nodeParent.arguments[0] === node
+  ) {
+    const parentName = getFunctionNameIdentifier(
+      /** @type {Node} */ (nodeParent.callee),
+    );
+    if (isHookFunctionIdentifier(parentName)) {
+      return getParentAssignmentName(/** @type {Node} */ (nodeParent));
+    }
+  }
+}
+
+/**
+ * Return a name suitable for a suggestion.
+ * isDollarFunction(getFirstSuggestion(name)) should
+ * be true for any given name.
+ *
+ * @param {string} name
+ * @returns {string}
+ */
+function getFirstSuggestion(name) {
+  if (/^[a-z]/.test(name)) {
+    return '$' + name;
+  } else if (/^[A-Z][a-z]/.test(name)) {
+    return '$' + name.slice(0, 1).toLowerCase() + name.slice(1);
+  } else {
+    return `$_${name}`;
+  }
+}
+
+/**
+ * Get the suggested name for a variable and add an underscore if it shadows
+ * or conflicts with an existing variable.
+ *
+ * @param {Identifier} nameIdentifier
+ * @param {Variable | undefined} variable
+ */
+function getSuggestName(nameIdentifier, variable) {
+  const suggestName = getFirstSuggestion(nameIdentifier.name);
+  // Add an underscore if this would shadow an existing name
+  if (variable) {
+    for (
+      let scope = /** @type {Scope | null} */ (variable.scope);
+      scope;
+      scope = scope.upper
+    ) {
+      if (scope.set.has(suggestName)) {
+        return suggestName + '_';
+      }
+    }
+  }
+  return suggestName;
+}
+
+/**
+ * Get the export declaration for a variable, if it has one.
+ *
+ * @param {Variable | undefined} variable
+ */
+function getExportDeclaration(variable) {
+  if (variable && variable.defs.length === 1) {
+    const defNode = /** @type {Node} */ (variable.defs[0].node);
+    const defParent = defNode.parent;
+    if (defParent != null && defParent.type === 'ExportNamedDeclaration') {
+      // export function foo();
+      return defParent;
+    } else if (
+      defParent != null &&
+      defParent.type === 'VariableDeclaration' &&
+      defParent.parent != null &&
+      defParent.parent.type === 'ExportNamedDeclaration'
+    ) {
+      // export const foo = () => {};
+      return defParent.parent;
+    }
+  }
+}
+
+/**
+ * The comment we insert when an export is renamed.
+ *
+ * @param {Record<'caller'|'suggestName', string>} data
+ */
+function renameExportText({caller, suggestName}) {
+  return `\n/** @deprecated renamed to {@link ${suggestName}} by @lexical/eslint-plugin rules-of-lexical */\nexport const ${caller} = ${suggestName};`;
+}
+
+/**
+ * @param {RuleContext} context
+ * @param {string} optionName
+ * @returns {ToMatcher}
+ */
+function parseMatcherOption(context, optionName) {
+  const options = Array.isArray(context.options)
+    ? context.options[0]
+    : undefined;
+  return options && optionName in options ? options[optionName] : undefined;
+}
+
+/** @param {RuleContext} context */
+function getSourceCode(context) {
+  if (context.sourceCode) {
+    return context.sourceCode;
+  }
+  // @ts-expect-error -- getSourceCode() removed from types in ESLint 10, kept for ESLint 8 compat
+  return context.getSourceCode();
+}
+
+const matcherSchema = {
+  oneOf: [{type: 'string'}, {contains: {type: 'string'}, type: 'array'}],
+};
+
+/** @type {RuleModule} */
+module.exports.rulesOfLexical = {
+  create(context) {
+    const sourceCode = getSourceCode(context);
+    const matchers = compileMatchers(context);
+
+    /**
+     * When this set is non-empty it means that we are visiting a node
+     * that should not be analyzed.
+     *
+     * @type {Set<Node>}
+     */
+    const ignoreSet = new Set();
+    /**
+     * The set of Identifier nodes that have been reported, we do not
+     * want to report the same node more than once (a function making several
+     * calls to $functions only needs to be renamed once!)
+     *
+     * @type {Set<Identifier>}
+     */
+    const reportedSet = new Set();
+    /**
+     * The current stack of functions
+     *
+     * @type {{ name?: Identifier, node: Node }[]} funStack
+     */
+    const funStack = [];
+    const shouldIgnore = () => {
+      if (ignoreSet.size > 0) {
+        return true;
+      }
+      // Ignore property assignments
+      const lastFunction = funStack[funStack.length - 1];
+      return (
+        lastFunction &&
+        lastFunction.node.parent != null &&
+        lastFunction.node.parent.type === 'Property'
+      );
+    };
+    const pushIgnoredNode = (/** @type {Node} */ node) => ignoreSet.add(node);
+    const popIgnoredNode = (/** @type {Node} */ node) => ignoreSet.delete(node);
+    const pushFunction = (/** @type {Node} */ node) => {
+      const name = getFunctionNameIdentifier(
+        /** @type {Node | undefined} */ (getLexicalFunctionName(node)),
+      );
+      funStack.push({name, node});
+      if (
+        matchers.isDollarFunction(name) ||
+        matchers.isIgnoredFunction(name) ||
+        matchers.isLexicalProvider(name)
+      ) {
+        pushIgnoredNode(node);
+      }
+    };
+    const popFunction = (/** @type {Node} */ node) => {
+      funStack.pop();
+      popIgnoredNode(node);
+    };
+    const getParentLexicalFunctionNameIdentifier = (
+      /** @type {Node} */ _node,
+    ) => {
+      const pair = funStack[funStack.length - 1];
+      return pair ? pair.name : undefined;
+    };
+    // Find all $function calls that are not inside a class or inside a $function
+    // by visiting all function definitions and calls
+    return {
+      ArrowFunctionExpression: pushFunction,
+      'ArrowFunctionExpression:exit': popFunction,
+      CallExpression: node => {
+        if (shouldIgnore()) {
+          return;
+        }
+        const calleeName = getFunctionNameIdentifier(
+          /** @type {Node} */ (node.callee),
+        );
+        if (
+          matchers.isLexicalProvider(calleeName) ||
+          matchers.isSafeDollarFunction(calleeName)
+        ) {
+          pushIgnoredNode(node);
+          return;
+        }
+        if (!matchers.isDollarFunction(calleeName)) {
+          return;
+        }
+        const nameIdentifier = getParentLexicalFunctionNameIdentifier(node);
+        if (!nameIdentifier || reportedSet.has(nameIdentifier)) {
+          return;
+        }
+        reportedSet.add(nameIdentifier);
+        const variable = getIdentifierVariable(sourceCode, nameIdentifier);
+        const suggestName = getSuggestName(nameIdentifier, variable);
+        const exportDeclaration = getExportDeclaration(variable);
+        const data = {
+          callee: sourceCode.getText(node.callee),
+          caller: sourceCode.getText(nameIdentifier),
+          suggestName,
+        };
+        /** @type {ReportFixer} */
+        const fix = fixer => {
+          /** @type {Set<Identifier>} */
+          const replaced = new Set();
+          /** @type {Fix[]} */
+          const fixes = [];
+          const renameIdentifier = (/** @type {Identifier} */ identifier) => {
+            if (!replaced.has(identifier)) {
+              replaced.add(identifier);
+              fixes.push(fixer.replaceText(identifier, suggestName));
+            }
+          };
+          renameIdentifier(nameIdentifier);
+          if (exportDeclaration) {
+            fixes.push(
+              fixer.insertTextAfter(exportDeclaration, renameExportText(data)),
+            );
+          }
+          if (variable) {
+            for (const ref of variable.references) {
+              renameIdentifier(/** @type {Identifier} */ (ref.identifier));
+            }
+          }
+          return fixes;
+        };
+        context.report({
+          data,
+          fix,
+          messageId: 'rulesOfLexicalReport',
+          node: nameIdentifier,
+          suggest: [
+            {
+              data,
+              fix,
+              messageId: 'rulesOfLexicalSuggestion',
+            },
+          ],
+        });
+      },
+      'CallExpression:exit': popIgnoredNode,
+      ClassBody: pushIgnoredNode,
+      'ClassBody:exit': popIgnoredNode,
+      FunctionDeclaration: pushFunction,
+      'FunctionDeclaration:exit': popFunction,
+      FunctionExpression: pushFunction,
+      'FunctionExpression:exit': popFunction,
+    };
+  },
+  meta: {
+    docs: {
+      description: 'enforces the Rules of Lexical',
+      recommended: true,
+      url: 'https://lexical.dev/docs/packages/lexical-eslint-plugin',
+    },
+    fixable: 'code',
+    hasSuggestions: true,
+    messages: {
+      rulesOfLexicalReport:
+        '{{ callee }} called from {{ caller }}, without $ prefix or read/update context',
+      rulesOfLexicalSuggestion: 'Rename {{ caller }} to {{ suggestName }}',
+    },
+    schema: [
+      {
+        additionalProperties: false,
+        properties: {
+          isDollarFunction: matcherSchema,
+          isIgnoredFunction: matcherSchema,
+          isLexicalProvider: matcherSchema,
+          isSafeDollarFunction: matcherSchema,
+        },
+        type: 'object',
+      },
+    ],
+    type: 'suggestion',
+  },
+};

package/src/util/buildMatcher.js

@@ -0,0 +1,77 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+
+/**
+ * @typedef {import('estree').Node} Node
+ * @typedef {import('estree').Identifier} Identifier
+ * @typedef {(name: string, node: Identifier) => boolean} NameIdentifierMatcher
+ * @typedef {NameIdentifierMatcher | string | RegExp | undefined} ToMatcher
+ * @typedef {(node: Identifier | undefined) => boolean} IdentifierMatcher
+ */
+
+/**
+ * Escape a string for exact match in a RegExp
+ * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_expressions#escaping
+ *
+ * @param {string} string
+ * @returns {string}
+ */
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'); // $& means the whole matched string
+}
+
+/**
+ * Build an Identifier Node Matcher from the given ToMatcher arguments.
+ * The Matcher is roughly equivalent to building RegExp from all of the
+ * sources and or-ing them together. String arguments are treated as
+ * RegExp sources and will be escaped with an implicit '^...$' wrapper
+ * unless it starts with a '(' or '^'
+ *
+ * @param {(ToMatcher | ToMatcher[])[]} args
+ * @returns {IdentifierMatcher}
+ */
+module.exports.buildMatcher = function buildMatcher(...toMatchers) {
+  /** @type {Matcher[]} */
+  const matchFuns = [];
+  /** @type {string[]} */
+  const regExpSources = [];
+  for (const arg of toMatchers.flat(1)) {
+    if (!arg) {
+      continue;
+    } else if (typeof arg === 'string') {
+      regExpSources.push(/^[(^]/.test(arg) ? arg : `^${escapeRegExp(arg)}$`);
+    } else if (arg && arg instanceof RegExp) {
+      if (arg.flags) {
+        matchFuns.push(s => arg.test(s));
+      } else {
+        regExpSources.push(arg.source);
+      }
+    } else if (typeof arg === 'function') {
+      matchFuns.push(arg);
+    }
+  }
+  const pattern = regExpSources.map(s => `(?:${s})`).join('|');
+  if (pattern) {
+    const re = new RegExp(pattern);
+    matchFuns.push(s => re.test(s));
+  }
+  return node => {
+    if (node) {
+      if (node.type !== 'Identifier') {
+        // Runtime type invariant check
+        throw new Error(`Expecting Identifier, not ${node.type}`);
+      }
+      for (const matcher of matchFuns) {
+        if (matcher(node.name, node)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  };
+};

package/src/util/getFunctionName.js

@@ -0,0 +1,43 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+// @ts-check
+
+const {getParentAssignmentName} = require('./getParentAssignmentName');
+
+/**
+ * Gets the static name of a function AST node. For function declarations it is
+ * easy. For anonymous function expressions it is much harder. If you search for
+ * `IsAnonymousFunctionDefinition()` in the ECMAScript spec you'll find places
+ * where JS gives anonymous function expressions names. We roughly detect the
+ * same AST nodes with some exceptions to better fit our use case.
+ *
+ * @param {import('eslint').Rule.Node} node
+ */
+module.exports.getFunctionName = function getFunctionName(node) {
+  if (
+    node.type === 'FunctionDeclaration' ||
+    (node.type === 'FunctionExpression' && node.id)
+  ) {
+    // function $function() {}
+    // const whatever = function $function() {};
+    //
+    // Function declaration or function expression names win over any
+    // assignment statements or other renames.
+    return node.id;
+  } else if (
+    node.type === 'FunctionExpression' ||
+    node.type === 'ArrowFunctionExpression'
+  ) {
+    // This checks for assignments such as
+    // const $function = function () {};
+    // const $function = () => {};
+    return getParentAssignmentName(node);
+  } else {
+    return undefined;
+  }
+};

package/src/util/getParentAssignmentName.js

@@ -0,0 +1,44 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+// @ts-check
+'use strict';
+
+/**
+ * Gets the static name of an AST node's parent, used to determine the name of an
+ * anonymous function declaration, possibly through a higher order function call.
+ * This was extracted from the body of getFunctionName so it could also be used
+ * in the context of `useCallback` or `useMemo`, e.g.
+ * `const $fun = useCallback(() => {}, [])` where the name is not the direct
+ * parent of the anonymous function.
+ *
+ * @param {import('eslint').Rule.Node} node
+ */
+module.exports.getParentAssignmentName = function getParentAssignmentName(
+  node,
+) {
+  // Unlike React's rules of hooks, this does not check property assignment.
+  // The rules of lexical $function convention only applies to functions,
+  // not methods or properties.
+  const parentNode = node.parent;
+  if (parentNode == null) {
+    return undefined;
+  }
+  if (parentNode.type === 'VariableDeclarator' && parentNode.init === node) {
+    // const $function = () => {};
+    return parentNode.id;
+  } else if (
+    parentNode.type === 'AssignmentExpression' &&
+    parentNode.right === node &&
+    parentNode.operator === '='
+  ) {
+    // $function = () => {};
+    return parentNode.left;
+  } else {
+    return undefined;
+  }
+};

package/LexicalEslintPlugin.prod.js

@@ -1,9 +0,0 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- */
-
-"use strict";function e(e,n){for(var t=0;t<n.length;t++){var r=n[t];if("string"!=typeof r&&!Array.isArray(r))for(var i in r)"default"===i||i in e||(e[i]=r[i])}return e}function n(e){return e&&e.__esModule&&Object.prototype.hasOwnProperty.call(e,"default")?e.default:e}var t,r,i={name:"@lexical/eslint-plugin",version:"0.44.1-nightly.20260519.0"},o={},s={},a={};function l(){return t||(t=1,a.getParentAssignmentName=function(e){const n=e.parent;if(null!=n)return"VariableDeclarator"===n.type&&n.init===e?n.id:"AssignmentExpression"===n.type&&n.right===e&&"="===n.operator?n.left:void 0}),a}function c(){if(r)return s;r=1;const{getParentAssignmentName:e}=l();return s.getFunctionName=function(n){return"FunctionDeclaration"===n.type||"FunctionExpression"===n.type&&n.id?n.id:"FunctionExpression"===n.type||"ArrowFunctionExpression"===n.type?e(n):void 0},s}var u,f,p,d,g={};function x(){if(u)return g;function e(e){return e.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}return u=1,g.buildMatcher=function(...n){const t=[],r=[];for(const i of n.flat(1))i&&("string"==typeof i?r.push(/^[(^]/.test(i)?i:`^${e(i)}$`):i&&i instanceof RegExp?i.flags?t.push(e=>i.test(e)):r.push(i.source):"function"==typeof i&&t.push(i));const i=r.map(e=>`(?:${e})`).join("|");if(i){const e=new RegExp(i);t.push(n=>e.test(n))}return e=>{if(e){if("Identifier"!==e.type)throw new Error(`Expecting Identifier, not ${e.type}`);for(const n of t)if(n(e.name,e))return!0}return!1}},g}function m(){if(f)return o;f=1;const{getFunctionName:e}=c(),{getParentAssignmentName:n}=l(),{buildMatcher:t}=x();const r={isDollarFunction:[/^\$[a-z_]/],isIgnoredFunction:[],isLexicalProvider:["parseEditorState","read","registerCommand","registerNodeTransform","update"],isSafeDollarFunction:[/^\$is[A-Z_]/]};function i(e){if(e)return"Identifier"===e.type?e:"MemberExpression"!==e.type||e.computed?void 0:i(e.property)}function s(e,n){const t=Array.isArray(e.options)?e.options[0]:void 0;return t&&n in t?t[n]:void 0}const a={oneOf:[{type:"string"},{contains:{type:"string"},type:"array"}]};return o.rulesOfLexical={create(o){const a=function(e){return e.sourceCode?e.sourceCode:e.getSourceCode()}(o),l=function(e){const n={};for(const i in r){const o=i;n[o]=t(r[o],s(e,o))}return n}(o),c=new Set,u=new Set,f=[],p=e=>c.add(e),d=e=>c.delete(e),g=t=>{const r=i(function(t){const r=e(t);if(r)return r;const o=t.parent;if(null!=o&&"CallExpression"===o.type&&o.arguments[0]===t&&function(e){return e&&"Identifier"===e.type&&/^use([A-Z]|$)/.test(e.name)}(i(o.callee)))return n(o)}(t));f.push({name:r,node:t}),(l.isDollarFunction(r)||l.isIgnoredFunction(r)||l.isLexicalProvider(r))&&p(t)},x=e=>{f.pop(),d(e)};return{ArrowFunctionExpression:g,"ArrowFunctionExpression:exit":x,CallExpression:e=>{if((()=>{if(c.size>0)return!0;const e=f[f.length-1];return e&&null!=e.node.parent&&"Property"===e.node.parent.type})())return;const n=i(e.callee);if(l.isLexicalProvider(n)||l.isSafeDollarFunction(n))return void p(e);if(!l.isDollarFunction(n))return;const t=(()=>{const e=f[f.length-1];return e?e.name:void 0})();if(!t||u.has(t))return;u.add(t);const r=function(e,n){const t=e.scopeManager;for(let e=n;e;e=e.parent){const r=t.getDeclaredVariables(e).find(e=>e.identifiers.includes(n));if(r)return r;const i=t.acquire(e);if(i)return i.set.get(n.name)||(i.upper?i.upper.set.get(n.name):void 0)}}(a,t),s=function(e,n){const t=function(e){return/^[a-z]/.test(e)?"$"+e:/^[A-Z][a-z]/.test(e)?"$"+e.slice(0,1).toLowerCase()+e.slice(1):`$_${e}`}(e.name);if(n)for(let e=n.scope;e;e=e.upper)if(e.set.has(t))return t+"_";return t}(t,r),d=function(e){if(e&&1===e.defs.length){const n=e.defs[0].node.parent;if(null!=n&&"ExportNamedDeclaration"===n.type)return n;if(null!=n&&"VariableDeclaration"===n.type&&null!=n.parent&&"ExportNamedDeclaration"===n.parent.type)return n.parent}}(r),g={callee:a.getText(e.callee),caller:a.getText(t),suggestName:s},x=e=>{const n=new Set,i=[],o=t=>{n.has(t)||(n.add(t),i.push(e.replaceText(t,s)))};if(o(t),d&&i.push(e.insertTextAfter(d,function({caller:e,suggestName:n}){return`\n/** @deprecated renamed to {@link ${n}} by @lexical/eslint-plugin rules-of-lexical */\nexport const ${e} = ${n};`}(g))),r)for(const e of r.references)o(e.identifier);return i};o.report({data:g,fix:x,messageId:"rulesOfLexicalReport",node:t,suggest:[{data:g,fix:x,messageId:"rulesOfLexicalSuggestion"}]})},"CallExpression:exit":d,ClassBody:p,"ClassBody:exit":d,FunctionDeclaration:g,"FunctionDeclaration:exit":x,FunctionExpression:g,"FunctionExpression:exit":x}},meta:{docs:{description:"enforces the Rules of Lexical",recommended:!0,url:"https://lexical.dev/docs/packages/lexical-eslint-plugin"},fixable:"code",hasSuggestions:!0,messages:{rulesOfLexicalReport:"{{ callee }} called from {{ caller }}, without $ prefix or read/update context",rulesOfLexicalSuggestion:"Rename {{ caller }} to {{ suggestName }}"},schema:[{additionalProperties:!1,properties:{isDollarFunction:a,isIgnoredFunction:a,isLexicalProvider:a,isSafeDollarFunction:a},type:"object"}],type:"suggestion"}},o}function y(){if(d)return p;d=1;const{name:e,version:n}=i,{rulesOfLexical:t}=m(),r={plugins:["@lexical"],rules:{"@lexical/rules-of-lexical":"warn"}},o={configs:{all:r,"flat/all":null,"flat/recommended":null,"legacy-all":r,"legacy-recommended":r,recommended:r},meta:{name:e,version:n},rules:{"rules-of-lexical":t}},s={plugins:{"@lexical":o},rules:{"@lexical/rules-of-lexical":"warn"}};return o.configs["flat/all"]=s,o.configs["flat/recommended"]=s,p=o}var h=y();const v=e({__proto__:null,default:n(h)},[h]);module.exports=v;

package/LexicalEslintPlugin.prod.mjs

@@ -1,9 +0,0 @@
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- */
-
-function e(e,n){for(var t=0;t<n.length;t++){var r=n[t];if("string"!=typeof r&&!Array.isArray(r))for(var i in r)"default"===i||i in e||(e[i]=r[i])}return e}function n(e){return e&&e.__esModule&&Object.prototype.hasOwnProperty.call(e,"default")?e.default:e}var t,r,i={name:"@lexical/eslint-plugin",version:"0.44.1-nightly.20260519.0"},o={},s={},a={};function l(){return t||(t=1,a.getParentAssignmentName=function(e){const n=e.parent;if(null!=n)return"VariableDeclarator"===n.type&&n.init===e?n.id:"AssignmentExpression"===n.type&&n.right===e&&"="===n.operator?n.left:void 0}),a}function c(){if(r)return s;r=1;const{getParentAssignmentName:e}=l();return s.getFunctionName=function(n){return"FunctionDeclaration"===n.type||"FunctionExpression"===n.type&&n.id?n.id:"FunctionExpression"===n.type||"ArrowFunctionExpression"===n.type?e(n):void 0},s}var u,f,p,d,g={};function x(){if(u)return g;function e(e){return e.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}return u=1,g.buildMatcher=function(...n){const t=[],r=[];for(const i of n.flat(1))i&&("string"==typeof i?r.push(/^[(^]/.test(i)?i:`^${e(i)}$`):i&&i instanceof RegExp?i.flags?t.push(e=>i.test(e)):r.push(i.source):"function"==typeof i&&t.push(i));const i=r.map(e=>`(?:${e})`).join("|");if(i){const e=new RegExp(i);t.push(n=>e.test(n))}return e=>{if(e){if("Identifier"!==e.type)throw new Error(`Expecting Identifier, not ${e.type}`);for(const n of t)if(n(e.name,e))return!0}return!1}},g}function m(){if(f)return o;f=1;const{getFunctionName:e}=c(),{getParentAssignmentName:n}=l(),{buildMatcher:t}=x();const r={isDollarFunction:[/^\$[a-z_]/],isIgnoredFunction:[],isLexicalProvider:["parseEditorState","read","registerCommand","registerNodeTransform","update"],isSafeDollarFunction:[/^\$is[A-Z_]/]};function i(e){if(e)return"Identifier"===e.type?e:"MemberExpression"!==e.type||e.computed?void 0:i(e.property)}function s(e,n){const t=Array.isArray(e.options)?e.options[0]:void 0;return t&&n in t?t[n]:void 0}const a={oneOf:[{type:"string"},{contains:{type:"string"},type:"array"}]};return o.rulesOfLexical={create(o){const a=function(e){return e.sourceCode?e.sourceCode:e.getSourceCode()}(o),l=function(e){const n={};for(const i in r){const o=i;n[o]=t(r[o],s(e,o))}return n}(o),c=new Set,u=new Set,f=[],p=e=>c.add(e),d=e=>c.delete(e),g=t=>{const r=i(function(t){const r=e(t);if(r)return r;const o=t.parent;if(null!=o&&"CallExpression"===o.type&&o.arguments[0]===t&&function(e){return e&&"Identifier"===e.type&&/^use([A-Z]|$)/.test(e.name)}(i(o.callee)))return n(o)}(t));f.push({name:r,node:t}),(l.isDollarFunction(r)||l.isIgnoredFunction(r)||l.isLexicalProvider(r))&&p(t)},x=e=>{f.pop(),d(e)};return{ArrowFunctionExpression:g,"ArrowFunctionExpression:exit":x,CallExpression:e=>{if((()=>{if(c.size>0)return!0;const e=f[f.length-1];return e&&null!=e.node.parent&&"Property"===e.node.parent.type})())return;const n=i(e.callee);if(l.isLexicalProvider(n)||l.isSafeDollarFunction(n))return void p(e);if(!l.isDollarFunction(n))return;const t=(()=>{const e=f[f.length-1];return e?e.name:void 0})();if(!t||u.has(t))return;u.add(t);const r=function(e,n){const t=e.scopeManager;for(let e=n;e;e=e.parent){const r=t.getDeclaredVariables(e).find(e=>e.identifiers.includes(n));if(r)return r;const i=t.acquire(e);if(i)return i.set.get(n.name)||(i.upper?i.upper.set.get(n.name):void 0)}}(a,t),s=function(e,n){const t=function(e){return/^[a-z]/.test(e)?"$"+e:/^[A-Z][a-z]/.test(e)?"$"+e.slice(0,1).toLowerCase()+e.slice(1):`$_${e}`}(e.name);if(n)for(let e=n.scope;e;e=e.upper)if(e.set.has(t))return t+"_";return t}(t,r),d=function(e){if(e&&1===e.defs.length){const n=e.defs[0].node.parent;if(null!=n&&"ExportNamedDeclaration"===n.type)return n;if(null!=n&&"VariableDeclaration"===n.type&&null!=n.parent&&"ExportNamedDeclaration"===n.parent.type)return n.parent}}(r),g={callee:a.getText(e.callee),caller:a.getText(t),suggestName:s},x=e=>{const n=new Set,i=[],o=t=>{n.has(t)||(n.add(t),i.push(e.replaceText(t,s)))};if(o(t),d&&i.push(e.insertTextAfter(d,function({caller:e,suggestName:n}){return`\n/** @deprecated renamed to {@link ${n}} by @lexical/eslint-plugin rules-of-lexical */\nexport const ${e} = ${n};`}(g))),r)for(const e of r.references)o(e.identifier);return i};o.report({data:g,fix:x,messageId:"rulesOfLexicalReport",node:t,suggest:[{data:g,fix:x,messageId:"rulesOfLexicalSuggestion"}]})},"CallExpression:exit":d,ClassBody:p,"ClassBody:exit":d,FunctionDeclaration:g,"FunctionDeclaration:exit":x,FunctionExpression:g,"FunctionExpression:exit":x}},meta:{docs:{description:"enforces the Rules of Lexical",recommended:!0,url:"https://lexical.dev/docs/packages/lexical-eslint-plugin"},fixable:"code",hasSuggestions:!0,messages:{rulesOfLexicalReport:"{{ callee }} called from {{ caller }}, without $ prefix or read/update context",rulesOfLexicalSuggestion:"Rename {{ caller }} to {{ suggestName }}"},schema:[{additionalProperties:!1,properties:{isDollarFunction:a,isIgnoredFunction:a,isLexicalProvider:a,isSafeDollarFunction:a},type:"object"}],type:"suggestion"}},o}function y(){if(d)return p;d=1;const{name:e,version:n}=i,{rulesOfLexical:t}=m(),r={plugins:["@lexical"],rules:{"@lexical/rules-of-lexical":"warn"}},o={configs:{all:r,"flat/all":null,"flat/recommended":null,"legacy-all":r,"legacy-recommended":r,recommended:r},meta:{name:e,version:n},rules:{"rules-of-lexical":t}},s={plugins:{"@lexical":o},rules:{"@lexical/rules-of-lexical":"warn"}};return o.configs["flat/all"]=s,o.configs["flat/recommended"]=s,p=o}var h=y();const v=e({__proto__:null,default:n(h)},[h]);export{v as default};