@jupyter/eslint-plugin 1.1.0 → 1.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (40) hide show
  1. package/lib/index.d.ts +49 -2
  2. package/lib/index.js +35 -5
  3. package/lib/rules/galata-prefer-context-menu-helper.d.ts +6 -0
  4. package/lib/rules/galata-prefer-context-menu-helper.js +394 -0
  5. package/lib/rules/galata-prefer-menu-helper.d.ts +6 -0
  6. package/lib/rules/galata-prefer-menu-helper.js +394 -0
  7. package/lib/rules/galata-prefer-notebook-cell-helper.d.ts +6 -0
  8. package/lib/rules/galata-prefer-notebook-cell-helper.js +403 -0
  9. package/lib/rules/galata-prefer-sidebar-activity-helper.d.ts +6 -0
  10. package/lib/rules/galata-prefer-sidebar-activity-helper.js +332 -0
  11. package/lib/rules/no-schema-enum.d.ts +1 -1
  12. package/lib/rules/no-schema-enum.js +54 -2
  13. package/lib/rules/no-untranslated-string.d.ts +2 -1
  14. package/lib/rules/no-untranslated-string.js +191 -113
  15. package/lib/rules/plugin-id-convention.d.ts +7 -0
  16. package/lib/rules/plugin-id-convention.js +296 -0
  17. package/lib/rules/prefer-lazy-imports.d.ts +6 -0
  18. package/lib/rules/prefer-lazy-imports.js +476 -0
  19. package/lib/rules/require-disposable-ownership.js +1 -16
  20. package/lib/rules/require-disposable-transfer.js +7 -2
  21. package/lib/utils/ast.d.ts +12 -0
  22. package/lib/utils/ast.js +49 -0
  23. package/lib/utils/disposables.d.ts +12 -0
  24. package/lib/utils/disposables.js +101 -10
  25. package/lib/utils/lazy-imports.d.ts +93 -0
  26. package/lib/utils/lazy-imports.js +600 -0
  27. package/lib/utils/module-size.d.ts +18 -0
  28. package/lib/utils/module-size.js +249 -0
  29. package/lib/utils/package-json.d.ts +8 -0
  30. package/lib/utils/package-json.js +76 -0
  31. package/lib/utils/playwright-selectors.d.ts +56 -5
  32. package/lib/utils/playwright-selectors.js +205 -12
  33. package/lib/utils/plugin-utils.d.ts +50 -2
  34. package/lib/utils/plugin-utils.js +221 -38
  35. package/lib/utils/shared-packages.d.ts +9 -0
  36. package/lib/utils/shared-packages.js +128 -0
  37. package/lib/utils/signal-lifetime.js +66 -5
  38. package/lib/utils/signals.d.ts +2 -8
  39. package/lib/utils/signals.js +7 -42
  40. package/package.json +1 -1
