lexical

Lexical version: 0.49 Steps To Reproduce Write a function that accepts a callback and passes it an arrow function with a $-function call inside. Store the result in a variable. Example: The current behavior The rule requires that a variable name begin with the $ prefix But this is pointless, since the function result can be used both inside the lexical context and outside of it (in this case, in the React renderer) The expected behavior The rule is not triggered by a non-function variable Impact of fix Extra prefixes in variables make it difficult to immediately determine whether a lexical context function is stored there or whether this is a side effect of the linter's autofix

Description In order to enable tree-shaking we added annotations to module-scoped calls in the source, enforced by lint. This injects them at build time with a vite/rollup plugin so they don't clutter the source and encourage cargo-culting them into places where they don't belong. This transform also gives us an opportunity to inline the trivial ones into the build product since they are function calls for type inference purposes and have no utility at runtime. For example: An annotated definition is only droppable when everything it is built from is droppable too, so one unannotated call in its arguments silently pins it. The build now fails on that instead (), naming the call — and the calls that used to need a hand-written annotation for this reason, and friends, are annotated by the transform like any other. More detailed description of the implementation Module-scope calls to the side-effect-free factories (, , , , …) need a annotation for bundlers to tree-shake unused definitions. Until now those annotations lived in the sources, enforced by the ESLint rule: 442 of them across 131 files, and a lint-fix round trip for every new definition. This injects them at build time instead, from a new published package ** — Lexical's build-time compiler, whose first pass this is, with codegen for / to follow. Each pass is its own entry point (), and the root re-exports all of them: — a Vite/Rollup plugin (, so it runs after TypeScript/JSX is compiled away) — the transform itself, for bundlers with no Rollup-style plugin API / / , and — the same resolution without rewriting the module, which is how the lint rule decides It runs in (the published bundles carry the annotations exactly as before) and in (playground, examples, dev-examples). The annotations are gone from the sources, and is replaced by its inverse, , so a branch written before this migrates with instead of by hand. It only touches module-scope calls to the factories the build annotates — an annotation on a third-party factory or inside a function body was written deliberately and is left alone. Publishing it is what keeps -mode consumers whole: anyone resolving Lexical through the export condition (a vendored copy, a ed checkout) adds the same plugin and gets the same annotations — for their own extension and command definitions too. The linked-checkout docs describe the setup, and the source-mode integration fixture uses it. Which calls get annotated. The transform resolves the callee to its binding and only annotates when it is imported from / (configurable), declared with in the module or one it imports relatively, or is a method of an object marked . A same-named from your own is left alone — annotating a call that does have side effects would let a bundler drop it. A declaration is evidence on its own, so marking a factory of your own is enough; it does not also have to be named in the list. The specifier is what decides, which matters for a short name like : one imported from or declared locally without the marker is not touched, and default imports are not followed, and a block that rebinds the name is left alone inside itself. is what makes the annotations a guarantee rather than a habit: it walks the arguments of every module-scope definition and fails on a call nothing has established is side-effect free (). Calls that only run later — a callback, a body — pin nothing and are not counted, and neither are the built-ins every bundler treats as pure. Both this repo's builds turn it on. A dependency is annotated as usual but never checked — including a Lexical resolved out of through its condition, which is the case this package exists for; a definition somebody else shipped is not the building project's to fix. It found four real pins in the examples, and objects whose methods build values and touch nothing else ( in ) are now marked , so their calls are annotated by the build rather than by hand — only the outermost call of a chain, which rollup, terser and esbuild all accept as covering the whole chain. goes further for the factories whose implementation is a trivial expression over their arguments — // (identity), / (their arguments as an array) — replacing the call with that literal and removing the import left behind: A literal needs no annotation to be dropped and nothing is left to pin the definition. Calls that do not fit their form (spread arguments, a discarded result) are annotated as usual, and the call's parentheses are kept where they were doing work. is deliberately not inlined: is more bytes than a call to a minified one-character name. Each inlined factory is marked where it is defined. For a non-Lexical source that marker is what makes inlining possible at all — proves a call is safe to drop, only the marker says what it can be replaced with. Unit tests check that the markers in the tree and the transform's table agree, and that evaluating what the transform emits matches what the real function returns, so editing one of these bodies fails there rather than silently producing wrong code. is off by default in the published plugin (it assumes a matching Lexical version); Lexical's own build turns it on. Test plan , the unit suite and the integration suite pass. What the new tests cover: re-runs the transform over every built artifact and requires nothing left to annotate and nothing left to inline — the check that catches the plugin falling out of . Unit tests bundle a module with Rollup, factories in an external module so the bundler cannot infer purity itself, and assert an unused definition survives without the plugin and is dropped with it — including the nested-argument case that pins the enclosing definition, and the inlined case where no annotation is involved at all. Unit tests check that the markers in the tree and the transform's table agree, and that evaluating what the transform emits matches what the real function returns, so editing one of these bodies fails there rather than silently producing wrong code. The strict check is exercised over the whole tree by the build itself, plus unit tests for the deferred-call, pure-built-in, annotated-by-hand and dependency cases. A test holds and the declarations to each other, so a factory in the list that never says fails there (it found one: ). Tests cover which sources are trusted for a namespace, and that a shadowing block turns the annotation off for the calls inside it. The source-mode integration fixture additionally asserts that every module-scope factory call in its bundle is annotated and that no calls to the trivial factories remain. The published bundles are unchanged in substance — that is the point, the injected annotations reproduce what the hand-written ones did — and builds about 10% smaller with the annotations than without.

I've copied over the playground and made a stripped down editor for a form submission page. I HAVE NOT written any custom code yet, I've only been removing or hiding elements from the toolbar I don't need, and I've added load editor content that was saved on initial render. I've found that adding a Youtube video embed works perfectly when you're editing and doing whatever in the editor. Though the next time the editor loads with the video node inside the onloaded content the behavior of enter becomes incredibly weird, instead of a new line being added where the cursor is, the cursor will instead move to the next line. Hitting enter a second time will delete the line the cursor is on and then behavior will return to normal and everything will continue working as expected. This behavior seems to happen with image too, not sure if it's all embeddable block types of node, haven't done testing with the others since I don't need them. Lexical version: 0.49.0 Steps To Reproduce 1. Insert a Youtube embed 2. Save the editor content 3. Reload the editor with the Youtube node there 4. Enter behaves weirdly regardless of where you click or start typing from Link to code example: N/A - As another test case for playground made it should be able to load previously saved state because behavior seems to change when its a clean state and when there's content already in the editor before typing. The current behavior When lexical loads with the video node enter behavior is weird until you manage to create a new line by pressing enter twice, then it's focus and keyboard behavior will return to normal. The expected behavior When lexical loads with a video node, enter should create a new line just as it does when you're typing normally. Impact of fix How severe is this bug? Medium to High I Guess? How often does it happen? Every single time the lexical editor loads with custom content that includes the video node. The fix would benefit 10,000s of users,