@lexical/eslint-plugin 0.15.0

package/LexicalEslintPlugin.js.flow

@@ -0,0 +1,11 @@
+/**
+ * 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.
+ *
+ */
+
+/**
+ * LexicalEslintPlugin
+ */

package/LexicalEslintPlugin.mjs

@@ -0,0 +1,12 @@
+/**
+ * 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.
+ *
+ */
+
+import * as modDev from './LexicalEslintPlugin.dev.mjs';
+import * as modProd from './LexicalEslintPlugin.prod.mjs';
+const mod = process.env.NODE_ENV === 'development' ? modDev : modProd;
+export default mod.default;

package/LexicalEslintPlugin.node.mjs

@@ -0,0 +1,10 @@
+/**
+ * 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.
+ *
+ */
+
+const mod = await (process.env.NODE_ENV === 'development' ? import('./LexicalEslintPlugin.dev.mjs') : import('./LexicalEslintPlugin.prod.mjs'));
+export default mod.default;

package/LexicalEslintPlugin.prod.js

@@ -0,0 +1,20 @@
+/**
+ * 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';var l={},n={},p={getParentAssignmentName:function(a){let c=a.parent;if("VariableDeclarator"===c.type&&c.init===a)return c.id;if("AssignmentExpression"===c.type&&c.right===a&&"="===c.operator)return c.left}};let {getParentAssignmentName:r}=p;n.getFunctionName=function(a){if("FunctionDeclaration"===a.type||"FunctionExpression"===a.type&&a.id)return a.id;if("FunctionExpression"===a.type||"ArrowFunctionExpression"===a.type)return r(a)};
+let {getFunctionName:t}=n,{getParentAssignmentName:z}=p,{buildMatcher:A}={buildMatcher:function(...a){let c=[],e=[];for(let b of a.flat(1))b&&("string"===typeof b?e.push(/^[(^]/.test(b)?b:`^${b.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}$`):b&&b instanceof RegExp?b.flags?c.push(h=>b.test(h)):e.push(b.source):"function"===typeof b&&c.push(b));if(a=e.map(b=>`(?:${b})`).join("|")){let b=new RegExp(a);c.push(h=>b.test(h))}return b=>{if(b){if("Identifier"!==b.type)throw Error(`Expecting Identifier, not ${b.type}`);
+for(let h of c)if(h(b.name,b))return!0}return!1}}};function B(a,c){a=a.scopeManager;for(let b=c;b;b=b.parent){var e=a.getDeclaredVariables(b).find(h=>h.identifiers.includes(c));if(e)return e;if(e=a.acquire(b))return e.set.get(c.name)||(e.upper?e.upper.set.get(c.name):void 0)}}let C={isDollarFunction:[/^\$[a-z_]/],isIgnoredFunction:[],isLexicalProvider:["parseEditorState","read","registerCommand","registerNodeTransform","update"],isSafeDollarFunction:[/^\$is[A-Z_]/]};
+function D(a){let c={};for(let u in C){var e=u,b=e,h=C[e],g=a;g=Array.isArray(g.options)?g.options[0]:void 0;c[b]=A(h,g&&e in g?g[e]:void 0)}return c}function E(a){if(a){if("Identifier"===a.type)return a;if("MemberExpression"===a.type&&!a.computed)return E(a.property)}}function L(a,c){a=a.name;a=/^[a-z]/.test(a)?"$"+a:/^[A-Z][a-z]/.test(a)?"$"+a.slice(0,1).toLowerCase()+a.slice(1):`$_${a}`;if(c)for(c=c.scope;c;c=c.upper)if(c.set.has(a))return a+"_";return a}
+function M(a){if(a&&1===a.defs.length){[{node:a}]=a.defs;if("ExportNamedDeclaration"===a.parent.type)return a.parent;if("VariableDeclaration"===a.parent.type&&"ExportNamedDeclaration"===a.parent.parent.type)return a.parent.parent}}function N({caller:a,suggestName:c}){return`\n/** @deprecated renamed to {@link ${c}} by @lexical/eslint-plugin rules-of-lexical */\nexport const ${a} = ${c};`}let O={oneOf:[{type:"string"},{contains:{type:"string"},type:"array"}]};
+l.rulesOfLexical={create(a){let c=a.getSourceCode(),e=D(a),b=new Set,h=new Set,g=[],u=()=>{if(0<b.size)return!0;const d=g[g.length-1];return d&&"Property"===d.node.parent.type},F=d=>b.delete(d),v=d=>{a:{var f=t(d);if(!f){f=d.parent;if("CallExpression"===f.type&&f.arguments[0]===d){let k=E(f.callee);if(k&&"Identifier"===k.type&&/^use([A-Z]|$)/.test(k.name)){f=z(f);break a}}f=void 0}}f=E(f);g.push({name:f,node:d});(e.isDollarFunction(f)||e.isIgnoredFunction(f)||e.isLexicalProvider(f))&&b.add(d)},w=
+d=>{g.pop();b.delete(d)},W=()=>{const d=g[g.length-1];return d?d.name:void 0};return{ArrowFunctionExpression:v,"ArrowFunctionExpression:exit":w,CallExpression:d=>{if(!u()){var f=E(d.callee);if(e.isLexicalProvider(f)||e.isSafeDollarFunction(f))b.add(d);else if(e.isDollarFunction(f)){var k=W();if(k&&!h.has(k)){h.add(k);var q=B(c,k),G=L(k,q),H=M(q),x={callee:c.getText(d.callee),caller:c.getText(k),suggestName:G};d=I=>{const J=new Set,y=[],K=m=>{J.has(m)||(J.add(m),y.push(I.replaceText(m,G)))};K(k);H&&
+y.push(I.insertTextAfter(H,N(x)));if(q)for(const m of q.references)K(m.identifier);return y};a.report({data:x,fix:d,messageId:"rulesOfLexicalReport",node:k,suggest:[{data:x,fix:d,messageId:"rulesOfLexicalSuggestion"}]})}}}},"CallExpression:exit":F,ClassBody:d=>b.add(d),"ClassBody:exit":F,FunctionDeclaration:v,"FunctionDeclaration:exit":w,FunctionExpression:v,"FunctionExpression:exit":w}},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:O,isIgnoredFunction:O,isLexicalProvider:O,isSafeDollarFunction:O},type:"object"}],type:"suggestion"}};
+let {name:P,version:Q}={name:"@lexical/eslint-plugin",description:"Lexical specific linting rules for ESLint",keywords:["eslint","eslint-plugin","eslintplugin","lexical","editor"],version:"0.15.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",bugs:{url:"https://github.com/facebook/lexical/issues"},homepage:"https://lexical.dev/docs/packages/lexical-eslint-plugin",sideEffects:!1,
+peerDependencies:{eslint:">=7.31.0 || ^8.0.0"},exports:{".":{"import":{types:"./index.d.ts",development:"./LexicalEslintPlugin.dev.mjs",production:"./LexicalEslintPlugin.prod.mjs",node:"./LexicalEslintPlugin.node.mjs","default":"./LexicalEslintPlugin.mjs"},require:{types:"./index.d.ts",development:"./LexicalEslintPlugin.dev.js",production:"./LexicalEslintPlugin.prod.js","default":"./LexicalEslintPlugin.js"}}},devDependencies:{"@types/eslint":"^8.56.9"},module:"LexicalEslintPlugin.mjs"},{rulesOfLexical:R}=
+l,S={plugins:["@lexical"],rules:{"@lexical/rules-of-lexical":"warn"}};for(var T={configs:{all:S,recommended:S},meta:{name:P,version:Q},rules:{"rules-of-lexical":R}},U={__proto__:null,default:T&&T.__esModule&&Object.prototype.hasOwnProperty.call(T,"default")?T["default"]:T},V=[T],X=0;X<V.length;X++){var Y=V[X];if("string"!==typeof Y&&!Array.isArray(Y))for(var Z in Y)"default"===Z||Z in U||(U[Z]=Y[Z])}module.exports=U

package/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,t){for(var n=0;n<t.length;n++){var i=t[n];if("string"!=typeof i&&!Array.isArray(i))for(var r in i)"default"===r||r in e||(e[r]=i[r])}return e}function t(e){return e&&e.__esModule&&Object.prototype.hasOwnProperty.call(e,"default")?e.default:e}var n={name:"@lexical/eslint-plugin",description:"Lexical specific linting rules for ESLint",keywords:["eslint","eslint-plugin","eslintplugin","lexical","editor"],version:"0.15.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",bugs:{url:"https://github.com/facebook/lexical/issues"},homepage:"https://lexical.dev/docs/packages/lexical-eslint-plugin",sideEffects:!1,peerDependencies:{eslint:">=7.31.0 || ^8.0.0"},exports:{".":{import:{types:"./index.d.ts",development:"./LexicalEslintPlugin.dev.mjs",production:"./LexicalEslintPlugin.prod.mjs",node:"./LexicalEslintPlugin.node.mjs",default:"./LexicalEslintPlugin.mjs"},require:{types:"./index.d.ts",development:"./LexicalEslintPlugin.dev.js",production:"./LexicalEslintPlugin.prod.js",default:"./LexicalEslintPlugin.js"}}},devDependencies:{"@types/eslint":"^8.56.9"},module:"LexicalEslintPlugin.mjs"},i={},r={},s={getParentAssignmentName:function(e){const t=e.parent;return"VariableDeclarator"===t.type&&t.init===e?t.id:"AssignmentExpression"===t.type&&t.right===e&&"="===t.operator?t.left:void 0}};const{getParentAssignmentName:o}=s;r.getFunctionName=function(e){return"FunctionDeclaration"===e.type||"FunctionExpression"===e.type&&e.id?e.id:"FunctionExpression"===e.type||"ArrowFunctionExpression"===e.type?o(e):void 0};var a={};a.buildMatcher=function(...e){const t=[],n=[];for(const r of e.flat(1))r&&("string"==typeof r?n.push(/^[(^]/.test(r)?r:`^${i=r,i.replace(/[.*+?^${}()|[\]\\]/g,"\\$&")}$`):r&&r instanceof RegExp?r.flags?t.push((e=>r.test(e))):n.push(r.source):"function"==typeof r&&t.push(r));var i;const r=n.map((e=>`(?:${e})`)).join("|");if(r){const e=new RegExp(r);t.push((t=>e.test(t)))}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}};const{getFunctionName:l}=r,{getParentAssignmentName:c}=s,{buildMatcher:u}=a;const p={isDollarFunction:[/^\$[a-z_]/],isIgnoredFunction:[],isLexicalProvider:["parseEditorState","read","registerCommand","registerNodeTransform","update"],isSafeDollarFunction:[/^\$is[A-Z_]/]};function d(e){if(e)return"Identifier"===e.type?e:"MemberExpression"!==e.type||e.computed?void 0:d(e.property)}function f(e,t){const n=Array.isArray(e.options)?e.options[0]:void 0;return n&&t in n?n[t]:void 0}const g={oneOf:[{type:"string"},{contains:{type:"string"},type:"array"}]};i.rulesOfLexical={create(e){const t=function(e){return e.getSourceCode()}(e),n=function(e){const t={};for(const n in p){const i=n;t[i]=u(p[i],f(e,i))}return t}(e),i=new Set,r=new Set,s=[],o=e=>i.add(e),a=e=>i.delete(e),g=e=>{const t=d(function(e){const t=l(e);if(t)return t;const n=e.parent;if("CallExpression"===n.type&&n.arguments[0]===e&&function(e){return e&&"Identifier"===e.type&&/^use([A-Z]|$)/.test(e.name)}(d(n.callee)))return c(n)}(e));s.push({name:t,node:e}),(n.isDollarFunction(t)||n.isIgnoredFunction(t)||n.isLexicalProvider(t))&&o(e)},x=e=>{s.pop(),a(e)};return{ArrowFunctionExpression:g,"ArrowFunctionExpression:exit":x,CallExpression:a=>{if((()=>{if(i.size>0)return!0;const e=s[s.length-1];return e&&"Property"===e.node.parent.type})())return;const l=d(a.callee);if(n.isLexicalProvider(l)||n.isSafeDollarFunction(l))return void o(a);if(!n.isDollarFunction(l))return;const c=(e=>{const t=s[s.length-1];return t?t.name:void 0})();if(!c||r.has(c))return;r.add(c);const u=function(e,t){const n=e.scopeManager;for(let e=t;e;e=e.parent){const i=n.getDeclaredVariables(e).find((e=>e.identifiers.includes(t)));if(i)return i;const r=n.acquire(e);if(r)return r.set.get(t.name)||(r.upper?r.upper.set.get(t.name):void 0)}}(t,c),p=function(e,t){const n=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(t)for(let e=t.scope;e;e=e.upper)if(e.set.has(n))return n+"_";return n}(c,u),f=function(e){if(e&&1===e.defs.length){const[{node:t}]=e.defs;if("ExportNamedDeclaration"===t.parent.type)return t.parent;if("VariableDeclaration"===t.parent.type&&"ExportNamedDeclaration"===t.parent.parent.type)return t.parent.parent}}(u),g={callee:t.getText(a.callee),caller:t.getText(c),suggestName:p},x=e=>{const t=new Set,n=[],i=i=>{t.has(i)||(t.add(i),n.push(e.replaceText(i,p)))};if(i(c),f&&n.push(e.insertTextAfter(f,function({caller:e,suggestName:t}){return`\n/** @deprecated renamed to {@link ${t}} by @lexical/eslint-plugin rules-of-lexical */\nexport const ${e} = ${t};`}(g))),u)for(const e of u.references)i(e.identifier);return n};e.report({data:g,fix:x,messageId:"rulesOfLexicalReport",node:c,suggest:[{data:g,fix:x,messageId:"rulesOfLexicalSuggestion"}]})},"CallExpression:exit":a,ClassBody:o,"ClassBody:exit":a,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:g,isIgnoredFunction:g,isLexicalProvider:g,isSafeDollarFunction:g},type:"object"}],type:"suggestion"}};const{name:x,version:m}=n,{rulesOfLexical:y}=i,h={plugins:["@lexical"],rules:{"@lexical/rules-of-lexical":"warn"}};var E={configs:{all:h,recommended:h},meta:{name:x,version:m},rules:{"rules-of-lexical":y}},v=e({__proto__:null,default:t(E)},[E]);export{v as default};

package/README.md

@@ -0,0 +1,216 @@
+# `@lexical/eslint-plugin`
+
+This ESLint plugin enforces the [Lexical $function convention](https://lexical.dev/docs/intro#reading-and-updating-editor-state).
+
+## Installation
+
+Assuming you already have ESLint installed, run:
+
+```sh
+npm install @lexical/eslint-plugin --save-dev
+```
+
+Then extend the recommended eslint config:
+
+```js
+{
+  "extends": [
+    // ...
+    "plugin:@lexical/recommended"
+  ]
+}
+```
+
+### Custom Configuration
+
+If you want more fine-grained configuration, you can instead add a snippet like this to your ESLint configuration file:
+
+```js
+{
+  "plugins": [
+    // ...
+    "@lexical"
+  ],
+  "rules": {
+    // ...
+    "@lexical/rules-of-lexical": "error"
+  }
+}
+```
+
+### Advanced configuration
+
+Most of the heuristics in `@lexical/rules-of-lexical` can be extended with
+additional terms or patterns.
+
+The code example below is shown using the default implementations for each
+option. When you configure these they are combined with the default
+implementations using "OR", the default implementations can not be overridden.
+These terms and patterns are only shown for reference and pasting this example
+into your project is not useful.
+
+If the string begins with a `"^"` or `"("` then it is treated as a RegExp,
+otherwise it will be an exact match. A string may also be used instead
+of an array of strings.
+
+```js
+{
+  "plugins": [
+    // ...
+    "@lexical"
+  ],
+  "rules": {
+    // ...
+    "@lexical/rules-of-lexical": [
+      "error",
+      {
+        "isDollarFunction": ["^\\$[a-z_]"],
+        "isIgnoredFunction": [],
+        "isLexicalProvider": [
+          "parseEditorState",
+          "read",
+          "registerCommand",
+          "registerNodeTransform",
+          "update"
+        ],
+        "isSafeDollarFunction": ["^\\$is"]
+      }
+    ]
+  }
+}
+```
+
+#### `isDollarFunction`
+
+*Base case*: `/^\$[a-z_]/`
+
+This defines the \$function convention, which by default is any function that
+starts with a dollar sign followed by a lowercase latin letter. You may have a
+secondary convention in your codebase, such as non-latin letters, or an
+internal prefix that you want to consider (e.g. `"^INTERNAL_\\$"`).
+
+#### `isIgnoredFunction`
+
+*Base case*: None
+
+Functions that match these patterns are ignored from analysis, they may call
+Lexical \$functions but are not considered to be a dollar function themselves.
+
+#### `isLexicalProvider`
+
+*Base case*: `/^(parseEditorState|read|registerCommand|registerNodeTransform|update)$/`
+
+These are functions that allow their function argument to use Lexical
+\$functions.
+
+#### `isSafeDollarFunction`
+
+*Base case*: `/^\$is/`
+
+These \$functions are considered safe to call from anywhere, generally
+these functions are runtime type checks that do not depend on any other
+state.
+
+## Valid and Invalid Examples
+
+### Valid Examples
+
+\$functions may be called by other \$functions
+
+```js
+function $namedCorrectly() {
+  return $getRoot();
+}
+```
+
+\$functions may be called in functions defined when calling the following
+methods (the heuristic only considers the method name):
+
+* `editor.update`
+* `editorState.read`
+* `editor.registerCommand`
+* `editor.registerNodeTransform`
+
+```js
+function validUsesEditorOrState(editor) {
+  editor.update(() => $getRoot());
+  editor.getLatestState().read(() => $getRoot());
+}
+```
+
+\$functions may be called from class methods
+
+```js
+class CustomNode extends ElementNode {
+  appendText(string) {
+    this.appendChild($createTextNode(string));
+  }
+}
+```
+
+### Invalid Examples
+
+#### Rename autofix
+
+```js
+function invalidFunction() {
+  return $getRoot();
+}
+function $callsInvalidFunction() {
+  return invalidFunction();
+}
+```
+
+*Autofix:* The function is renamed with a $ prefix. Any references to this
+name in this module are also always renamed.
+
+```js
+function $invalidFunction() {
+  return $getRoot();
+}
+function $callsInvalidFunction() {
+  return $invalidFunction();
+}
+```
+
+#### Rename & deprecate autofix
+
+```js
+export function exportedInvalidFunction() {
+  return $getRoot();
+}
+```
+
+*Autofix:* The exported function is renamed with a $ prefix. The previous name
+is also exported and marked deprecated, because automatic renaming of
+references to that name is limited to the module's scope.
+
+```js
+export function $exportedInvalidFunction() {
+  return $getRoot();
+}
+/** @deprecated renamed to {@link $exportedInvalidFunction} by @lexical/eslint-plugin rules-of-lexical */
+export const exportedInvalidFunction = $exportedInvalidFunction;
+```
+
+#### Rename scope conflict
+
+```js
+import {$getRoot} from 'lexical';
+function InvalidComponent() {
+  const [editor] = useLexicalComposerContext();
+  const getRoot = useCallback(() => $getRoot(), []);
+  return (<button onClick={() => editor.update(() => getRoot())} />);
+}
+```
+
+*Autofix:* The function is renamed with a $ prefix and _ suffix since the suggested name was already in scope.
+
+```js
+import {$getRoot} from 'lexical';
+function InvalidComponent() {
+  const [editor] = useLexicalComposerContext();
+  const $getRoot_ = useCallback(() => $getRoot(), []);
+  return (<button onClick={() => editor.update(() => $getRoot_())} />);
+}
+```

package/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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 * as plugin from './LexicalEslintPlugin.js';
+export type { RulesOfLexicalOptions } from './rules/rules-of-lexical.js';
+export default plugin;

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@lexical/eslint-plugin",
+  "description": "Lexical specific linting rules for ESLint",
+  "keywords": [
+    "eslint",
+    "eslint-plugin",
+    "eslintplugin",
+    "lexical",
+    "editor"
+  ],
+  "version": "0.15.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",
+  "bugs": {
+    "url": "https://github.com/facebook/lexical/issues"
+  },
+  "homepage": "https://lexical.dev/docs/packages/lexical-eslint-plugin",
+  "sideEffects": false,
+  "peerDependencies": {
+    "eslint": ">=7.31.0 || ^8.0.0"
+  },
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./index.d.ts",
+        "development": "./LexicalEslintPlugin.dev.mjs",
+        "production": "./LexicalEslintPlugin.prod.mjs",
+        "node": "./LexicalEslintPlugin.node.mjs",
+        "default": "./LexicalEslintPlugin.mjs"
+      },
+      "require": {
+        "types": "./index.d.ts",
+        "development": "./LexicalEslintPlugin.dev.js",
+        "production": "./LexicalEslintPlugin.prod.js",
+        "default": "./LexicalEslintPlugin.js"
+      }
+    }
+  },
+  "devDependencies": {
+    "@types/eslint": "^8.56.9"
+  },
+  "module": "LexicalEslintPlugin.mjs"
+}

package/rules/rules-of-lexical.d.ts

@@ -0,0 +1,52 @@
+export const rulesOfLexical: RuleModule;
+export type NodeParentExtension = import('eslint').Rule.NodeParentExtension;
+export type CallExpression = import('estree').CallExpression & NodeParentExtension;
+export type Identifier = import('estree').Identifier & NodeParentExtension;
+export type RuleContext = import('eslint').Rule.RuleContext;
+export type Fix = import('eslint').Rule.Fix;
+export type Node = import('eslint').Rule.Node;
+export type RuleModule = import('eslint').Rule.RuleModule;
+export type ReportFixer = import('eslint').Rule.ReportFixer;
+export type SourceCode = import('eslint').SourceCode;
+export type Variable = import('eslint').Scope.Variable;
+export type Scope = import('eslint').Scope.Scope;
+export type RulesOfLexicalOptions = Partial<BaseMatchers<ToMatcher | ToMatcher[]>>;
+export type Matchers = BaseMatchers<IdentifierMatcher>;
+export type ToMatcher = import('../util/buildMatcher.js').ToMatcher;
+export type IdentifierMatcher = import('../util/buildMatcher.js').IdentifierMatcher;
+/**
+ * <T>
+ */
+export type BaseMatchers<T> = {
+    /**
+     * Catch all identifiers that begin with '$' or 'INTERNAL_$' followed by a lowercase Latin character or underscore
+     */
+    isDollarFunction: T;
+    /**
+     * These functions may call any $functions even though they do not have the isDollarFunction naming convention
+     */
+    isIgnoredFunction: T;
+    /**
+     * Certain calls through the editor or editorState allow for implicit access to call $functions: read, registerCommand, registerNodeTransform, update.
+     */
+    isLexicalProvider: T;
+    /**
+     * It's usually safe to call $isNode functions, so any '$is' or 'INTERNAL_$is' function may be called in any context.
+     */
+    isSafeDollarFunction: T;
+};
+/**
+ * @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>[]>} */
+declare const BaseMatchers: BaseMatchers<Exclude<ToMatcher, undefined>[]>;
+export {};

package/util/buildMatcher.d.ts

@@ -0,0 +1,6 @@
+export function buildMatcher(...toMatchers: any[]): IdentifierMatcher;
+export type Node = import('estree').Node;
+export type Identifier = import('estree').Identifier;
+export type NameIdentifierMatcher = (name: string, node: Identifier) => boolean;
+export type ToMatcher = NameIdentifierMatcher | string | RegExp | undefined;
+export type IdentifierMatcher = (node: Identifier | undefined) => boolean;

package/util/getFunctionName.d.ts

@@ -0,0 +1 @@
+export function getFunctionName(node: import('eslint').Rule.Node): any;

package/util/getParentAssignmentName.d.ts

@@ -0,0 +1 @@
+export function getParentAssignmentName(node: import('eslint').Rule.Node): import("estree").Pattern | undefined;