@@ -0,0 +1,6 @@
1
+ import { TSESLint } from '@typescript-eslint/utils';
2
+ type MessageIds = 'preferMenuOpen' | 'preferClickMenuItem' | 'preferMenuHelper';
3
+ declare const galataPreferMenuHelper: TSESLint.RuleModule<MessageIds, [], unknown, TSESLint.RuleListener> & {
4
+ name: string;
5
+ };
6
+ export = galataPreferMenuHelper;
@@ -0,0 +1,394 @@
1
+ "use strict";
2
+ /*
3
+ * Copyright (c) Jupyter Development Team.
4
+ * Distributed under the terms of the Modified BSD License.
5
+ */
6
+ const ast_1 = require("../utils/ast");
7
+ const create_rule_1 = require("../utils/create-rule");
8
+ const playwright_selectors_1 = require("../utils/playwright-selectors");
9
+ // JupyterLab's main menu bar
10
+ const TOP_LEVEL_MENU_LABELS = 'File|Edit|View|Run|Kernel|Tabs|Settings|Help';
11
+ // The entire selector is a bare text query for a top-level menu label:
12
+ // `text=File`, `text="Settings"`.
13
+ const BARE_MENU_BAR_LABEL_PATTERN = new RegExp(`^text=["']?(?:${TOP_LEVEL_MENU_LABELS})["']?$`);
14
+ // Playwright's text pseudo-classes, which take the label in parentheses:
15
+ // `:has-text("File")`, `:text("File")`, `:text-is("File")`. Galata's own
16
+ // `getMenuBarItemLocator` builds `li:has(div.lm-MenuBar-itemLabel:text-is(…))`,
17
+ // so a test copying that shape has to be read here too.
18
+ const TEXT_PSEUDO_CLASS = ':?(?:has-)?text(?:-is)?\\(';
19
+ // A top-level menu label inside a larger selector. Only trusted when the same
20
+ // selector also carries menu markup (see MENU_MARKUP_PATTERN), e.g.
21
+ // `li[role="menuitem"]:has-text("File")`.
22
+ //
23
+ // The left boundary of the `text=` form accepts a plain space as well as `>>`
24
+ // because a locator chain such as
25
+ // `page.locator('.lm-MenuBar-item').getByText('File')` is joined into
26
+ // `.lm-MenuBar-item text=File`. The right boundary deliberately does not:
27
+ // allowing a space there would make `text=File Browser` match the label `File`.
28
+ // The pseudo-class form needs no boundary, because its closing parenthesis is
29
+ // one.
30
+ const SCOPED_MENU_BAR_LABEL_PATTERN = new RegExp(`(?:^|>>\\s*|\\s)text=["']?(?:${TOP_LEVEL_MENU_LABELS})["']?\\s*(?:$|>>)` +
31
+ `|${TEXT_PSEUDO_CLASS}["']?(?:${TOP_LEVEL_MENU_LABELS})["']?\\)`);
32
+ // Any `#jp-mainmenu-…` id, top-level menu or submenu.
33
+ //
34
+ // Every one of these names a popup, never a menu bar item. `MenuFactory` sets
35
+ // the id with `menu.id = item.id`, `Widget.id` writes it to `this.node.id`,
36
+ // and a `Menu`'s node is the `div` it adds `lm-Menu` to. Lumino's
37
+ // `MenuBar.Renderer.renderItem` builds the menu bar `li` from a class name, a
38
+ // dataset and ARIA attributes, and gives it no id at all. So `#jp-mainmenu-tabs`
39
+ // is the Tabs popup and `#jp-mainmenu-file-new` is the File > New popup; they
40
+ // differ by nesting depth only.
41
+ //
42
+ // Only JupyterLab's main menu carries these ids, so they say which menu is open
43
+ // on their own, without the lookback in `findMenuOrigin`.
44
+ const MAIN_MENU_ID_PATTERN = /#jp-mainmenu-/;
45
+ // Markers proving the selector is scoped inside an open popup menu. Note that
46
+ // `\blm-Menu\b` cannot match inside `lm-MenuBar` (there is no word boundary
47
+ // between `u` and `B`) but does match `lm-Menu-item`, `lm-Menu-content`, …
48
+ const POPUP_CONTAINER_PATTERN = /\blm-Menu\b|role\s*=\s*["']menu["']|#jp-mainmenu-/;
49
+ // The menu bar itself. Unlike a popup it is always on screen, so a selector
50
+ // carrying this needs nothing before it to say which menu it is on.
51
+ const MENU_BAR_CONTAINER_PATTERN = /lm-MenuBar\b/;
52
+ // Menu markup that does not resolve menu bar vs popup on its own: Lumino gives
53
+ // `role="menuitem"` to both menu bar items and popup items, and stamps
54
+ // `data-type="submenu"` on any item that opens a submenu.
55
+ //
56
+ // A toggleable item gets `role="menuitemcheckbox"` instead, which the View and
57
+ // Settings menus are full of, so both roles count. A submenu item gets no role
58
+ // at all and is reached through `data-type` instead.
59
+ const MENU_MARKUP_PATTERN = /role\s*=\s*["']menuitem(?:checkbox)?["']|lm-MenuBar\b|data-type\s*=\s*["']?submenu/;
60
+ // Any item label in the selector, whatever spelling it uses. Its presence is
61
+ // what makes a menu path suggestible, so `preferClickMenuItem` can be reported
62
+ // instead of the generic message.
63
+ const TEXT_SELECTOR_PATTERN = new RegExp(`text=|${TEXT_PSEUDO_CLASS}`);
64
+ // Menu items are activated with a single click, so a click is the gesture the
65
+ // rule reads. `dblclick`, `tap`, `press` and `fill` are left alone: a menu-ish
66
+ // selector combined with one of them means the test is doing something else.
67
+ //
68
+ // `hover` is the exception, and it is left alone anyway. `openLocator` opens a
69
+ // submenu by hovering its parent item, so a hover on a menu item does have a
70
+ // helper form, and reporting one would be defensible. It is skipped because a
71
+ // hover is also how a test positions the pointer for a screenshot, which is
72
+ // what the single corpus site doing it wants.
73
+ const MENU_INTERACTION_METHOD = 'click';
74
+ function readMenuEvidence(selectorText) {
75
+ const hasPopupContainer = POPUP_CONTAINER_PATTERN.test(selectorText);
76
+ const hasMenuMarkup = MENU_MARKUP_PATTERN.test(selectorText);
77
+ // The menu bar's own class names the target outright, whatever label it
78
+ // carries, so a third-party menu such as `Git` is covered by it even though
79
+ // the label list is not. Failing that, a top-level label is trusted unscoped
80
+ // (`text=File` and nothing else) or next to menu markup
81
+ // (`li[role="menuitem"]:has-text("File")`). Any other scope means the label
82
+ // is some other piece of UI text. No id appears here: every `#jp-mainmenu-…`
83
+ // names a popup, so it is a container instead.
84
+ const hasTopLevelMarker = MENU_BAR_CONTAINER_PATTERN.test(selectorText) ||
85
+ BARE_MENU_BAR_LABEL_PATTERN.test(selectorText) ||
86
+ (hasMenuMarkup && SCOPED_MENU_BAR_LABEL_PATTERN.test(selectorText));
87
+ return { hasPopupContainer, hasMenuMarkup, hasTopLevelMarker };
88
+ }
89
+ // `MenuHelper` methods that leave the main menu open. `open` and `getMenuItem`
90
+ // are deprecated in favour of the `…Locator` forms, and both spellings appear
91
+ // in current suites, so both are recognized.
92
+ const MENU_OPENING_HELPERS = new Set([
93
+ 'open',
94
+ 'openLocator',
95
+ 'clickMenuItem'
96
+ ]);
97
+ function menuOriginOf(node) {
98
+ const callee = node.callee;
99
+ if (callee.type === 'MemberExpression' &&
100
+ callee.property.type === 'Identifier') {
101
+ // `page.menu.openContextMenu(selector)` / `openContextMenuLocator(selector)`
102
+ if (callee.property.name.startsWith('openContextMenu')) {
103
+ return 'context';
104
+ }
105
+ // The helper form of a menu bar click. `openLocator` clicks the first path
106
+ // part and hovers the rest; `open` delegates to it; `clickMenuItem` calls
107
+ // it and then clicks the item. `getMenuItemLocator` is not here: it walks
108
+ // the same path but clicks and hovers nothing, so it opens no menu.
109
+ if (MENU_OPENING_HELPERS.has(callee.property.name) &&
110
+ callee.object.type === 'MemberExpression' &&
111
+ callee.object.property.type === 'Identifier' &&
112
+ callee.object.property.name === 'menu') {
113
+ return 'menubar';
114
+ }
115
+ }
116
+ // A right-click is the one gesture that opens the context menu. Which element
117
+ // it targets does not matter here, so the chain does not have to resolve to
118
+ // `page` first: `const item = page.locator(a); item.click({ button:
119
+ // 'right' })` and `page.activity.getTabLocator(b).click({ button: 'right' })`
120
+ // open the context menu just as `page.click(a, { button: 'right' })` does.
121
+ if (callee.type === 'MemberExpression' &&
122
+ callee.property.type === 'Identifier' &&
123
+ callee.property.name === MENU_INTERACTION_METHOD &&
124
+ (0, playwright_selectors_1.isRightClick)(node)) {
125
+ return 'context';
126
+ }
127
+ const match = (0, playwright_selectors_1.matchSelectorInteraction)(node);
128
+ if (!match) {
129
+ return null;
130
+ }
131
+ if (match.interactionMethod !== MENU_INTERACTION_METHOD) {
132
+ return null;
133
+ }
134
+ const selectorText = (0, playwright_selectors_1.combineStaticSelectorText)(match);
135
+ if (selectorText === null) {
136
+ return null;
137
+ }
138
+ const evidence = readMenuEvidence(selectorText);
139
+ // Clicking a menu bar item — the same shape the rule reports as
140
+ // `preferMenuOpen` — is what opens the main menu.
141
+ return evidence.hasTopLevelMarker && !evidence.hasPopupContainer
142
+ ? 'menubar'
143
+ : null;
144
+ }
145
+ function collectMenuOrigins(root, found) {
146
+ (0, ast_1.walkFrom)(root, node => {
147
+ if ((0, playwright_selectors_1.isTestScopeBoundary)(node)) {
148
+ return 'skip-children';
149
+ }
150
+ if (node.type === 'CallExpression') {
151
+ const origin = menuOriginOf(node);
152
+ if (origin) {
153
+ found.push({ origin, start: node.range[0] });
154
+ }
155
+ }
156
+ return undefined;
157
+ });
158
+ }
159
+ /**
160
+ * The last menu-opening gesture among the first `index` statements of `block`.
161
+ *
162
+ * Each statement is read once per block and the running answer is kept, because
163
+ * a file that walks a menu many times asks about the same statements once per
164
+ * gesture; reading them again each time costs the square of their number. The
165
+ * scan grows only as far as it has been asked to, so a block with one gesture
166
+ * near the top never reads the rest of it.
167
+ */
168
+ function originBeforeStatement(block, body, index, cache) {
169
+ let scan = cache.get(block);
170
+ if (!scan) {
171
+ scan = { prefix: [null], scanned: 0, latest: null };
172
+ cache.set(block, scan);
173
+ }
174
+ while (scan.scanned < index) {
175
+ const found = [];
176
+ collectMenuOrigins(body[scan.scanned], found);
177
+ for (const hit of found) {
178
+ if (!scan.latest || hit.start > scan.latest.start) {
179
+ scan.latest = hit;
180
+ }
181
+ }
182
+ scan.prefix.push(scan.latest?.origin ?? null);
183
+ scan.scanned++;
184
+ }
185
+ return scan.prefix[index];
186
+ }
187
+ /**
188
+ * The kind of menu that was last opened before `node` runs, or `null` when
189
+ * nothing in the enclosing scopes says.
190
+ *
191
+ * Statements preceding `node` are read innermost block first, then outward, and
192
+ * the last menu-opening gesture in source order wins — clicking `File` after a
193
+ * right-click replaces the context menu with the main menu. An inner block's
194
+ * preceding statements all come after an outer block's, so the innermost block
195
+ * with an answer holds the latest one and the walk can stop there. The walk
196
+ * also stops at the enclosing test callback or named helper, so one test's menu
197
+ * state never reaches the next (see `isTestScopeBoundary`).
198
+ */
199
+ function findMenuOrigin(node, cache) {
200
+ let current = node;
201
+ let parent = current.parent;
202
+ while (parent) {
203
+ let body = null;
204
+ if (parent.type === 'BlockStatement' || parent.type === 'Program') {
205
+ body = parent.body;
206
+ }
207
+ else if (parent.type === 'SwitchCase') {
208
+ body = parent.consequent;
209
+ }
210
+ const index = body ? body.indexOf(current) : -1;
211
+ if (body && index > 0) {
212
+ const origin = originBeforeStatement(parent, body, index, cache);
213
+ if (origin) {
214
+ return origin;
215
+ }
216
+ }
217
+ if ((0, playwright_selectors_1.isTestScopeBoundary)(parent)) {
218
+ return null;
219
+ }
220
+ current = parent;
221
+ parent = parent.parent;
222
+ }
223
+ return null;
224
+ }
225
+ // Any mention of menu markup at all, used to confirm that a bare top-level
226
+ // label really is the menu bar. Wider than the patterns above because it is
227
+ // matched against every string in the test, not against a gesture's selector.
228
+ const ANY_MENU_MARKUP_PATTERN = /\blm-Menu|#jp-mainmenu-|role\s*=\s*["']?menuitem|role\s*=\s*["']?menu["']?\s*\]|data-type\s*=\s*["']?submenu/;
229
+ // The word itself, matched only against a test title.
230
+ const MENU_WORD_PATTERN = /menus?\b/i;
231
+ /**
232
+ * Whether the test around `node` is about a menu.
233
+ *
234
+ * `page.click('text=File')` carries no DOM evidence: the eight built-in labels
235
+ * are ordinary words, and a dialog button reading `Run` looks the same. A test
236
+ * that walks the menu bar names the menu somewhere, in its title or in a
237
+ * selector that reaches the popup it opened, so that mention is what separates
238
+ * the two.
239
+ *
240
+ * The title takes the bare word, because a person wrote it to describe the
241
+ * test. Every other string has to carry real markup: `menu` inside a selector
242
+ * or a file name says nothing.
243
+ */
244
+ function testMentionsMenuMarkup(node) {
245
+ const scope = (0, playwright_selectors_1.enclosingTestScope)(node);
246
+ // The title of a `test(…)` sits next to its callback rather than inside it.
247
+ // It is a sentence a person wrote about what the test does, so the bare word
248
+ // is enough there, where in a selector it would not be.
249
+ const enclosingCall = scope.parent;
250
+ if (enclosingCall?.type === 'CallExpression') {
251
+ const title = enclosingCall.arguments[0];
252
+ if (title?.type === 'Literal' &&
253
+ typeof title.value === 'string' &&
254
+ MENU_WORD_PATTERN.test(title.value)) {
255
+ return true;
256
+ }
257
+ }
258
+ let found = false;
259
+ (0, ast_1.walkFrom)(scope, current => {
260
+ if ((current.type === 'Literal' && typeof current.value === 'string'
261
+ ? ANY_MENU_MARKUP_PATTERN.test(current.value)
262
+ : false) ||
263
+ (current.type === 'TemplateElement' &&
264
+ ANY_MENU_MARKUP_PATTERN.test(current.value.cooked ?? ''))) {
265
+ found = true;
266
+ return 'stop';
267
+ }
268
+ return undefined;
269
+ });
270
+ return found;
271
+ }
272
+ /**
273
+ * Whether a click on popup menu markup is walking the main menu.
274
+ *
275
+ * Lumino gives every menu the same markup: `.lm-Menu` for the widget node,
276
+ * `role="menu"` for its content, `.lm-Menu-item` and `role="menuitem"` for its
277
+ * items. The context menu shares it, and so does every dropdown opened from a
278
+ * toolbar button. JupyterLab builds six of those on its own (the console
279
+ * prompt menu, the debugger pause-on-exceptions menu, two file editor menus,
280
+ * the terminal theme menu, the table of contents toolbar menu), and extensions
281
+ * add more, none of which `page.menu` drives. So popup markup alone proves
282
+ * nothing and the rule needs the main menu to have been opened first.
283
+ *
284
+ * A `#jp-mainmenu-…` id settles it from the selector. Otherwise the last
285
+ * menu-opening gesture before this one has to be a menu bar click, either raw
286
+ * or through `page.menu.open`.
287
+ */
288
+ function isMainMenuTraversal(node, selectorText, cache) {
289
+ // No context menu and no dropdown carries a `#jp-mainmenu-…` id, and none is
290
+ // inside the menu bar, so either settles it regardless of what came before.
291
+ if (MAIN_MENU_ID_PATTERN.test(selectorText) ||
292
+ MENU_BAR_CONTAINER_PATTERN.test(selectorText)) {
293
+ return true;
294
+ }
295
+ return findMenuOrigin(node, cache) === 'menubar';
296
+ }
297
+ const galataPreferMenuHelper = (0, create_rule_1.createRule)({
298
+ name: 'galata-prefer-menu-helper',
299
+ meta: {
300
+ type: 'suggestion',
301
+ docs: {
302
+ description: 'Prefer the Galata menu helper over raw Playwright selectors for JupyterLab main menu traversal'
303
+ },
304
+ messages: {
305
+ preferMenuOpen: 'Prefer `page.menu.openLocator(path)` (or `page.menu.clickMenuItem(path)`) over clicking the main menu bar directly.',
306
+ preferClickMenuItem: "Prefer `page.menu.clickMenuItem(path)` (e.g. `'File>New>Terminal'`) over raw selectors to click a menu item.",
307
+ preferMenuHelper: 'Prefer the Galata `page.menu` helper (e.g. `page.menu.openLocator(path)`, `page.menu.isOpen(path)`) over raw main menu selectors.'
308
+ },
309
+ schema: []
310
+ },
311
+ defaultOptions: [],
312
+ create(context) {
313
+ // Keyed by block node, so it is per file without being reset by hand.
314
+ const prefixCache = new WeakMap();
315
+ return {
316
+ CallExpression(node) {
317
+ // Most call expressions are not interactions at all, and
318
+ // `matchSelectorInteraction` rejects them on the callee alone, so the
319
+ // scope is looked up only once something actually needs it.
320
+ let scope = null;
321
+ const currentScope = () => (scope ?? (scope = context.sourceCode.getScope(node)));
322
+ const match = (0, playwright_selectors_1.matchSelectorInteraction)(node, identifier => (0, playwright_selectors_1.resolveLocatorBinding)(identifier, currentScope()));
323
+ if (!match) {
324
+ return;
325
+ }
326
+ if (match.interactionMethod !== MENU_INTERACTION_METHOD) {
327
+ return;
328
+ }
329
+ // Right-clicks open the context menu, not the main menu.
330
+ if (match.isRightClick) {
331
+ return;
332
+ }
333
+ const selectorText = (0, playwright_selectors_1.combineStaticSelectorText)(match);
334
+ if (selectorText === null) {
335
+ return;
336
+ }
337
+ const { hasPopupContainer, hasMenuMarkup, hasTopLevelMarker } = readMenuEvidence(selectorText);
338
+ if (!hasTopLevelMarker && !hasPopupContainer && !hasMenuMarkup) {
339
+ return;
340
+ }
341
+ // `getByRole('menuitem', { name })` carries no scope at all: a menu bar
342
+ // item, a main menu item and a right-click context menu item are all
343
+ // `role="menuitem"` with an accessible name. An exact top-level label
344
+ // is unambiguous on that evidence alone, and a popup container in the
345
+ // same chain settles it too. Failing both, the menu bar click that
346
+ // opened the menu answers it, which is the
347
+ // `getByRole('menuitem', { name: 'File' })` then
348
+ // `getByRole('menuitem', { name: 'Open from Path' })` idiom of the
349
+ // Notebook and JupyterLite suites. With none of the three the target
350
+ // could be a context menu item, which the planned context menu rule
351
+ // covers.
352
+ const viaGetByRole = match.selectorParts.some(part => part.method === 'getByRole');
353
+ if (viaGetByRole &&
354
+ !hasTopLevelMarker &&
355
+ !hasPopupContainer &&
356
+ findMenuOrigin(node, prefixCache) !== 'menubar') {
357
+ return;
358
+ }
359
+ // A popup container proves the target sits inside an already open menu,
360
+ // so it wins over a top-level label appearing in the same selector.
361
+ if (hasTopLevelMarker && !hasPopupContainer) {
362
+ // A label on its own is just a word. `File`, `Run` and `Help` name
363
+ // dialog buttons and file names too, so a selector carrying nothing
364
+ // but the label needs the test to mention menu markup somewhere.
365
+ if (!hasMenuMarkup &&
366
+ !MAIN_MENU_ID_PATTERN.test(selectorText) &&
367
+ !testMentionsMenuMarkup(node)) {
368
+ return;
369
+ }
370
+ context.report({
371
+ node: match.callNode,
372
+ messageId: 'preferMenuOpen'
373
+ });
374
+ return;
375
+ }
376
+ // Everything left is a click inside some open popup menu. Which one it
377
+ // is has to come from what opened it; a context menu belongs to the
378
+ // planned context menu rule, and a toolbar dropdown to no rule at all.
379
+ if (!isMainMenuTraversal(node, selectorText, prefixCache)) {
380
+ return;
381
+ }
382
+ // Without an item label there is no path to suggest, so fall back to
383
+ // the generic helper message.
384
+ context.report({
385
+ node: match.callNode,
386
+ messageId: TEXT_SELECTOR_PATTERN.test(selectorText)
387
+ ? 'preferClickMenuItem'
388
+ : 'preferMenuHelper'
389
+ });
390
+ }
391
+ };
392
+ }
393
+ });
394
+ module.exports = galataPreferMenuHelper;
@@ -0,0 +1,6 @@
1
+ import { TSESLint } from '@typescript-eslint/utils';
2
+ type MessageIds = 'preferSetCell' | 'preferEnterCellEditingMode' | 'preferSelectCells' | 'preferRunCell';
3
+ declare const galataPreferNotebookCellHelper: TSESLint.RuleModule<MessageIds, [], unknown, TSESLint.RuleListener> & {
4
+ name: string;
5
+ };
6
+ export = galataPreferNotebookCellHelper;