diff --git a/docs/diagrams/model-tree-structure.mmd b/docs/diagrams/model-tree-structure.mmd index b7f54b2a..2db37cee 100644 --- a/docs/diagrams/model-tree-structure.mmd +++ b/docs/diagrams/model-tree-structure.mmd @@ -68,30 +68,24 @@ classDiagram +update(value: T) } - class ParentInlineNode { - <> - +children: InlineNode[] - +insertText(text, index?) - +removeText(start?, end?) - +format(tool, start, end, data?) - +unformat(tool, start, end) - +getFragments(start?, end?): InlineFragment[] + class RunList { + +length: number + +insert(text, offset) + +remove(start, end): string + +setMark(start, end, mark) + +removeMark(start, end, tool) + +toFragments(): InlineFragment[] } - class FormattingInlineNode { - +tool: InlineToolName - +data?: InlineToolData - +format(tool, start, end, data?) - +unformat(tool, start, end) - +split(index): FormattingInlineNode + class TextRun { + +text: string + +marks: TextMark[] } - class TextInlineNode { - +value: string - +length: number - +insertText(text, index?) - +removeText(start?, end?) - +format(tool, start, end, data?): InlineNode[] + class TextMark { + +tool: InlineToolName + +data?: InlineToolData + +equals(mark): boolean } %% ── Caret management ───────────────────────────── @@ -125,7 +119,7 @@ classDiagram BlockNode --|> EventBus BlockTune --|> EventBus ValueNode --|> EventBus - ParentInlineNode --|> EventBus + TextNode --|> EventBus %% Document composition EditorJSModel "1" *-- "1" EditorDocument : document @@ -136,11 +130,10 @@ classDiagram BlockNode "1" *-- "0..*" ValueNode : data[key] BlockNode "1" *-- "0..*" BlockTune : tunes[name] - %% Inline tree - TextNode --|> ParentInlineNode - FormattingInlineNode --|> ParentInlineNode - ParentInlineNode "1" *-- "0..*" FormattingInlineNode : children - ParentInlineNode "1" *-- "0..*" TextInlineNode : children + %% Inline formatting runs + TextNode "1" *-- "1" RunList : runs + RunList "1" *-- "0..*" TextRun : runs + TextRun "1" o-- "0..*" TextMark : marks %% Caret management (declared last → placed right) EditorJSModel "1" *-- "1" CaretManager : caretManager diff --git a/docs/model.md b/docs/model.md index b01c057d..2d4cf58b 100644 --- a/docs/model.md +++ b/docs/model.md @@ -8,7 +8,7 @@ Internally it owns an `EditorDocument` (ordered `BlockNode[]`) and a `CaretManag Each `BlockNode` contains keyed data nodes: -- `TextNode`: rich text with inline tree (`FormattingInlineNode` + `TextInlineNode`). +- `TextNode`: rich text. Inline formatting is stored as runs: pieces of text with the set of marks (inline tool + data) applied to every character. Runs are canonical (no empty runs, neighbours never have equal mark sets, at most one mark per tool), so the same formatting always gives the same state. `getFragments()` derives maximal fragments from the runs, sorted by start, then end descending, then tool name. - `ValueNode`: non-text typed value for tools. - `BlockTune`: per-block tune configuration. diff --git a/openspec/changes/inline-fragments-flat-runs/tasks.md b/openspec/changes/inline-fragments-flat-runs/tasks.md index 56ab154e..96fe6aad 100644 --- a/openspec/changes/inline-fragments-flat-runs/tasks.md +++ b/openspec/changes/inline-fragments-flat-runs/tasks.md @@ -1,43 +1,43 @@ ## 1. Regression and contract tests (against the current tree) -- [ ] 1.1 Add order-independence tests to `packages/model/src/entities/inline-text/TextNode/TextNode.integration.spec.ts` (the unit spec mocks the tree): `should return the same fragments when equal formatting is applied in a different order` (bold 0–2, italic 0–4, bold 2–4 vs bold 0–4, italic 0–4), `should merge fragments split by other formatting` (bold 0–3, italic 1–3, italic 3–6, bold 3–5 → bold 0–5, italic 1–6), `should return a single fragment when a tool is applied over an existing shorter fragment of another tool` (italic 1–3, bold 0–4), and `should return the same fragments when constructed with fragments in a different order`. Confirm they fail on the current implementation -- [ ] 1.2 Add fragment order tests: `should return a containing fragment before the contained one` and `should order fragments with equal ranges by tool name` -- [ ] 1.3 Add behaviour-preservation tests that pass on the current implementation: insertion inheritance (at the end of a formatted stretch, at index 0, after unformatted text, into empty text), range queries (partial overlap returns the whole fragment, touching fragments and empty ranges return nothing, filtering by tool), data replacement and the identical-data no-op, adjacent equal/different data, `removeText` inside formatting, removing all formatted text, `removeText` joining equal fragments, unformat restoring the previous state, zero-length format, and the validation errors -- [ ] 1.4 Commit the tests on their own so the implementation commit shows only the failing order-dependent cases turning green +- [x] 1.1 Add order-independence tests to `packages/model/src/entities/inline-text/TextNode/TextNode.integration.spec.ts` (the unit spec mocks the tree): `should return the same fragments when equal formatting is applied in a different order` (bold 0–2, italic 0–4, bold 2–4 vs bold 0–4, italic 0–4), `should merge fragments split by other formatting` (bold 0–3, italic 1–3, italic 3–6, bold 3–5 → bold 0–5, italic 1–6), `should return a single fragment when a tool is applied over an existing shorter fragment of another tool` (italic 1–3, bold 0–4), and `should return the same fragments when constructed with fragments in a different order`. Confirm they fail on the current implementation +- [x] 1.2 Add fragment order tests: `should return a containing fragment before the contained one` and `should order fragments with equal ranges by tool name` +- [x] 1.3 Add behaviour-preservation tests that pass on the current implementation: insertion inheritance (at the end of a formatted stretch, at index 0, after unformatted text, into empty text), range queries (partial overlap returns the whole fragment, touching fragments and empty ranges return nothing, filtering by tool), data replacement and the identical-data no-op, adjacent equal/different data, `removeText` inside formatting, removing all formatted text, `removeText` joining equal fragments, unformat restoring the previous state, zero-length format, and the validation errors +- [x] 1.4 Commit the tests on their own so the implementation commit shows only the failing order-dependent cases turning green ## 2. Run model -- [ ] 2.1 Write failing tests for the private run helpers (`RunList/RunList.spec.ts`, `TextMark/TextMark.spec.ts`): `splitAt` (inside a run, on a boundary, at 0 and at the end), `merge` (equal neighbours joined, empty runs dropped, different data kept apart), and the fragment sweep (open/close on data change, maximal fragments, sort order) -- [ ] 2.2 Implement `TextMark` (immutable, `equals()` using `isSameInlineData`), `TextRun` (immutable data) and `RunList` (owns the runs and their invariants) classes under `inline-text/`, with mark equality only through `TextMark#equals` -- [ ] 2.3 Add a test-only `expectRunInvariants(runList)` helper (`RunList/runInvariants.testing.ts`, excluded from Stryker) checking no empty runs, no equal neighbours, one mark per tool and marks sorted by tool. Call it after every `RunList` spec and after every operation in the `RunList` random sequences (`RunList/RunList.random.spec.ts`). Keep `TextNode` free of test-only API +- [x] 2.1 Write failing tests for the private run helpers (`RunList/RunList.spec.ts`, `TextMark/TextMark.spec.ts`): `splitAt` (inside a run, on a boundary, at 0 and at the end), `merge` (equal neighbours joined, empty runs dropped, different data kept apart), and the fragment sweep (open/close on data change, maximal fragments, sort order) +- [x] 2.2 Implement `TextMark` (immutable, `equals()` using `isSameInlineData`), `TextRun` (immutable data) and `RunList` (owns the runs and their invariants) classes under `inline-text/`, with mark equality only through `TextMark#equals` +- [x] 2.3 Add a test-only `expectRunInvariants(runList)` helper (`RunList/runInvariants.testing.ts`, excluded from Stryker) checking no empty runs, no equal neighbours, one mark per tool and marks sorted by tool. Call it after every `RunList` spec and after every operation in the `RunList` random sequences (`RunList/RunList.random.spec.ts`). Keep `TextNode` free of test-only API ## 3. TextNode on runs -- [ ] 3.1 Rewrite `TextNode` to extend `EventBus` directly and store `#runs`: implement `length`, `getText`, `insertText`, `removeText`, `format`, `unformat`, `getFragments` and `serialized` as in design Decisions 2–5, dispatching the same events with the same payloads and keeping the current validation error messages -- [ ] 3.2 Make `format`/`unformat` return `void` and update their callers' types if needed (`BlockNode`) -- [ ] 3.3 Make the section 1 and 2 tests pass -- [ ] 3.4 Add the seeded random-sequence test (no new dependency, shared generator and reference model in `specs/randomOperations.testing.ts`, `TextNode/TextNode.random.spec.ts`): random `insertText`/`removeText`/`format`/`unformat` sequences compare text and fragments with a per-character reference model after every operation, then check that a `TextNode` rebuilt from `serialized` returns the same fragments, and that shuffling the serialized fragments before rebuilding gives the same result +- [x] 3.1 Rewrite `TextNode` to extend `EventBus` directly and store `#runs`: implement `length`, `getText`, `insertText`, `removeText`, `format`, `unformat`, `getFragments` and `serialized` as in design Decisions 2–5, dispatching the same events with the same payloads and keeping the current validation error messages +- [x] 3.2 Make `format`/`unformat` return `void` and update their callers' types if needed (`BlockNode`) +- [x] 3.3 Make the section 1 and 2 tests pass +- [x] 3.4 Add the seeded random-sequence test (no new dependency, shared generator and reference model in `specs/randomOperations.testing.ts`, `TextNode/TextNode.random.spec.ts`): random `insertText`/`removeText`/`format`/`unformat` sequences compare text and fragments with a per-character reference model after every operation, then check that a `TextNode` rebuilt from `serialized` returns the same fragments, and that shuffling the serialized fragments before rebuilding gives the same result ## 4. Remove the tree -- [ ] 4.1 Delete `ParentInlineNode`, `FormattingInlineNode`, `TextInlineNode`, `InlineNode` and the `ParentNode`/`ChildNode` mixins with their mocks and specs, and remove their exports from `inline-text/index.ts` -- [ ] 4.2 Port `specs/InlineTree.integration.spec.ts` to the `TextNode` API as `specs/InlineFormatting.integration.spec.ts`, rewrite `TextNode/TextNode.spec.ts` without tree mocks, and drop the specs of the removed classes -- [ ] 4.3 Run the whole model test suite plus the `core`, `dom-adapters` and `collaboration-manager` suites, and fix anything that relied on the removed classes or on the old fragment order +- [x] 4.1 Delete `ParentInlineNode`, `FormattingInlineNode`, `TextInlineNode`, `InlineNode` and the `ParentNode`/`ChildNode` mixins with their mocks and specs, and remove their exports from `inline-text/index.ts` +- [x] 4.2 Port `specs/InlineTree.integration.spec.ts` to the `TextNode` API as `specs/InlineFormatting.integration.spec.ts`, rewrite `TextNode/TextNode.spec.ts` without tree mocks, and drop the specs of the removed classes +- [x] 4.3 Run the whole model test suite plus the `core`, `dom-adapters` and `collaboration-manager` suites, and fix anything that relied on the removed classes or on the old fragment order ## 5. Docs and wrap-up -- [ ] 5.1 Update `docs/model.md` (the `TextNode` bullet) and `docs/diagrams/model-tree-structure.mmd` (replace the `ParentInlineNode`/`FormattingInlineNode`/`TextInlineNode` classes with the run model) to describe runs -- [ ] 5.2 Run `yarn lint` for the touched packages and `test:mutations` for `@editorjs/model`; make sure the score stays above the threshold -- [ ] 5.3 Check formatting in the playground once by hand (overlapping bold/italic, undo/redo of formatting) -- [ ] 5.4 Run `openspec validate inline-fragments-flat-runs --type change` and make sure it passes +- [x] 5.1 Update `docs/model.md` (the `TextNode` bullet) and `docs/diagrams/model-tree-structure.mmd` (replace the `ParentInlineNode`/`FormattingInlineNode`/`TextInlineNode` classes with the run model) to describe runs +- [x] 5.2 Run `yarn lint` for the touched packages and `test:mutations` for `@editorjs/model`; make sure the score stays above the threshold +- [x] 5.3 Check formatting in the playground once by hand (overlapping bold/italic, undo/redo of formatting) +- [x] 5.4 Run `openspec validate inline-fragments-flat-runs --type change` and make sure it passes ## 6. Review fixes -- [ ] 6.1 Write failing tests, then store empty data as no data in `TextMark`, so equal data can't serialize differently depending on operation order -- [ ] 6.2 Write failing tests, then make `TextMark` keep a deep copy of its data and `RunList#toFragments` return copies (`cloneInlineData` in `utils/`) -- [ ] 6.3 Write failing tests, then apply initial fragments in a total order (start, end descending, tool, data) so conflicting fragments load the same in any order -- [ ] 6.4 Extend the shared random generator with empty data for non-link tools and random, possibly conflicting, initial fragments loaded in shuffled order against the reference model -- [ ] 6.5 Cache `RunList#length`, drop the `#merge` call for inserting into an empty list, and fold `getFragments` filters into one predicate -- [ ] 6.6 Write a failing test, then put a separate copy of the inline data into `TextFormattedEvent`, so mutating the caller's object can't change collaboration operations or undo history built from the event -- [ ] 6.7 Write failing tests, then make `FormattingAdapter` re-query fragments over the widened re-render range until it stops growing (`collectFragmentsToRender` in `dom-adapters/src/utils/`), and start the range from the edit rather than from the first fragment -- [ ] 6.8 Write failing jsdom-backed `FormattingAdapter` tests (literal tags, entity-like text, HTML in text), then rebuild re-rendered ranges from a text node instead of `template.innerHTML`. Run `dom-adapters` Jest in jsdom and ESM mode so the specs can import the ESM `sdk` build +- [x] 6.1 Write failing tests, then store empty data as no data in `TextMark`, so equal data can't serialize differently depending on operation order +- [x] 6.2 Write failing tests, then make `TextMark` keep a deep copy of its data and `RunList#toFragments` return copies (`cloneInlineData` in `utils/`) +- [x] 6.3 Write failing tests, then apply initial fragments in a total order (start, end descending, tool, data) so conflicting fragments load the same in any order +- [x] 6.4 Extend the shared random generator with empty data for non-link tools and random, possibly conflicting, initial fragments loaded in shuffled order against the reference model +- [x] 6.5 Cache `RunList#length`, drop the `#merge` call for inserting into an empty list, and fold `getFragments` filters into one predicate +- [x] 6.6 Write a failing test, then put a separate copy of the inline data into `TextFormattedEvent`, so mutating the caller's object can't change collaboration operations or undo history built from the event +- [x] 6.7 Write failing tests, then make `FormattingAdapter` re-query fragments over the widened re-render range until it stops growing (`collectFragmentsToRender` in `dom-adapters/src/utils/`), and start the range from the edit rather than from the first fragment +- [x] 6.8 Write failing jsdom-backed `FormattingAdapter` tests (literal tags, entity-like text, HTML in text), then rebuild re-rendered ranges from a text node instead of `template.innerHTML`. Run `dom-adapters` Jest in jsdom and ESM mode so the specs can import the ESM `sdk` build diff --git a/openspec/config.yaml b/openspec/config.yaml index b3cba3b5..157aaf40 100644 --- a/openspec/config.yaml +++ b/openspec/config.yaml @@ -4,7 +4,7 @@ context: | Tech stack: TypeScript, Yarn 4 (Berry) workspaces monorepo (packages/*, packages/tools/*). Domain: Editor.js document model - a collaborative rich-text editor engine (block/inline data tree, operational-transform based collaboration, pluggable block/inline tools). - Key packages: model (EditorJSModel/EditorDocument/BlockNode/inline-fragments/CaretManager), + Key packages: model (EditorJSModel/EditorDocument/BlockNode/inline-text/CaretManager), model-types (shared event/type contracts), core, dom-adapters, ot-server (collaboration/OT server), sdk (public API for building tools/plugins - tools should depend on this, not on model directly), ui, collaboration-manager, and packages/tools/* (built-in block/inline diff --git a/packages/dom-adapters/jest.config.ts b/packages/dom-adapters/jest.config.ts index 999ea6af..77abfe53 100644 --- a/packages/dom-adapters/jest.config.ts +++ b/packages/dom-adapters/jest.config.ts @@ -2,7 +2,7 @@ import type { JestConfigWithTsJest } from 'ts-jest'; export default { preset: 'ts-jest', - testEnvironment: 'node', + testEnvironment: 'jsdom', testMatch: [ '/src/**/*.spec.ts' ], modulePathIgnorePatterns: [ '/.*/__mocks__' ], extensionsToTreatAsEsm: ['.ts'], diff --git a/packages/dom-adapters/package.json b/packages/dom-adapters/package.json index 8fead328..7d15271c 100644 --- a/packages/dom-adapters/package.json +++ b/packages/dom-adapters/package.json @@ -12,9 +12,9 @@ "lint": "eslint ./src", "lint:ci": "yarn lint --max-warnings 0", "lint:fix": "yarn lint --fix", - "test": "jest", + "test": "node --experimental-vm-modules $(yarn bin jest)", "test:coverage": "yarn test --coverage=true", - "test:mutations": "stryker run", + "test:mutations": "NODE_OPTIONS=\"$NODE_OPTIONS --experimental-vm-modules\" stryker run", "clear": "rm -rf ./dist && rm -rf ./tsconfig.build.tsbuildinfo" }, "devDependencies": { @@ -28,6 +28,7 @@ "eslint-config-codex": "^2.0.3", "eslint-plugin-import": "^2.29.0", "jest": "^29.7.0", + "jest-environment-jsdom": "^29.7.0", "stryker-cli": "^1.0.2", "ts-jest": "^29.2.5", "ts-node": "^10.9.2", diff --git a/packages/dom-adapters/src/FormattingAdapter/FormattingAdapter.spec.ts b/packages/dom-adapters/src/FormattingAdapter/FormattingAdapter.spec.ts new file mode 100644 index 00000000..df640452 --- /dev/null +++ b/packages/dom-adapters/src/FormattingAdapter/FormattingAdapter.spec.ts @@ -0,0 +1,224 @@ +/* eslint-disable @typescript-eslint/no-magic-numbers */ +import 'reflect-metadata'; +import { describe, expect, it, jest } from '@jest/globals'; +import type { DataKey, EditorAPI, EventBus, InlineFragment, InlineTool, InlineToolName } from '@editorjs/sdk'; +import { Index, TextFormattedEvent, TextUnformattedEvent } from '@editorjs/sdk'; +import type { CaretAdapter } from '../CaretAdapter/index.js'; + +/** + * The DOM helpers package ships extensionless ESM imports that Jest can't resolve + */ +jest.unstable_mockModule('@editorjs/dom', () => ({ + isNativeInput: jest.fn(() => false), +})); + +const { FormattingAdapter } = await import('./index.js'); + +const bold = 'bold' as InlineToolName; +const italic = 'italic' as InlineToolName; + +/** + * Creates an inline tool that wraps text in the passed tag + * @param tag - wrapper tag name + */ +function createTool(tag: string): InlineTool { + return { + createWrapper: () => document.createElement(tag), + } as unknown as InlineTool; +} + +/** + * Range passed to the API's getFragments() + */ +interface TextQuery { + start: number; + end: number; +} + +/** + * Adapter rendering into a single input, with the model's fragments under the test's control + */ +interface Harness { + input: HTMLElement; + + /** + * Replaces the model's fragments and dispatches a model event for the changed range + */ + format: (fragments: InlineFragment[], tool: InlineToolName, start: number, end: number) => void; + + /** + * Same as format, but dispatches an unformat event + */ + unformat: (fragments: InlineFragment[], tool: InlineToolName, start: number, end: number) => void; +} + +/** + * Creates the adapter with an input holding the passed text as a single text node + * @param text - input text, taken literally + */ +function createHarness(text: string): Harness { + const input = document.createElement('div'); + + /** + * An attribute rather than the contentEditable property, which jsdom doesn't implement: the adapter looks for the attribute + */ + input.setAttribute('contenteditable', 'true'); + input.append(document.createTextNode(text)); + document.body.append(input); + + let fragments: InlineFragment[] = []; + let onUpdate: (event: unknown) => void = () => undefined; + + const api = { + document: { + onUpdate: (callback: (event: unknown) => void) => { + onUpdate = callback; + + return () => undefined; + }, + }, + text: { + /** + * Model semantics: whole fragments sharing a character with the range + * @param query - text range to return fragments for + */ + getFragments: (query: TextQuery) => fragments + .filter(item => query.start < query.end && item.range[0] < query.end && item.range[1] > query.start), + }, + } as unknown as EditorAPI; + const caretAdapter = { findInput: () => input } as unknown as CaretAdapter; + const adapter = new FormattingAdapter(api, caretAdapter, new EventTarget() as EventBus); + + adapter.attachTool(bold, createTool('b')); + adapter.attachTool(italic, createTool('i')); + + const dispatch = (EventClass: typeof TextFormattedEvent | typeof TextUnformattedEvent, next: InlineFragment[], tool: InlineToolName, start: number, end: number): void => { + fragments = next; + onUpdate(new EventClass( + Index.text([ + { + blockIndex: 0, + dataKey: 'text' as DataKey, + textRange: [start, end], + }, + ]), + { tool }, + 'user' + )); + }; + + return { + input, + format: (next, tool, start, end) => dispatch(TextFormattedEvent, next, tool, start, end), + unformat: (next, tool, start, end) => dispatch(TextUnformattedEvent, next, tool, start, end), + }; +} + +/** + * Creates a fragment + * @param tool - inline tool name + * @param start - range start + * @param end - range end + */ +function fragment(tool: InlineToolName, start: number, end: number): InlineFragment { + return { + tool, + range: [start, end], + }; +} + +/** + * Returns the wrapper tags around each character of the input, sorted, e.g. ['b', 'b,i', ''] + * @param input - input element + */ +function tagsPerCharacter(input: HTMLElement): string[] { + const result: string[] = []; + const walker = document.createTreeWalker(input, NodeFilter.SHOW_TEXT); + + for (let node = walker.nextNode(); node !== null; node = walker.nextNode()) { + const tags: string[] = []; + + for (let parent = node.parentElement; parent !== null && parent !== input; parent = parent.parentElement) { + tags.push(parent.tagName.toLowerCase()); + } + + const key = tags.sort().join(','); + + for (let index = 0; index < (node.textContent ?? '').length; index++) { + result.push(key); + } + } + + return result; +} + +describe('FormattingAdapter', () => { + describe('text that looks like markup', () => { + it('should keep literal tags as text when re-rendering around them', () => { + const text = 'xyz'; + const { input, format } = createHarness(text); + + format([fragment(italic, 0, 10)], italic, 0, 10); + + expect(input.textContent).toBe(text); + expect(input.querySelectorAll('b')).toHaveLength(0); + expect(tagsPerCharacter(input)).toEqual(Array(10).fill('i')); + }); + + it('should keep entity-like text as it is', () => { + const text = 'a < b & c'; + const { input, format } = createHarness(text); + + format([fragment(bold, 2, 6)], bold, 2, 6); + + expect(input.textContent).toBe(text); + expect(tagsPerCharacter(input).slice(2, 6)).toEqual(['b', 'b', 'b', 'b']); + expect(tagsPerCharacter(input)[6]).toBe(''); + }); + + it('should not create elements from text that contains HTML', () => { + const text = ''; + const { input, format } = createHarness(text); + + format([fragment(bold, 0, 5)], bold, 0, 5); + + expect(input.querySelector('img')).toBeNull(); + expect(input.textContent).toBe(text); + expect((window as unknown as { injected?: boolean }).injected).toBeUndefined(); + }); + }); + + describe('re-rendering widened ranges', () => { + it('should keep formatting that only overlaps the widened range', () => { + const { input, format } = createHarness('abcdefghij'); + + format([fragment(italic, 0, 2)], italic, 0, 2); + format([fragment(bold, 0, 10), fragment(italic, 0, 2)], bold, 0, 10); + format([fragment(bold, 0, 10), fragment(italic, 0, 2), fragment(italic, 8, 9)], italic, 8, 9); + + expect(input.textContent).toBe('abcdefghij'); + expect(tagsPerCharacter(input)).toEqual(['b,i', 'b,i', 'b', 'b', 'b', 'b', 'b', 'b', 'b,i', 'b']); + }); + + it('should keep formatting around a partially unformatted fragment', () => { + const { input, format, unformat } = createHarness('abcdefghij'); + + format([fragment(bold, 0, 10)], bold, 0, 10); + format([fragment(bold, 0, 10), fragment(italic, 0, 2)], italic, 0, 2); + format([fragment(bold, 0, 10), fragment(italic, 0, 2), fragment(italic, 8, 10)], italic, 8, 10); + unformat([fragment(bold, 0, 4), fragment(italic, 0, 2), fragment(bold, 6, 10), fragment(italic, 8, 10)], bold, 4, 6); + + expect(input.textContent).toBe('abcdefghij'); + expect(tagsPerCharacter(input)).toEqual(['b,i', 'b,i', 'b', 'b', '', '', 'b', 'b', 'b,i', 'b,i']); + }); + + it('should re-render a range unformatted before a remaining fragment', () => { + const { input, format, unformat } = createHarness('abcdefghij'); + + format([fragment(bold, 2, 8)], bold, 2, 8); + unformat([fragment(bold, 5, 8)], bold, 2, 5); + + expect(tagsPerCharacter(input)).toEqual(['', '', '', '', '', 'b', 'b', 'b', '', '']); + }); + }); +}); diff --git a/packages/dom-adapters/src/FormattingAdapter/index.ts b/packages/dom-adapters/src/FormattingAdapter/index.ts index 320eb97f..39efced9 100644 --- a/packages/dom-adapters/src/FormattingAdapter/index.ts +++ b/packages/dom-adapters/src/FormattingAdapter/index.ts @@ -16,6 +16,7 @@ import { CoreEventType, EventBus } from '@editorjs/sdk'; import { surround } from '../utils/surround.js'; import { getBoundaryPointByAbsoluteOffset } from '../utils/getRelativeIndex.js'; import { expandRangeNodeBoundary } from '../utils/expandRangeNodeBoundary.js'; +import { collectFragmentsToRender } from '../utils/collectFragmentsToRender.js'; import { inject, injectable } from 'inversify'; import { TOKENS } from '../tokens.js'; @@ -146,19 +147,18 @@ export class FormattingAdapter { const inputContent = input.textContent; const rangeStart = Math.max(0, textRange[0] - 1); const rangeEnd = inputContent !== null ? Math.min(inputContent.length, textRange[1] + 1) : 0; - const affectedFragments = this.#api.text.getFragments({ - block: blockIndex, - key: dataKey as string, - start: rangeStart, - end: rangeEnd, - }); - const leftBoundary = affectedFragments[0]?.range[0] ?? textRange[0]; - let rightBoundary = textRange[1]; - - for (const fragment of affectedFragments) { - rightBoundary = Math.max(rightBoundary, fragment.range[1]); - } - this.#rerenderRange(input, leftBoundary, rightBoundary, affectedFragments); + const { start, end, fragments } = collectFragmentsToRender( + (queryStart, queryEnd) => this.#api.text.getFragments({ + block: blockIndex, + key: dataKey as string, + start: queryStart, + end: queryEnd, + }), + rangeStart, + rangeEnd + ); + + this.#rerenderRange(input, start, end, fragments); } /** @@ -186,11 +186,13 @@ export class FormattingAdapter { } /** - * Create temporary container to allow formatting of the extracted content + * Rebuild the range from its plain text, then wrap the fragments in it. + * The text goes in as a text node so it's never parsed as markup: literal `` or `<` in the text + * would otherwise turn into elements or other characters, shifting offsets and injecting live HTML */ - const template = document.createElement('template'); + const content = document.createDocumentFragment(); - template.innerHTML = range.toString()!; + content.append(document.createTextNode(range.toString())); for (const fragment of affectedFragments) { const tool = this.#tools.get(fragment.tool); @@ -207,10 +209,10 @@ export class FormattingAdapter { */ const wrapper = tool.createWrapper(fragment.data); - surround(wrapper, template.content, [relativeStart, relativeEnd]); + surround(wrapper, content, [relativeStart, relativeEnd]); } range.extractContents(); - range.insertNode(template.content); + range.insertNode(content); } } diff --git a/packages/dom-adapters/src/utils/collectFragmentsToRender.spec.ts b/packages/dom-adapters/src/utils/collectFragmentsToRender.spec.ts new file mode 100644 index 00000000..3d5c49c1 --- /dev/null +++ b/packages/dom-adapters/src/utils/collectFragmentsToRender.spec.ts @@ -0,0 +1,96 @@ +/* eslint-disable @typescript-eslint/no-magic-numbers */ +import { describe, expect, it, jest } from '@jest/globals'; +import type { InlineFragment, InlineToolName } from '@editorjs/sdk'; +import { collectFragmentsToRender } from './collectFragmentsToRender.js'; + +const bold = 'bold' as InlineToolName; +const italic = 'italic' as InlineToolName; + +/** + * Creates a fragment + * @param tool - inline tool name + * @param start - range start + * @param end - range end + */ +function fragment(tool: InlineToolName, start: number, end: number): InlineFragment { + return { + tool, + range: [start, end], + }; +} + +/** + * Returns a query over the fragments with the model's semantics: whole fragments sharing a character with the range + * @param fragments - all fragments of the input + */ +function queryOver(fragments: InlineFragment[]): jest.Mock<(start: number, end: number) => InlineFragment[]> { + return jest.fn((start: number, end: number) => fragments.filter(f => start < end && f.range[0] < end && f.range[1] > start)); +} + +describe('collectFragmentsToRender()', () => { + it('should return the range and its fragments when no fragment reaches outside', () => { + const query = queryOver([fragment(bold, 3, 5)]); + + expect(collectFragmentsToRender(query, 2, 6)).toEqual({ + start: 2, + end: 6, + fragments: [fragment(bold, 3, 5)], + }); + }); + + it('should include fragments that only overlap the widened range', () => { + /** + * italic [0,2), bold [0,10), italic [8,9) on "abcdefghij": the edit around [7,10) reaches bold [0,10), + * which brings italic [0,2) into the region to re-render + */ + const query = queryOver([fragment(bold, 0, 10), fragment(italic, 0, 2), fragment(italic, 8, 9)]); + + expect(collectFragmentsToRender(query, 7, 10)).toEqual({ + start: 0, + end: 10, + fragments: [fragment(bold, 0, 10), fragment(italic, 0, 2), fragment(italic, 8, 9)], + }); + }); + + it('should include fragments around a partially unformatted range', () => { + /** + * bold [0,10) with italic [0,2) and italic [8,10); unformatting bold over [4,6) leaves bold [0,4) and [6,10) + */ + const query = queryOver([fragment(bold, 0, 4), fragment(italic, 0, 2), fragment(bold, 6, 10), fragment(italic, 8, 10)]); + + expect(collectFragmentsToRender(query, 3, 7)).toEqual({ + start: 0, + end: 10, + fragments: [fragment(bold, 0, 4), fragment(italic, 0, 2), fragment(bold, 6, 10), fragment(italic, 8, 10)], + }); + }); + + it('should keep the range when the remaining fragment starts after it', () => { + const query = queryOver([fragment(bold, 5, 8)]); + + expect(collectFragmentsToRender(query, 1, 6)).toEqual({ + start: 1, + end: 8, + fragments: [fragment(bold, 5, 8)], + }); + }); + + it('should widen step by step until no new fragment is reached', () => { + const query = queryOver([fragment(bold, 4, 8), fragment(italic, 7, 12), fragment(bold, 11, 15)]); + + const result = collectFragmentsToRender(query, 5, 6); + + expect(result.start).toBe(4); + expect(result.end).toBe(15); + expect(result.fragments).toHaveLength(3); + expect(query).toHaveBeenLastCalledWith(4, 15); + }); + + it('should return no fragments for a range without formatting', () => { + expect(collectFragmentsToRender(queryOver([]), 2, 4)).toEqual({ + start: 2, + end: 4, + fragments: [], + }); + }); +}); diff --git a/packages/dom-adapters/src/utils/collectFragmentsToRender.ts b/packages/dom-adapters/src/utils/collectFragmentsToRender.ts new file mode 100644 index 00000000..2a4ce69e --- /dev/null +++ b/packages/dom-adapters/src/utils/collectFragmentsToRender.ts @@ -0,0 +1,58 @@ +import type { InlineFragment } from '@editorjs/sdk'; + +/** + * Range of an input to re-render with all the fragments overlapping it + */ +export interface FragmentsToRender { + /** + * Range start + */ + start: number; + + /** + * Range end + */ + end: number; + + /** + * All fragments sharing a character with the range + */ + fragments: InlineFragment[]; +} + +/** + * Collects the range to re-render around an edit, with every fragment overlapping it. + * + * Fragments are returned whole, so they can reach outside the queried range and overlap other fragments there. + * The range is widened to the fragments' boundaries and queried again until no new fragment is reached, + * so rendering the range from plain text with the returned fragments doesn't drop any formatting inside it + * @param getFragments - returns whole fragments sharing a character with the range + * @param start - start of the range around the edit + * @param end - end of the range around the edit + */ +export function collectFragmentsToRender( + getFragments: (start: number, end: number) => InlineFragment[], + start: number, + end: number +): FragmentsToRender { + let rangeStart = start; + let rangeEnd = end; + let fragments = getFragments(rangeStart, rangeEnd); + + for (;;) { + const widenedStart = Math.min(rangeStart, ...fragments.map(fragment => fragment.range[0])); + const widenedEnd = Math.max(rangeEnd, ...fragments.map(fragment => fragment.range[1])); + + if (widenedStart === rangeStart && widenedEnd === rangeEnd) { + return { + start: rangeStart, + end: rangeEnd, + fragments, + }; + } + + rangeStart = widenedStart; + rangeEnd = widenedEnd; + fragments = getFragments(rangeStart, rangeEnd); + } +} diff --git a/packages/dom-adapters/src/utils/selectionRangeInInput.spec.ts b/packages/dom-adapters/src/utils/selectionRangeInInput.spec.ts index ef90fb2f..61dc2f5c 100644 --- a/packages/dom-adapters/src/utils/selectionRangeInInput.spec.ts +++ b/packages/dom-adapters/src/utils/selectionRangeInInput.spec.ts @@ -1,17 +1,21 @@ /* eslint-disable @typescript-eslint/no-magic-numbers, jsdoc/require-jsdoc */ import { describe, it, expect, jest, beforeEach } from '@jest/globals'; -import { getAbsoluteRangeOffset } from './getAbsoluteRangeOffset.js'; -import { + +/** + * Tests run as ESM, where module mocks must be registered before the modules under test are imported + */ +jest.unstable_mockModule('./getAbsoluteRangeOffset.js', () => ({ + getAbsoluteRangeOffset: jest.fn(), +})); + +const { getAbsoluteRangeOffset } = await import('./getAbsoluteRangeOffset.js'); +const { getClippedTextRangeForInput, isInputContainsOnlyEndOfSelection, isInputContainsOnlyStartOfSelection, isInputContainsWholeSelection, - isInputInBetweenSelection -} from './selectionRangeInInput.js'; - -jest.mock('./getAbsoluteRangeOffset.js', () => ({ - getAbsoluteRangeOffset: jest.fn(), -})); + isInputInBetweenSelection, +} = await import('./selectionRangeInInput.js'); const mockedGetAbsoluteRangeOffset = jest.mocked(getAbsoluteRangeOffset); diff --git a/packages/model-types/src/Text.ts b/packages/model-types/src/Text.ts index 6e511036..1e1241d3 100644 --- a/packages/model-types/src/Text.ts +++ b/packages/model-types/src/Text.ts @@ -14,7 +14,11 @@ export interface InlineFragment { range: [start: number, end: number]; } -/** Serialized inline tree node containing text value and formatting fragments */ +/** + * Serialized text value with its formatting fragments + * @todo Rename: the model no longer stores inline formatting as a tree (TextNode keeps runs), so "InlineTree" is misleading. + * It is a public type, so the rename is breaking and needs a major release + */ export interface InlineTreeNodeSerialized { /** Text content */ value: string; diff --git a/packages/model/src/entities/BlockNode/BlockNode.spec.ts b/packages/model/src/entities/BlockNode/BlockNode.spec.ts index 801ab728..3bae7dcc 100644 --- a/packages/model/src/entities/BlockNode/BlockNode.spec.ts +++ b/packages/model/src/entities/BlockNode/BlockNode.spec.ts @@ -14,7 +14,7 @@ import type { ValueNodeConstructorParameters } from '../ValueNode/index.js'; import type { InlineToolData, InlineToolName } from '@editorjs/model-types'; import { BlockChildType } from '@editorjs/model-types'; import type { InlineFragment, TextNodeSerialized, BlockNodeDataSerialized } from '@editorjs/model-types'; -import { TextNode } from '../inline-fragments/index.js'; +import { TextNode } from '../inline-text/index.js'; import type { BlockNodeData } from './types/index.js'; import { NODE_TYPE_HIDDEN_PROP } from '@editorjs/model-types'; import { TextAddedEvent, TuneModifiedEvent, ValueModifiedEvent } from '@editorjs/model-types'; @@ -31,7 +31,7 @@ const ValueNodeProto = ValueNode.prototype as unknown as { jest.mock('../BlockTune'); -jest.mock('../inline-fragments/TextNode'); +jest.mock('../inline-text/TextNode'); jest.mock('../ValueNode'); diff --git a/packages/model/src/entities/BlockNode/index.ts b/packages/model/src/entities/BlockNode/index.ts index 47e434bb..9ea10921 100644 --- a/packages/model/src/entities/BlockNode/index.ts +++ b/packages/model/src/entities/BlockNode/index.ts @@ -10,7 +10,7 @@ import type { ChildNode } from './types/index.js'; import { ValueNode } from '../ValueNode/index.js'; -import { TextNode } from '../inline-fragments/index.js'; +import { TextNode } from '../inline-text/index.js'; import type { InlineFragment, TextNodeSerialized, ValueSerialized } from '@editorjs/model-types'; import { PartialIndex, diff --git a/packages/model/src/entities/BlockNode/types/BlockNodeData.ts b/packages/model/src/entities/BlockNode/types/BlockNodeData.ts index 27f8874f..093f262b 100644 --- a/packages/model/src/entities/BlockNode/types/BlockNodeData.ts +++ b/packages/model/src/entities/BlockNode/types/BlockNodeData.ts @@ -1,6 +1,6 @@ import type { DataKey } from '@editorjs/model-types'; import type { ValueNode } from '../../ValueNode/index.js'; -import type { TextNode } from '../../inline-fragments/index.js'; +import type { TextNode } from '../../inline-text/index.js'; export type ChildNode = ValueNode | TextNode; diff --git a/packages/model/src/entities/ValueNode/index.ts b/packages/model/src/entities/ValueNode/index.ts index 7b291b20..8f0e39ee 100644 --- a/packages/model/src/entities/ValueNode/index.ts +++ b/packages/model/src/entities/ValueNode/index.ts @@ -9,7 +9,7 @@ import { ValueModifiedEvent } from '@editorjs/model-types'; /** * ValueNode class represents a node in a tree-like structure, used to store and manipulate data associated with a BlockNode. - * Unlike TextInlineNode, changing the data of a ValueNode will replace the entire data in this node. + * Unlike TextNode, changing the data of a ValueNode will replace the entire data in this node. * This can be useful for storing data that needs to be updated in its entirety, such as a link or other metadata associated with a BlockNode. */ export class ValueNode extends EventBus { diff --git a/packages/model/src/entities/index.ts b/packages/model/src/entities/index.ts index 0db7aa2c..ca209742 100644 --- a/packages/model/src/entities/index.ts +++ b/packages/model/src/entities/index.ts @@ -2,4 +2,4 @@ export * from './EditorDocument/index.js'; export * from './BlockNode/index.js'; export * from './BlockTune/index.js'; export * from './ValueNode/index.js'; -export * from './inline-fragments/index.js'; +export * from './inline-text/index.js'; diff --git a/packages/model/src/entities/inline-fragments/FormattingInlineNode/__mocks__/index.ts b/packages/model/src/entities/inline-fragments/FormattingInlineNode/__mocks__/index.ts deleted file mode 100644 index 3b5215bd..00000000 --- a/packages/model/src/entities/inline-fragments/FormattingInlineNode/__mocks__/index.ts +++ /dev/null @@ -1,68 +0,0 @@ -import { ParentNode } from '../../mixins/ParentNode/index.js'; -import { ChildNode } from '../../mixins/ChildNode/index.js'; -import type { InlineFragment } from '@editorjs/model-types'; - -export interface FormattingInlineNode extends ParentNode, ChildNode {} - -/** - * Mock for FormattingInlineNode class - */ -@ParentNode -@ChildNode -export class FormattingInlineNode { - /** - * Method mock - */ - public get length(): number { - return this.children.reduce((sum, child) => sum + child.length, 0); - } - - /** - * Mock method - */ - public getText(): string { - return ''; - } - - /** - * Mock method - */ - public insertText(): void { - return; - } - - /** - * Mock method - */ - public removeText(): string { - return ''; - } - - /** - * Mock method - */ - public getFragments(): InlineFragment[] { - return []; - } - - /** - * Mock method - */ - public isEqual(): boolean { - return false; - } - - /** - * Mock method - */ - public format(): [] { - return []; - } - - /** - * Mock method - */ - public unformat(): [] { - return []; - } -} diff --git a/packages/model/src/entities/inline-fragments/FormattingInlineNode/index.ts b/packages/model/src/entities/inline-fragments/FormattingInlineNode/index.ts deleted file mode 100644 index f257f4e1..00000000 --- a/packages/model/src/entities/inline-fragments/FormattingInlineNode/index.ts +++ /dev/null @@ -1,294 +0,0 @@ -import type { - FormattingInlineNodeConstructorParameters -} from './types/index.js'; -import type { InlineToolName, InlineToolData, InlineFragment } from '@editorjs/model-types'; -import type { InlineNode } from '../InlineNode/index.js'; -import { ParentNode } from '../mixins/ParentNode/index.js'; -import { ChildNode } from '../mixins/ChildNode/index.js'; -import { ParentInlineNode } from '../ParentInlineNode/index.js'; -import { isSameInlineData } from '../../../utils/index.js'; - -export type * from './types/index.js'; - -/** - * We need to extend FormattingInlineNode interface with ChildNode and ParentNode ones to use the methods from mixins - */ -// eslint-disable-next-line @typescript-eslint/no-empty-object-type -export interface FormattingInlineNode extends ChildNode {} - -/** - * FormattingInlineNode class represents a node in a tree-like structure, used to store and manipulate formatted text content - */ -@ParentNode -@ChildNode -export class FormattingInlineNode extends ParentInlineNode implements InlineNode { - /** - * Property representing the name of the formatting tool applied to the content - */ - public readonly tool: InlineToolName; - - /** - * Any additional data associated with the formatting tool. - * Kept in a private field so it can be replaced on re-formatting while staying read-only to the outside. - */ - #data?: InlineToolData; - - /** - * Any additional data associated with the formatting tool - */ - public get data(): InlineToolData | undefined { - return this.#data; - } - - /** - * Constructor for FormattingInlineNode class. - * @param args - FormattingInlineNode constructor arguments. - * @param args.tool - The name of the formatting tool applied to the content. - * @param args.data - Any additional data associated with the formatting. - */ - // Stryker disable next-line BlockStatement -- Styker's bug, see https://github.com/stryker-mutator/stryker-js/issues/2474 - constructor({ tool, data }: FormattingInlineNodeConstructorParameters) { - super(); - - this.tool = tool; - this.#data = data; - } - - /** - * Removes text from the specified range. If there is no text left in a node, removes a node from a parent. - * @param [start] - start char index of the range, by default 0 - * @param [end] - end char index of the range, by default length of the text value - * @returns removed text - */ - public removeText(start = 0, end = this.length): string { - const result = super.removeText(start, end); - - if (this.length === 0) { - this.remove(); - } - - return result; - } - - /** - * Returns inline fragments for node from the specified character range - * Always return full fragments even if one is not fully covered by the passed range - * @param [start] - start char index of the range, by default 0 - * @param [end] - end char index of the range, by default length of the text value - */ - public getFragments(start = 0, end = this.length): InlineFragment[] { - const fragments = super.getFragments(start, end); - - const currentFragment: InlineFragment = { - tool: this.tool, - range: [0, this.length], - }; - - if (this.data) { - currentFragment.data = this.data; - } - - /** - * Current node is not processed in super.getFragments, so we need to add it manually at the beginning - */ - fragments.unshift(currentFragment); - - return fragments; - } - - /** - * Splits current node by the specified index - * @param index - char index where to split the node - * @returns new node - */ - public split(index: number): FormattingInlineNode | null { - this.validateIndex(index); - - if (index === 0 || index === this.length) { - return null; - } - - const newNode = new FormattingInlineNode({ - tool: this.tool, - data: this.data, - }); - - const [child, offset] = this.findChildByIndex(index); - - child.split(index - offset); - - /** - * We need to add 1 to the index to get the index of the new node appended to the parent after child split - */ - const midNodeIndex = this.children.indexOf(child) + 1; - - newNode.append(...this.children.slice(midNodeIndex)); - - this.parent?.insertAfter(this, newNode); - - return newNode; - } - - /** - * Applies formatting to the text with specified inline tool in the specified range - * @param tool - name of inline tool to apply - * @param start - char start index of the range - * @param end - char end index of the range - * @param [data] - inline tool data if applicable - */ - public format(tool: InlineToolName, start: number, end: number, data?: InlineToolData): InlineNode[] { - if (tool === this.tool) { - /** - * Re-applying the same tool with the same data is a no-op - */ - if (isSameInlineData(data, this.#data)) { - return []; - } - - /** - * Re-applying the same tool with different data replaces the data over the passed range. - * Split the node so only the affected range gets the new data, then update that segment. - */ - return this.#replaceData(start, end, data); - } - - return super.format(tool, start, end, data); - } - - /** - * Replaces this node's data over the specified range, splitting the node when the range does - * not cover it fully so the surrounding parts keep their original data. - * @param start - char start index of the range - * @param end - char end index of the range - * @param [data] - new inline tool data to apply - */ - #replaceData(start: number, end: number, data?: InlineToolData): InlineNode[] { - /** - * Range covers the whole node — just swap the data in place - */ - if (start === 0 && end === this.length) { - this.#data = data; - - return [this]; - } - - const middleNode = this.split(start); - const result: FormattingInlineNode[] = []; - - /** - * If start > 0, `split` produced a node covering [start, length). Split it again at `end` - * so `middleNode` is exactly the affected range, and the remainder keeps the old data. - */ - if (middleNode) { - const endNode = middleNode.split(end - this.length); - - middleNode.#data = data; - - result.push(this, middleNode); - - if (endNode) { - result.push(endNode); - } - /** - * If start === 0, split at `end` so `this` becomes the affected range and the tail keeps the old data. - */ - } else { - const endNode = this.split(end); - - this.#data = data; - - result.push(this); - - if (endNode) { - result.push(endNode); - } - } - - return result; - } - - /** - * Removes formatting from the text for a specified inline tool in the specified range - * @param tool - name of inline tool to remove - * @param start - char start index of the range - * @param end - char end index of the range - * @todo Possibly pass data or some InlineTool identifier to relevant only required fragments - */ - public unformat(tool: InlineToolName, start: number, end: number): InlineNode[] { - if (this.tool === tool) { - const middleNode = this.split(start); - const endNode = middleNode ? middleNode.split(end - this.length) : this.split(end); - - const result: ChildNode[] = []; - - /** - * If start > 0, then there is a middle node, so we'll need to append its children to the parent - */ - if (middleNode) { - result.push(this, ...middleNode.children); - /** - * Else we'll need to append current nodes children to the parent - */ - } else { - result.push(...this.children); - } - - /** - * If end < this.length, we just append it to the parent - */ - if (endNode) { - result.push(endNode); - } - - this.parent?.insertAfter(this, ...result); - - if (middleNode) { - middleNode.remove(); - } else { - this.remove(); - } - - return result; - } - - return super.unformat(tool, start, end); - } - - /** - * Checks if node is equal to passed node - * @param node - node to check - */ - public isEqual(node: InlineNode): node is FormattingInlineNode { - if (!(node instanceof FormattingInlineNode)) { - return false; - } - - if (this.tool !== node.tool) { - return false; - } - - /** - * Fragments with different data must stay separate so normalization does not drop or resurrect stale data - */ - return isSameInlineData(this.#data, node.#data); - } - - /** - * Merges current node with passed node - * @param node - node to merge with - */ - public mergeWith(node: InlineNode): void { - if (!this.isEqual(node)) { - throw new Error('Can not merge unequal nodes'); - } - - /** - * `isEqual` guarantees the data is equal, so there is nothing to reconcile — just move the children over - */ - Array.from(node.children).forEach((child) => { - this.append(child); - }); - - node.remove(); - } -} diff --git a/packages/model/src/entities/inline-fragments/FormattingInlineNode/types/FormattingInlineNodeConstructorParameters.ts b/packages/model/src/entities/inline-fragments/FormattingInlineNode/types/FormattingInlineNodeConstructorParameters.ts deleted file mode 100644 index 4fcf7032..00000000 --- a/packages/model/src/entities/inline-fragments/FormattingInlineNode/types/FormattingInlineNodeConstructorParameters.ts +++ /dev/null @@ -1,16 +0,0 @@ -import type { InlineToolName } from '@editorjs/model-types'; -import type { InlineToolData } from '@editorjs/model-types'; -import type { ChildNodeConstructorOptions } from '../../mixins/ChildNode/index.js'; -import type { ParentNodeConstructorOptions } from '../../mixins/ParentNode/index.js'; - -export interface FormattingInlineNodeConstructorParameters extends ChildNodeConstructorOptions, ParentNodeConstructorOptions { - /** - * The name of the formatting tool applied to the content - */ - tool: InlineToolName; - - /** - * Any additional data associated with the formatting - */ - data?: InlineToolData; -} diff --git a/packages/model/src/entities/inline-fragments/FormattingInlineNode/types/index.ts b/packages/model/src/entities/inline-fragments/FormattingInlineNode/types/index.ts deleted file mode 100644 index 4d044d6f..00000000 --- a/packages/model/src/entities/inline-fragments/FormattingInlineNode/types/index.ts +++ /dev/null @@ -1 +0,0 @@ -export type { FormattingInlineNodeConstructorParameters } from './FormattingInlineNodeConstructorParameters.js'; diff --git a/packages/model/src/entities/inline-fragments/InlineNode/index.ts b/packages/model/src/entities/inline-fragments/InlineNode/index.ts deleted file mode 100644 index bc29d65c..00000000 --- a/packages/model/src/entities/inline-fragments/InlineNode/index.ts +++ /dev/null @@ -1,93 +0,0 @@ -import type { InlineToolData, InlineToolName } from '@editorjs/model-types'; -import type { InlineTreeNodeSerialized } from '@editorjs/model-types'; -import type { InlineFragment, TextNodeSerialized } from '@editorjs/model-types'; - -/** - * Interface describing abstract InlineNode — common properties and methods for all inline nodes - */ -export interface InlineNode { - /** - * Text length of node and it's subtree - */ - readonly length: number; - - /** - * Serialized value of the node - */ - readonly serialized: InlineTreeNodeSerialized; - - /** - * Returns text value in passed range - * @param start - start char index of the range - * @param end - end char index of the range - */ - getText(start?: number, end?: number): string; - - /** - * Applies inline formatting on the passed range - * @param name - name of Inline Tool to apply - * @param [start] - start char index of the range - * @param [end] - end char index of the range - * @param [data] - Inline Tool data if applicable - * @returns - array of nodes after applied formatting - */ - format(name: InlineToolName, start?: number, end?: number, data?: InlineToolData): InlineNode[]; - - /** - * Removes inline formatting from the passed range - * - * Optional as some nodes don't contain any formatting (e.g. TextInlineNode) - * @param name - name of Inline Tool to remove - * @param start - start char index of the range - * @param end - end char index of the range - */ - unformat?(name: InlineToolName, start?: number, end?: number): InlineNode[]; - - /** - * Returns inline fragments for subtree including current node from the specified range - * - * Optional as some nodes don't contain any formatting (e.g. TextInlineNode) - * @param [start] - start char index of the range, by default 0 - * @param [end] - end char index of the range, by default length of the text value - */ - getFragments?(start: number, end: number): InlineFragment[]; - - /** - * Inserts text at passed char index - * @param text - text to insert - * @param [index] - char index where to insert text - */ - insertText(text: string, index?: number): void; - - /** - * Removes text from the passed range - * @param [start] - start char index of the range - * @param [end] - end char index of the range - * @returns removed text - */ - removeText(start?: number, end?: number): string; - - /** - * Splits current node at the passed index - * @param index - char index where to split the node - * @returns new node if split successful, null if nothing to split - */ - split(index?: number): InlineNode | null; - - /** - * Merges current node with passed - * @param node - node to merge - */ - mergeWith(node: InlineNode): void; - - /** - * Check if current node is equal to passed - * @param node - node to check - */ - isEqual(node: InlineNode): boolean; - - /** - * Normalizes nodes subtree - */ - normalize(): void; -} diff --git a/packages/model/src/entities/inline-fragments/ParentInlineNode/__mocks__/index.ts b/packages/model/src/entities/inline-fragments/ParentInlineNode/__mocks__/index.ts deleted file mode 100644 index 082837be..00000000 --- a/packages/model/src/entities/inline-fragments/ParentInlineNode/__mocks__/index.ts +++ /dev/null @@ -1,57 +0,0 @@ -import type { InlineFragment } from '@editorjs/model-types'; -import type { InlineNode } from '../../InlineNode/index.js'; - -/** - * We still need actual class for private and protected methods we can't mock - */ -// eslint-disable-next-line no-undef -const { ParentInlineNode: ActualClass } = jest.requireActual('../index'); - -/** - * Mock for ParentInlineNode class - */ -export class ParentInlineNode extends ActualClass { - #children: ChildNode[] = []; - - /** - * Mock method - */ - public get children(): ChildNode[] { - return this.#children; - } - - /** - * Mock method - */ - public insertText(): void { - return; - } - - /** - * Mock method - */ - public removeText(): void { - return; - } - - /** - * Mock method - */ - public getFragments(): Array { - return []; - } - - /** - * Mock method - */ - public format(): Array { - return []; - } - - /** - * Mock method - */ - public unformat(): Array { - return []; - } -} diff --git a/packages/model/src/entities/inline-fragments/ParentInlineNode/index.ts b/packages/model/src/entities/inline-fragments/ParentInlineNode/index.ts deleted file mode 100644 index 322faf73..00000000 --- a/packages/model/src/entities/inline-fragments/ParentInlineNode/index.ts +++ /dev/null @@ -1,344 +0,0 @@ -import { getContext } from '../../../utils/Context.js'; -import { PartialIndex } from '@editorjs/model-types'; -import { isSameInlineData } from '../../../utils/index.js'; -import type { InlineNode } from '../InlineNode/index.js'; -import type { InlineFragment, InlineTreeNodeSerialized, InlineToolData, InlineToolName } from '@editorjs/model-types'; -import type { ParentNodeConstructorOptions } from '../mixins/ParentNode/index.js'; -import { ParentNode } from '../mixins/ParentNode/index.js'; -import type { ChildNode } from '../mixins/ChildNode/index.js'; -import { TextInlineNode } from '../index.js'; -import { EventBus } from '@editorjs/model-types'; -import { - TextAddedEvent, - TextFormattedEvent, - TextRemovedEvent, - TextUnformattedEvent -} from '@editorjs/model-types'; - -/** - * We need to extend ParentInlineNode interface with ParentNode ones to use the methods from mixins - */ -// eslint-disable-next-line @typescript-eslint/no-empty-object-type -export interface ParentInlineNode extends ParentNode { -} - -// eslint-disable-next-line @typescript-eslint/no-empty-object-type -export interface ParentInlineNodeConstructorOptions extends ParentNodeConstructorOptions { -} - -/** - * ParentInlineNode is a class that contains common attributes for inline nodes that may have children. For example, TextInlineNode or FormattingInlineNode - */ -@ParentNode -export class ParentInlineNode extends EventBus implements InlineNode { - /** - * Empty constructor to support types - * @param options - constructor options to support types - */ - // eslint-disable-next-line @typescript-eslint/no-unused-vars,@typescript-eslint/no-empty-function,no-unused-vars - constructor(options?: ParentInlineNodeConstructorOptions) { - super(); - } - - /** - * Returns serialized value of the node: text and formatting fragments - */ - public get serialized(): InlineTreeNodeSerialized { - return { - value: this.getText(), - fragments: this.getFragments(), - }; - } - - /** - * Inserts text to the specified index, by default appends text to the end of the current value - * @param text - text to insert - * @param [index] - char index where to insert text - */ - public insertText(text: string, index = this.length): void { - this.validateIndex(index); - - if (this.length === 0) { - const textNode = new TextInlineNode(); - - this.append(textNode); - } - - const [child, offset] = this.findChildByIndex(index); - - child.insertText(text, index - offset); - - this.normalize(); - - this.dispatchEvent(new TextAddedEvent(new PartialIndex({ textRange: [index, index] }), text, getContext()!)); - } - - /** - * Removes text form the specified range - * @param [start] - start char index of the range, by default 0 - * @param [end] - end char index of the range, by default length of the text value - * @returns removed text - */ - public removeText(start = 0, end = this.length): string { - this.validateRange(start, end); - - const removedText = this.#reduceChildrenInRange( - start, - end, - (acc, child, childStart, childEnd) => { - return acc + child.removeText(childStart, childEnd); - }, - '' - ); - - this.normalize(); - - this.dispatchEvent(new TextRemovedEvent(new PartialIndex({ textRange: [start, end] }), removedText, getContext()!)); - - return removedText; - } - - /** - * Returns text from the specified range - * @param [start] - start char index of the range, by default 0 - * @param [end] - end char index of the range, by default length of the text value - */ - public getText(start = 0, end = this.length): string { - this.validateRange(start, end); - - return this.#reduceChildrenInRange( - start, - end, - (acc, child, childStart, childEnd) => { - return acc + child.getText(childStart, childEnd); - }, - '' - ); - } - - /** - * Returns inline fragments for subtree including current node from the specified range - * @param [start] - start char index of the range, by default 0 - * @param [end] - end char index of the range, by default length of the text value - */ - public getFragments(start = 0, end = this.length): InlineFragment[] { - this.validateRange(start, end); - - return this.#reduceChildrenInRange( - start, - end, - (acc, child, childStart, childEnd, offset) => { - /** - * If child is not a FormattingInlineNode, it doesn't include any fragments. So we skip it. - */ - if (typeof child.getFragments !== 'function') { - return acc; - } - - const fragments = child - .getFragments(childStart, childEnd) - .map(fragment => ({ - ...fragment, - range: fragment.range.map(index => index + offset) as InlineFragment['range'], - })); - - acc.push(...fragments); - - return acc.reduce((normalized, fragment) => { - const previousFragment = normalized[normalized.length - 1]; - - /** - * Adjacent fragments are only coalesced when they share the same tool AND data, - * so a range whose data was replaced keeps its own fragment in the output. - */ - if ( - previousFragment === undefined - || previousFragment.tool !== fragment.tool - || previousFragment.range[1] !== fragment.range[0] - || !isSameInlineData(previousFragment.data, fragment.data) - ) { - normalized.push(fragment); - - return normalized; - } - - previousFragment.range[1] = fragment.range[1]; - - return normalized; - }, [] as InlineFragment[]); - }, - [] - ); - } - - /** - * Applies formatting to the text with specified inline tool in the specified range - * @param tool - name of inline tool to apply - * @param start - char start index of the range - * @param end - char end index of the range - * @param [data] - inline tool data if applicable - * @todo - Implement intersectionType logic - */ - public format(tool: InlineToolName, start: number, end: number, data?: InlineToolData): InlineNode[] { - this.validateRange(start, end); - - const newNodes = this.#reduceChildrenInRange( - start, - end, - (acc, child, childStart, childEnd) => { - acc.push(...child.format(tool, childStart, childEnd, data)); - - return acc; - }, - [] - ); - - this.normalize(); - - this.dispatchEvent( - new TextFormattedEvent( - new PartialIndex({ textRange: [start, end] }), - { - tool, - data, - }, - getContext()! - ) - ); - - return newNodes; - } - - /** - * Removes formatting from the text for a specified inline tool in the specified range - * @param tool - name of inline tool to remove - * @param start - char start index of the range - * @param end - char end index of the range - * @todo Possibly pass data or some InlineTool identifier to relevant only required fragments - */ - public unformat(tool: InlineToolName, start: number, end: number): InlineNode[] { - this.validateRange(start, end); - - const newNodes = this.#reduceChildrenInRange( - start, - end, - (acc, child, childStart, childEnd) => { - /** - * TextInlineNodes don't have unformat method, so skip them - */ - if (typeof child.unformat !== 'function') { - return acc; - } - - acc.push(...child.unformat(tool, childStart, childEnd)); - - return acc; - }, - [] - ); - - this.normalize(); - - this.dispatchEvent(new TextUnformattedEvent(new PartialIndex({ textRange: [start, end] }), { tool }, getContext()!)); - - return newNodes; - } - - /** - * Checks if node is equal to passed node - * @param node - node to check - */ - public isEqual(node: InlineNode): boolean { - return node instanceof this.constructor; - } - - /** - * Returns child by passed text index - * @param index - char index - */ - protected findChildByIndex(index: number): [ child: InlineNode & ChildNode, offset: number ] { - let totalLength = 0; - - for (const child of this.children) { - if (index <= child.length + totalLength) { - return [child, totalLength]; - } - - totalLength += child.length; - } - - /** - * This is unreachable code in normal operation, but we need it to have consistent types - */ - /* Stryker disable next-line StringLiteral */ - /* istanbul ignore next */ - throw new Error(`Child is not found by ${index} index`); - } - - /** - * Iterates through children in range and calls callback for each - * @param start - range start char index - * @param end - range end char index - * @param callback - callback to apply on children - * @param initialValue - initial accumulator value - */ - #reduceChildrenInRange( - start: number, - end: number, - callback: (acc: Acc, child: InlineNode, start: number, end: number, offset: number) => Acc, - initialValue: Acc - ): Acc { - let result = initialValue; - - /** - * Make a copy of the children array in case callback would modify it - */ - const children = Array.from(this.children); - - let offset = 0; - - for (const child of children) { - /** - * Saving child length in case it would be modified by callback - */ - const childLength = child.length; - - if (start < childLength && end > 0 && start < end) { - result = callback(result, child, Math.max(start, 0), Math.min(childLength, end), offset); - } - - offset += childLength; - start -= childLength; - end -= childLength; - } - - return result; - } - - /** - * Validates if range has valid start and end points - * @param start - range start - * @param end - range end - * @throws Error if range is invalid - */ - protected validateRange(start: number, end: number): void { - this.validateIndex(start); - this.validateIndex(end); - - if (end < start) { - throw new Error(`The end of range must be greater or equal than the start: [${start}, ${end}]`); - } - } - - /** - * Validates index - * @param index - char index to validate - * @throws Error if index is out of the text length - */ - protected validateIndex(index: number): void { - if (index < 0 || index > this.length) { - // Stryker disable next-line StringLiteral - throw new Error(`Index ${index} is not in valid range [0, ${this.length}]`); - } - } -} diff --git a/packages/model/src/entities/inline-fragments/TextInlineNode/__mocks__/index.ts b/packages/model/src/entities/inline-fragments/TextInlineNode/__mocks__/index.ts deleted file mode 100644 index 40b012f1..00000000 --- a/packages/model/src/entities/inline-fragments/TextInlineNode/__mocks__/index.ts +++ /dev/null @@ -1,92 +0,0 @@ -import { ChildNode } from '../../mixins/ChildNode/index.js'; -import type { InlineNode } from '../../InlineNode/index.js'; -import type { TextInlineNodeConstructorParameters } from '../types/index.js'; - -// eslint-disable-next-line @typescript-eslint/no-empty-object-type -export interface TextInlineNode extends ChildNode {} - -/** - * Mock for TextInlineNode class - */ -@ChildNode -export class TextInlineNode implements InlineNode { - /** Mock value */ - public value; - - /** - * Mock constructor - * @param args - constructor params - * @param [args.value] - TextNode value - */ - constructor({ value = '' }: TextInlineNodeConstructorParameters) { - this.value = value; - } - - /** - * Mock method - */ - public getText(): string { - return ''; - } - - /** - * Mock method - */ - public removeText(): string { - return ''; - } - - /** - * Mock method - * @param text - text to insert - */ - public insertText(text: string): void { - this.value += text; - } - - /** - * Mock method - */ - public isEqual(): boolean { - return false; - } - - /** - * Mock method - */ - public get length(): number { - return this.value.length; - } - - /** - * Mock method - */ - public normalize(): void { - return; - } - - /** - * Mock method - * @param index - index where to split the node - */ - public split(index: number): InlineNode | null { - if (index === 0 || index === this.length) { - return null; - } - - const newNode = new TextInlineNode({ value: this.value.slice(index) }); - - this.value = this.value.slice(0, index); - - this.parent?.insertAfter(this, newNode); - - return newNode; - } - - /** - * Mock method - */ - public format(): [] { - return []; - } -} diff --git a/packages/model/src/entities/inline-fragments/TextInlineNode/index.ts b/packages/model/src/entities/inline-fragments/TextInlineNode/index.ts deleted file mode 100644 index 19735382..00000000 --- a/packages/model/src/entities/inline-fragments/TextInlineNode/index.ts +++ /dev/null @@ -1,220 +0,0 @@ -import type { InlineToolName, InlineToolData, InlineTreeNodeSerialized } from '@editorjs/model-types'; -import { FormattingInlineNode } from '../index.js'; -import type { TextInlineNodeConstructorParameters } from './types/index.js'; -import type { InlineNode } from '../InlineNode/index.js'; -import { ChildNode } from '../mixins/ChildNode/index.js'; - -export type * from './types/index.js'; - -// eslint-disable-next-line @typescript-eslint/no-empty-object-type -export interface TextInlineNode extends ChildNode {} - -/** - * TextInlineNode class represents a node in a tree-like structure, used to store and manipulate text content. - */ -@ChildNode -export class TextInlineNode implements InlineNode { - /** - * Property representing the text content of the node - */ - public value: string; - - /** - * Constructor for TextInlineNode class - * @param args - TextInlineNode constructor arguments. - * @param args.value - Text content of the node. - */ - constructor({ value = '' }: TextInlineNodeConstructorParameters = {}) { - this.value = value; - } - - /** - * Returns length of the text - */ - public get length(): number { - return this.value.length; - } - - /** - * Returns serialized value of the node - */ - public get serialized(): InlineTreeNodeSerialized { - return { - value: this.getText(), - // No fragments for text node - fragments: [], - }; - } - - /** - * Inserts text to specified position. By default, appends new text to the current value - * @param text - text to insert - * @param [index] - char start index - */ - public insertText(text: string, index = this.length): void { - this.#validateIndex(index); - - this.value = this.value.slice(0, index) + text + this.value.slice(index); - } - - /** - * Remove text from specified range - * @param [start] - start char index of the range, 0 by default - * @param [end] - end char index of the range, text length by default - * @returns removed text - */ - public removeText(start = 0, end = this.length): string { - this.#validateIndex(start); - this.#validateIndex(end); - - const removedValue = this.value.slice(start, end); - - this.value = this.value.slice(0, start) + this.value.slice(end); - - if (this.length === 0) { - this.remove(); - } - - return removedValue; - } - - /** - * Returns text value from the specified range - * @param [start] - start char index of the range, 0 by default - * @param [end] - end char index of the range, text length by default - */ - public getText(start = 0, end = this.length): string { - if (start > end) { - // Stryker disable next-line StringLiteral - throw new Error(`Start index ${start} should be less or equal than end index ${end}`); - } - - this.#validateIndex(start); - this.#validateIndex(end); - - return this.value.slice(start, end); - } - - /** - * Applies inline tool for specified range - * @param tool - name of the tool to apply - * @param start - start char index of the range - * @param end - end char index of the range - * @param [data] - inline tool data if applicable - * @returns - array of nodes after applied formatting - */ - public format(tool: InlineToolName, start: number, end: number, data?: InlineToolData): InlineNode[] { - this.#validateIndex(start); - this.#validateIndex(end); - - const formattingNode = new FormattingInlineNode({ - tool, - data, - }); - - const fragments: ChildNode[] = []; - - /** - * If start index is greater than 0, we need extract part of the text before the start index - */ - if (start > 0) { - fragments.push(this.#cloneContents(0, start)); - } - - /** - * Formatting is applied to the specified range - */ - const formattedFragment = this.#cloneContents(start, end); - - formattedFragment.appendTo(formattingNode); - - fragments.push(formattingNode); - - /** - * If end index is less than the text length, we need to extract part of the text after the end index - */ - if (end < this.length) { - fragments.push(this.#cloneContents(end, this.length)); - } - - this.parent?.insertAfter(this, ...fragments); - - this.remove(); - - return fragments; - } - - /** - * Splits current node into two nodes by the specified index - * @param index - char index where to split - * @returns - new node or null if split is not applicable - */ - public split(index: number): TextInlineNode | null { - if (index === 0 || index === this.length) { - return null; - } - - const newNode = new TextInlineNode(); - const text = this.removeText(index); - - newNode.insertText(text); - - this.parent?.insertAfter(this, newNode); - - return newNode; - } - - /** - * Checks if node is equal to passed node - * @param node - node to check - */ - public isEqual(node: InlineNode): node is TextInlineNode { - return node instanceof this.constructor; - } - - /** - * Merges current node with passed node - * @param node - node to merge with - */ - public mergeWith(node: InlineNode): void { - if (!this.isEqual(node)) { - throw new Error('Can not merge unequal nodes'); - } - - this.value += node.value; - - node.remove(); - } - - /** - * Normalizes node - */ - public normalize(): void { - /** - * do nothing - */ - } - - /** - * Validates index - * @param index - char index to validate - * @throws Error if index is out of the text length - */ - #validateIndex(index: number): void { - if (index < 0 || index > this.length) { - // Stryker disable next-line StringLiteral - throw new Error(`Index ${index} is not in valid range [0, ${this.length}]`); - } - } - - /** - * Clones specified range to a new TextInlineNode - * @param start - start char index of the range - * @param end - end char index of the range - */ - #cloneContents(start: number, end: number): TextInlineNode { - return new TextInlineNode({ - value: this.getText(start, end), - }); - } -} diff --git a/packages/model/src/entities/inline-fragments/TextInlineNode/types/TextInlineNodeConstructorParameters.ts b/packages/model/src/entities/inline-fragments/TextInlineNode/types/TextInlineNodeConstructorParameters.ts deleted file mode 100644 index 58ed3f3a..00000000 --- a/packages/model/src/entities/inline-fragments/TextInlineNode/types/TextInlineNodeConstructorParameters.ts +++ /dev/null @@ -1,8 +0,0 @@ -import type { ChildNodeConstructorOptions } from '../../mixins/ChildNode/index.js'; - -export interface TextInlineNodeConstructorParameters extends ChildNodeConstructorOptions { - /** - * Text content of the node - */ - value?: string; -} diff --git a/packages/model/src/entities/inline-fragments/TextInlineNode/types/index.ts b/packages/model/src/entities/inline-fragments/TextInlineNode/types/index.ts deleted file mode 100644 index d8759fe7..00000000 --- a/packages/model/src/entities/inline-fragments/TextInlineNode/types/index.ts +++ /dev/null @@ -1 +0,0 @@ -export type { TextInlineNodeConstructorParameters } from './TextInlineNodeConstructorParameters.js'; diff --git a/packages/model/src/entities/inline-fragments/TextNode/TextNode.spec.ts b/packages/model/src/entities/inline-fragments/TextNode/TextNode.spec.ts deleted file mode 100644 index 53e75c92..00000000 --- a/packages/model/src/entities/inline-fragments/TextNode/TextNode.spec.ts +++ /dev/null @@ -1,93 +0,0 @@ -import type { InlineToolName } from '@editorjs/model-types'; -import { BlockChildType, NODE_TYPE_HIDDEN_PROP } from '@editorjs/model-types'; -import type { InlineFragment } from '@editorjs/model-types'; -import { TextNode } from './index.js'; -import { ParentInlineNode } from '../ParentInlineNode/index.js'; - -jest.mock('../ParentInlineNode'); - -describe('TextNode', () => { - describe('.serialized', () => { - it('should add NODE_TYPE_HIDDEN_PROP with BlockChildType.Text to the parent serialized output', () => { - const superSerialized = { - value: 'hello', - fragments: [], - }; - - jest.spyOn(ParentInlineNode.prototype, 'serialized', 'get').mockReturnValueOnce(superSerialized); - - const node = new TextNode(); - const result = node.serialized; - - expect(result[NODE_TYPE_HIDDEN_PROP]).toBe(BlockChildType.Text); - expect(result.value).toBe('hello'); - expect(result.fragments).toEqual([]); - }); - }); - - describe('.getFragments()', () => { - it('should return all fragments for the specific range', () => { - const boldFragmentStart = 0; - const boldFragmentEnd = 5; - const italicFragmentStart = 3; - const italicFragmentEnd = 10; - - const testRangeStart = 2; - const testRangeEnd = 7; - - const fragments: InlineFragment[] = [ - { - tool: 'bold' as InlineToolName, - range: [boldFragmentStart, boldFragmentEnd], - }, - { - tool: 'italic' as InlineToolName, - range: [italicFragmentStart, italicFragmentEnd], - }, - ]; - - jest.spyOn(ParentInlineNode.prototype, 'getFragments').mockReturnValueOnce(fragments); - - const node = new TextNode({ - value: 'Editor.js is a block-styled editor', - fragments, - }); - - const result = node.getFragments(testRangeStart, testRangeEnd); - - expect(result).toEqual(fragments); - }); - - it('should return filtered fragments by inline tool name', () => { - const boldFragmentStart = 0; - const boldFragmentEnd = 5; - const italicFragmentStart = 3; - const italicFragmentEnd = 10; - - const testRangeStart = 2; - const testRangeEnd = 7; - - const fragments: InlineFragment[] = [ - { - tool: 'bold' as InlineToolName, - range: [boldFragmentStart, boldFragmentEnd], - }, - { - tool: 'italic' as InlineToolName, - range: [italicFragmentStart, italicFragmentEnd], - }, - ]; - - jest.spyOn(ParentInlineNode.prototype, 'getFragments').mockReturnValueOnce(fragments); - - const node = new TextNode({ - value: 'Editor.js is a block-styled editor', - fragments, - }); - - const result = node.getFragments(testRangeStart, testRangeEnd, 'bold' as InlineToolName); - - expect(result).toEqual([fragments[0]]); - }); - }); -}); diff --git a/packages/model/src/entities/inline-fragments/TextNode/index.ts b/packages/model/src/entities/inline-fragments/TextNode/index.ts deleted file mode 100644 index 4f5ae8ca..00000000 --- a/packages/model/src/entities/inline-fragments/TextNode/index.ts +++ /dev/null @@ -1,68 +0,0 @@ -import type { InlineToolName, InlineFragment, TextNodeSerialized } from '@editorjs/model-types'; -import { BlockChildType, NODE_TYPE_HIDDEN_PROP } from '@editorjs/model-types'; -import type { ParentInlineNodeConstructorOptions } from '../index.js'; -import { ParentInlineNode } from '../index.js'; - -interface TextNodeConstructorOptions extends ParentInlineNodeConstructorOptions { - value?: string; - fragments?: InlineFragment[]; -} - -/** - * TextNode class represents a root node in a tree-like structure to have a single access point to the tree - */ -export class TextNode extends ParentInlineNode { - /** - * TextNode constructor - * @param options - TextNode constructor options - */ - // Stryker disable next-line BlockStatement -- Styker's bug, see https://github.com/stryker-mutator/stryker-js/issues/2474 - constructor(options: TextNodeConstructorOptions = {}) { - const { value = '', fragments = [], ...rest } = options; - - super(rest); - - this.#initialize(value, fragments); - } - - /** - * Returns serialized TextNode - */ - public get serialized(): TextNodeSerialized { - return Object.assign({ [NODE_TYPE_HIDDEN_PROP]: BlockChildType.Text as const }, super.serialized); - } - - /** - * Overridden method to get fragments of the TextNode - * Returns all fragments if no tool is specified - * @param [start] - start char index of the range - * @param [end] - end char index of the range - * @param [tool] - name of the Inline Tool - */ - public getFragments(start?: number, end?: number, tool?: InlineToolName): InlineFragment[] { - let fragments = super.getFragments(start, end); - - if (tool) { - fragments = fragments.filter(fragment => fragment.tool === tool); - } - - return fragments; - } - - /** - * Private method to initialize the TextNode with passed initial data - * @param value - initial text value to insert - * @param fragments - initial inline fragments to apply - */ - #initialize(value: string, fragments: InlineFragment[]): void { - if (!value) { - return; - } - - this.insertText(value); - - fragments.forEach((fragment) => { - this.format(fragment.tool, ...fragment.range, fragment.data); - }); - } -} diff --git a/packages/model/src/entities/inline-fragments/index.ts b/packages/model/src/entities/inline-fragments/index.ts deleted file mode 100644 index b1feb5ed..00000000 --- a/packages/model/src/entities/inline-fragments/index.ts +++ /dev/null @@ -1,7 +0,0 @@ -export * from './FormattingInlineNode/index.js'; -export * from './ParentInlineNode/index.js'; -export * from './TextNode/index.js'; -export * from './TextInlineNode/index.js'; -export * from './mixins/ChildNode/index.js'; -export * from './mixins/ParentNode/index.js'; -export type { InlineNode } from './InlineNode/index.js'; diff --git a/packages/model/src/entities/inline-fragments/mixins/ChildNode/__mocks__/index.ts b/packages/model/src/entities/inline-fragments/mixins/ChildNode/__mocks__/index.ts deleted file mode 100644 index 9180bb50..00000000 --- a/packages/model/src/entities/inline-fragments/mixins/ChildNode/__mocks__/index.ts +++ /dev/null @@ -1,61 +0,0 @@ -import type { InlineNode } from '../../../InlineNode/index.js'; -import type { ParentNode } from '../../ParentNode/index.js'; - -/** - * Mock for ChildNode decorator - */ -export function ChildNode(constructor: { new(): InlineNode }): { new(): InlineNode } { - return class extends constructor { - /** - * Parent mock - */ - public parent: ParentNode | null = null; - /** - * Mock property - */ - // eslint-disable-next-line @typescript-eslint/no-magic-numbers - public length = 5; - - /** - * Mock method - * @param parent - parent to append the node to - */ - public appendTo(parent: ParentNode): void { - if (this.parent === parent) { - return; - } - - this.parent = parent; - - parent.append(this); - } - - /** - * Mock method - */ - public remove(): void { - return; - } - - /** - * Mock method - */ - public normalize(): void { - return; - } - - /** - * Mock method - */ - public isEqual(): boolean { - return false; - } - - /** - * Mock method - */ - public mergeWith(): void { - return; - } - }; -} diff --git a/packages/model/src/entities/inline-fragments/mixins/ChildNode/index.ts b/packages/model/src/entities/inline-fragments/mixins/ChildNode/index.ts deleted file mode 100644 index 518a5ab6..00000000 --- a/packages/model/src/entities/inline-fragments/mixins/ChildNode/index.ts +++ /dev/null @@ -1,101 +0,0 @@ -import type { ParentNode } from '../ParentNode/index.js'; -import type { InlineNode } from '../../InlineNode/index.js'; - -/** - * Abstract child node interface - */ -export interface ChildNode extends InlineNode { - /** - * Appends this node to passed parent node - * @param parent - new parent - */ - appendTo(parent: ParentNode): void; - - /** - * Removes this node from parent - */ - remove(): void; - - /** - * Node's parent - */ - parent: ParentNode | null; -} - -export interface ChildNodeConstructorOptions { - parent?: ParentNode; -} - -/** - * ChildNode decorator to mixin ChildNode's methods - * @param constructor - class to decorate - * @example - * - * ```ts - * // interface is required to let TS know about ChildNode's methods - * interface MyNode extends ChildNode {} - * - * @ChildNode - * class MyNode {} - * ``` - */ -// eslint-disable-next-line @typescript-eslint/no-explicit-any -- any type here is a TS requirement for mixin classes -export function ChildNode(constructor: C): C { - // eslint-disable-next-line @typescript-eslint/no-shadow - return class ChildNode extends constructor { - /** - * Node's parent - */ - #parent: ParentNode | null; - - /** - * @param args — constructor arguments - * @param [args.parent] - optional node's parent - */ - // Stryker disable next-line BlockStatement -- Styker's bug, see https://github.com/stryker-mutator/stryker-js/issues/2474 - // eslint-disable-next-line @typescript-eslint/no-explicit-any -- any type here is a TS requirement for mixin classes - constructor(...args: any[]) { - const { parent, ...rest } = args[0] as ChildNodeConstructorOptions ?? {}; - - super(rest); - - this.#parent = parent ?? null; - - this.parent?.append(this); - } - - /** - * Returns node's parent - */ - public get parent(): ParentNode | null { - return this.#parent; - } - - /** - * Appends this node to passed parent node - * @param parent - new parent - */ - public appendTo(parent: ParentNode): void { - if (this.parent === parent) { - return; - } - - this.parent?.removeChild(this); - - this.#parent = parent; - - parent.append(this); - } - - /** - * Removes this node from parent - */ - public remove(): void { - const parent = this.parent; - - this.#parent = null; - - parent?.removeChild(this); - } - }; -} diff --git a/packages/model/src/entities/inline-fragments/mixins/ParentNode/__mocks__/index.ts b/packages/model/src/entities/inline-fragments/mixins/ParentNode/__mocks__/index.ts deleted file mode 100644 index 53a7e9a2..00000000 --- a/packages/model/src/entities/inline-fragments/mixins/ParentNode/__mocks__/index.ts +++ /dev/null @@ -1,22 +0,0 @@ -import type { InlineNode } from '../../../InlineNode/index.js'; - -/** - * Mock for ParentNode decorator - */ -export function ParentNode(constructor: { new(): InlineNode }): { new(): InlineNode } { - return class extends constructor { - /** - * Mock method - */ - public append(): void { - return; - } - - /** - * Mock method - */ - public removeChild(): void { - return; - } - }; -} diff --git a/packages/model/src/entities/inline-fragments/mixins/ParentNode/index.ts b/packages/model/src/entities/inline-fragments/mixins/ParentNode/index.ts deleted file mode 100644 index 5734c272..00000000 --- a/packages/model/src/entities/inline-fragments/mixins/ParentNode/index.ts +++ /dev/null @@ -1,187 +0,0 @@ -import type { ChildNode } from '../ChildNode/index.js'; -import type { InlineNode } from '../../InlineNode/index.js'; - -/** - * Abstract parent node interface - */ -export interface ParentNode extends InlineNode { - /** - * Node's children - */ - readonly children: ChildNode[]; - - /** - * Appends passed children to this node - * @param children - array of children to append - */ - append(...children: ChildNode[]): void; - - /** - * Removes a child from the parent - * @param child - child to remove - */ - removeChild(child: ChildNode): void; - - /** - * Inserts new children after specified target - * @param target - target after which to insert new children - * @param children - children nodes to insert - */ - insertAfter(target: ChildNode, ...children: ChildNode[]): void; - - /** - * Normalizes node's children - */ - normalize(): void; -} - -export interface ParentNodeConstructorOptions { - children?: ChildNode[]; -} - -/** - * ParentNode decorator to mixin ParentNode's methods - * @param constructor - class to decorate - * @example - * - * ```ts - * // interface is required to let TS know about ParentNode's methods - * interface MyNode extends ParentNode {} - * - * @ParentNode - * class MyNode {} - * ``` - */ -// eslint-disable-next-line @typescript-eslint/no-explicit-any -- any type here is a TS requirement for mixin classes -export function ParentNode(constructor: C): C { - return class extends constructor { - #children: ChildNode[] = []; - - /** - * @param args — constructor arguments - * @param [args.children] - optional node's children - */ - // Stryker disable next-line BlockStatement -- Styker's bug, see https://github.com/stryker-mutator/stryker-js/issues/2474 - // eslint-disable-next-line @typescript-eslint/no-explicit-any -- any type here is a TS requirement for mixin classes - constructor(...args: any[]) { - const { children = [], ...rest } = args[0] as ParentNodeConstructorOptions ?? {}; - - super(rest); - - children.forEach(child => child.appendTo(this)); - } - - /** - * Returns node's children - */ - public get children(): ChildNode[] { - return this.#children; - } - - /** - * Returns text value length of current node (including subtree) - */ - public get length(): number { - return this.children.reduce((sum, child) => sum + child.length, 0); - } - - /** - * Appends passed children to this node - * @param children - array of children to append - */ - public append(...children: ChildNode[]): void { - /** - * If node is already a child of current node, remove it to append at the end - */ - children.forEach((child) => { - const index = this.children.indexOf(child); - - if (index === -1) { - return; - } - - this.children.splice(index, 1); - }); - - this.children.push(...children); - - children.forEach(child => child.appendTo(this)); - } - - /** - * Removes a child from the parent - * @param child - child to remove - */ - public removeChild(child: ChildNode): void { - const index = this.children.indexOf(child); - - if (index === -1) { - return; - } - - this.children.splice(index, 1); - - child.remove(); - } - - /** - * Inserts new children after specified target - * @param target - target after which to insert new children - * @param children - children nodes to insert - */ - public insertAfter(target: ChildNode, ...children: ChildNode[]): void { - /** - * We need to get the index first before any manipulations with children array - */ - const targetIndex = this.children.indexOf(target); - - /** - * Append children to the parent to set their parent property - */ - children.forEach(child => child.appendTo(this)); - - /** - * Remove all appended children from the children array to insert if on the next step - */ - children.forEach((child) => { - const index = this.children.indexOf(child); - - this.children.splice(index, 1); - }); - - /** - * Insert added children to correct places - */ - this.children.splice(targetIndex + 1, 0, ...children); - } - - /** - * Normalizes node's subtree - */ - public normalize(): void { - const children = Array.from(this.children); - - if (children.length === 0) { - return; - } - - children.reduce((prev, child) => { - if (prev !== undefined && prev.isEqual(child)) { - prev.mergeWith(child); - - return prev; - } - - return child; - }); - - children.forEach((child) => { - if (child.length === 0) { - child.remove(); - } - }); - - this.children.forEach(child => child.normalize()); - } - }; -} diff --git a/packages/model/src/entities/inline-fragments/specs/ChildNode.spec.ts b/packages/model/src/entities/inline-fragments/specs/ChildNode.spec.ts deleted file mode 100644 index 54788720..00000000 --- a/packages/model/src/entities/inline-fragments/specs/ChildNode.spec.ts +++ /dev/null @@ -1,129 +0,0 @@ -import { ChildNode } from '../mixins/ChildNode/index.js'; -import { ParentNode } from '../mixins/ParentNode/index.js'; - -jest.mock('../mixins/ParentNode'); - -// eslint-disable-next-line @typescript-eslint/no-empty-object-type -interface Dummy extends ChildNode { -} - -/** - * Dummy Node's class - */ -@ChildNode -class Dummy { - /** - * - * @param _options - dummy options - */ - // eslint-disable-next-line @typescript-eslint/no-empty-function,@typescript-eslint/no-unused-vars,no-unused-vars - constructor(_options?: unknown) {} -} - -// eslint-disable-next-line @typescript-eslint/no-empty-object-type -interface ParentDummy extends ParentNode {} - -/** - * ParentNode class dummy - */ -@ParentNode -class ParentDummy {} - -describe('ChildNode mixin', () => { - let dummy: Dummy; - let parentMock: ParentNode; - - beforeEach(() => { - parentMock = new ParentDummy(); - - jest.resetAllMocks(); - }); - - afterEach(() => { - jest.clearAllMocks(); - }); - - it('should decorated class to a parent', () => { - const spy = jest.spyOn(parentMock, 'append'); - - dummy = new Dummy({ parent: parentMock }); - - expect(spy).toHaveBeenCalledWith(dummy); - }); - - it('should add remove method to the decorated class', () => { - expect(dummy.remove).toBeInstanceOf(Function); - }); - - it('should add appendTo method to the decorated class', () => { - expect(dummy.appendTo).toBeInstanceOf(Function); - }); - - describe('.parent', () => { - it('should return null by default', () => { - dummy = new Dummy(); - - expect(dummy.parent).toBeNull(); - }); - - it('should return parent passed via constructor', () => { - dummy = new Dummy({ parent: parentMock }); - - expect(dummy.parent).toEqual(parentMock); - }); - }); - - describe('.remove()', () => { - beforeEach(() => { - dummy = new Dummy({ - parent: parentMock, - }); - }); - - it('should call parent\'s removeChild method', () => { - const spy = jest.spyOn(parentMock, 'removeChild'); - - dummy.remove(); - - expect(spy).toHaveBeenCalledWith(dummy); - }); - - it('should set node\'s parent to null', () => { - dummy.remove(); - - expect(dummy.parent).toBeNull(); - }); - }); - - describe('.appendTo()', () => { - beforeEach(() => { - dummy = new Dummy(); - }); - - it('should call parent\'s append method on appendTo call', () => { - const spy = jest.spyOn(parentMock, 'append'); - - dummy.appendTo(parentMock); - - expect(spy).toHaveBeenCalledWith(dummy); - }); - - it('should set node\'s parent on appendTo call', () => { - dummy.appendTo(parentMock); - - expect(dummy.parent).toBe(parentMock); - }); - - it('should do nothing if parents are the same', () => { - const dummyWithParent = new Dummy({ - parent: parentMock, - }); - - const spy = jest.spyOn(parentMock, 'append'); - - dummyWithParent.appendTo(parentMock); - - expect(spy).not.toHaveBeenCalled(); - }); - }); -}); diff --git a/packages/model/src/entities/inline-fragments/specs/FormattingInlineNode.spec.ts b/packages/model/src/entities/inline-fragments/specs/FormattingInlineNode.spec.ts deleted file mode 100644 index 6e09bf58..00000000 --- a/packages/model/src/entities/inline-fragments/specs/FormattingInlineNode.spec.ts +++ /dev/null @@ -1,333 +0,0 @@ -import { createInlineToolData, createInlineToolName } from '@editorjs/model-types'; -import type { InlineNode } from '../InlineNode/index.js'; -import type { ChildNode } from '../index.js'; -import { TextInlineNode, FormattingInlineNode } from '../index.js'; -import type { ParentNode } from '../mixins/ParentNode/index.js'; -import { ParentInlineNode } from '../ParentInlineNode/index.js'; - -jest.mock('../ParentInlineNode'); -jest.mock('../TextInlineNode'); - -describe('FormattingInlineNode', () => { - let parent: ParentNode; - let firstChildMock: TextInlineNode; - let secondChildMock: TextInlineNode; - let thirdChildMock: TextInlineNode; - - const tool = createInlineToolName('bold'); - const anotherTool = createInlineToolName('italic'); - const data = createInlineToolData({}); - let node: FormattingInlineNode; - let children: ChildNode[]; - - beforeEach(() => { - parent = new FormattingInlineNode({ tool: createInlineToolName('parentTool') }); - firstChildMock = new TextInlineNode({ value: 'Some text here. ' }); - secondChildMock = new TextInlineNode({ value: 'Another text here.' }); - thirdChildMock = new TextInlineNode({ value: 'Some more text.' }); - - children = [firstChildMock, secondChildMock, thirdChildMock]; - - node = new FormattingInlineNode({ - tool, - data, - parent, - children, - }); - - jest.clearAllMocks(); - }); - - describe('.removeText()', () => { - it('should call parents removeText() method', () => { - const start = 0; - const end = 3; - - const spy = jest.spyOn(ParentInlineNode.prototype, 'removeText'); - - node.removeText(start, end); - - expect(spy).toHaveBeenCalledWith(start, end); - }); - - it('should return removed text', () => { - const removedText = 'Editor.js is a block-styled editor'; - - jest.spyOn(FormattingInlineNode.prototype, 'removeText').mockImplementationOnce(() => removedText); - - const result = node.removeText(); - - expect(result).toEqual(removedText); - }); - - it('should call remove() if length is 0 after removeText() call', () => { - const removeSpy = jest.spyOn(node, 'remove'); - const lengthSpy = jest.spyOn(node, 'length', 'get').mockImplementation(() => 0); - - node.removeText(); - - expect(removeSpy).toHaveBeenCalled(); - - removeSpy.mockRestore(); - lengthSpy.mockRestore(); - }); - }); - - describe('.getFragments()', () => { - it('should call parents getFragments() method', () => { - const start = 0; - const end = 3; - - const spy = jest.spyOn(ParentInlineNode.prototype, 'getFragments'); - - node.getFragments(start, end); - - expect(spy).toHaveBeenCalledWith(start, end); - }); - - it('should return fragment with the range from 0 to the length of formatting node', () => { - const start = 0; - const end = 3; - - const result = node.getFragments(start, end); - - expect(result[0]).toEqual(expect.objectContaining({ - tool: node.tool, - range: [0, node.length], - })); - }); - - it('should add tool\'s data if it exists', () => { - const result = node.getFragments(); - - expect(result[0]).toHaveProperty('data', data); - }); - - it('should not add tool\'s data if it doesn\'t exist', () => { - node = new FormattingInlineNode({ tool }); - - const result = node.getFragments(); - - expect(result[0]).not.toHaveProperty('data'); - }); - }); - - describe('.split()', () => { - const index = 5; - - it('should throw an error if index is invalid', () => { - expect(() => node.split(-1)).toThrow(); - expect(() => node.split(node.length + 1)).toThrow(); - }); - - it('should not split (return null) if index is 0', () => { - const newNode = node.split(0); - - expect(newNode).toBeNull(); - }); - - it('should not split (return null) if index equals text length', () => { - const newNode = node.split(node.length); - - expect(newNode).toBeNull(); - }); - - it('should create new FormattingInlineNode on split', () => { - const newNode = node.split(index); - - expect(newNode).toBeInstanceOf(FormattingInlineNode); - }); - - it('should create new FormattingInlineNode with children split from the original one', () => { - const newNode = node.split(firstChildMock.length); - - expect(newNode?.children).toEqual([secondChildMock, thirdChildMock]); - }); - - it('should call split method of child containing the specified index', () => { - const spy = jest.spyOn(secondChildMock, 'split'); - - node.split(index + firstChildMock.length); - - expect(spy).toHaveBeenCalledWith(index); - }); - - it('should insert new node to the parent', () => { - const spy = jest.spyOn(parent, 'insertAfter'); - - const newNode = node.split(index); - - expect(spy).toHaveBeenCalledWith(node, newNode); - }); - }); - - describe('.format()', () => { - const start = 3; - const end = 5; - - it('should return empty array if formatting is already applied', () => { - const result = node.format(tool, start, end); - - expect(result).toHaveLength(0); - }); - - it('should call parent format() method', () => { - const spy = jest.spyOn(ParentInlineNode.prototype, 'format'); - - node.format(anotherTool, start, end, data); - - expect(spy).toHaveBeenCalledWith(anotherTool, start, end, data); - }); - }); - - describe('.unformat()', () => { - const start = 3; - const end = 5; - let childNode: TextInlineNode; - - beforeEach(() => { - parent = new FormattingInlineNode({ tool: createInlineToolName('parentTool') }); - - childNode = new TextInlineNode({ - value: 'Editor.js is a block-styled editor', - }); - - node = new FormattingInlineNode({ - tool, - data, - parent: parent as FormattingInlineNode, - children: [childNode], - }); - }); - - it('should call parents unformat() method if tools are unequal', () => { - const spy = jest.spyOn(ParentInlineNode.prototype, 'unformat'); - - node.unformat(anotherTool, start, end); - - expect(spy).toHaveBeenCalledWith(anotherTool, start, end); - }); - - it('should not call parent unformat() method if tools are equal', () => { - const spy = jest.spyOn(ParentInlineNode.prototype, 'unformat'); - - node.unformat(tool, start, end); - - expect(spy).not.toHaveBeenCalled(); - }); - - it('should split node into two if unformatting applied from the start to the middle of the text', () => { - const result = node.unformat(tool, 0, end); - - expect(result).toEqual([ - expect.any(TextInlineNode), - expect.any(FormattingInlineNode), - ]); - }); - - it('should remove unformatted node from parent if unformatting applied from the start to the middle of the text', () => { - const result = node.unformat(tool, 0, end); - - expect(parent.children).toHaveLength(result.length); - }); - - it('should split node into tree if unformatting applied in the middle of the node', () => { - const result = node.unformat(tool, start, end); - - expect(result).toEqual([ - expect.any(FormattingInlineNode), - expect.any(TextInlineNode), - expect.any(FormattingInlineNode), - ]); - }); - - it('should remove unformatted node from parent if unformatting applied in the middle of the node', () => { - const result = node.unformat(tool, start, end); - - expect(parent.children).toHaveLength(result.length); - }); - - it('should split node into two if unformatting applied at the end of the node', () => { - const result = node.unformat(tool, end, node.length); - - expect(result).toEqual([ - expect.any(FormattingInlineNode), - expect.any(TextInlineNode), - ]); - }); - - it('should remove unformatted node from parent if unformatting applied at the end of the node', () => { - const result = node.unformat(tool, end, node.length); - - expect(parent.children).toHaveLength(result.length); - }); - }); - - describe('.isEqual()', () => { - it('should return true for FormattingInlineNode with the same tool name', () => { - const nodeToCompare = new FormattingInlineNode({ tool }); - - expect(node.isEqual(nodeToCompare)).toEqual(true); - }); - - it('should return false for not FormattingInlineNode object', () => { - const nodeToCompare = {} as InlineNode; - - expect(node.isEqual(nodeToCompare)).toEqual(false); - }); - - it('should return false for FormattingInlineNode with another tool name', () => { - const nodeToCompare = new FormattingInlineNode({ tool: anotherTool }); - - expect(node.isEqual(nodeToCompare)).toEqual(false); - }); - }); - - describe('.mergeWith()', () => { - it('should append children of merged node to the current', () => { - const child = new TextInlineNode({ value: 'Text node' }); - const nodeToMerge = new FormattingInlineNode({ - tool, - children: [child], - }); - - const spy = jest.spyOn(node, 'append'); - - node.mergeWith(nodeToMerge); - - expect(spy).toHaveBeenCalledWith(child); - }); - - it('should append several children of merged node to the current', () => { - const firstChild = new TextInlineNode({ value: 'Text node' }); - const secondChild = new FormattingInlineNode({ tool: anotherTool }); - const nodeToMerge = new FormattingInlineNode({ - tool, - children: [firstChild, secondChild], - }); - - const spy = jest.spyOn(node, 'append'); - - node.mergeWith(nodeToMerge); - - expect(spy).toHaveBeenCalledWith(firstChild); - expect(spy).toHaveBeenCalledWith(secondChild); - }); - - it('should remove merged node', () => { - const nodeToMerge = new FormattingInlineNode({ tool }); - - const spy = jest.spyOn(nodeToMerge, 'remove'); - - node.mergeWith(nodeToMerge); - - expect(spy).toHaveBeenCalled(); - }); - - it('should throw an error if node to merge is not equal to the current', () => { - const nodeToMerge = new FormattingInlineNode({ tool: anotherTool }); - - expect(() => node.mergeWith(nodeToMerge)).toThrow(); - }); - }); -}); diff --git a/packages/model/src/entities/inline-fragments/specs/ParentChild.integration.spec.ts b/packages/model/src/entities/inline-fragments/specs/ParentChild.integration.spec.ts deleted file mode 100644 index 6642bee7..00000000 --- a/packages/model/src/entities/inline-fragments/specs/ParentChild.integration.spec.ts +++ /dev/null @@ -1,116 +0,0 @@ -import { ParentNode } from '../mixins/ParentNode/index.js'; -import { ChildNode } from '../mixins/ChildNode/index.js'; - -// eslint-disable-next-line @typescript-eslint/no-empty-object-type -interface DummyParent extends ParentNode {} - -/** - * DummyParent class - */ -@ParentNode -class DummyParent { - /** - * - * @param _options - dummy options - */ - // eslint-disable-next-line @typescript-eslint/no-empty-function,@typescript-eslint/no-unused-vars,no-unused-vars - constructor(_options?: unknown) {} -} - -// eslint-disable-next-line @typescript-eslint/no-empty-object-type -interface DummyChild extends ChildNode {} - -/** - * DummyChild class - */ -@ChildNode -class DummyChild { - /** - * @param _options - dummy options - */ - // eslint-disable-next-line @typescript-eslint/no-empty-function,@typescript-eslint/no-unused-vars,no-unused-vars - constructor(_options?: unknown) {} -} - -describe('ParentNode and ChildNode integration', () => { - describe('child removal', () => { - let parent: DummyParent; - let child: DummyChild; - - beforeEach(() => { - parent = new DummyParent(); - child = new DummyChild({ parent }); - }); - - it('should remove child from parent on child.remove() call', () => { - child.remove(); - - expect(parent.children).not.toContain(child); - }); - - it('should set child\'s parent to null on parent.removeChild() call', () => { - parent.removeChild(child); - - expect(child.parent).toBeNull(); - }); - }); - - describe('child addition', () => { - let parent: DummyParent; - let child: DummyChild; - - beforeEach(() => { - parent = new DummyParent(); - child = new DummyChild(); - }); - - it('should add child to parent on child.appendTo call', () => { - child.appendTo(parent); - - expect(parent.children).toContain(child); - }); - - it('should set child\'s parent on parent.append() call', () => { - parent.append(child); - - expect(child.parent).toEqual(parent); - }); - - it('should set child\'s parent on parent.insertAfter() call', () => { - const anotherChild = new DummyChild(); - - parent.append(child); - - parent.insertAfter(child, anotherChild); - - expect(anotherChild.parent).toEqual(parent); - }); - }); - - describe('child transfer from parent to parent', () => { - let parent: DummyParent; - let anotherParent: DummyParent; - let child: DummyChild; - - beforeEach(() => { - parent = new DummyParent(); - child = new DummyChild({ parent }); - - anotherParent = new DummyParent(); - }); - - it('should remove child from the old parent on new parent.append() call', () => { - anotherParent.append(child); - - expect(parent.children).not.toContain(child); - }); - - it('should remove child from the old parent on new parent.insertAfter() call', () => { - const anotherChild = new DummyChild({ parent: anotherParent }); - - anotherParent.insertAfter(anotherChild, child); - - expect(parent.children).not.toContain(child); - }); - }); -}); diff --git a/packages/model/src/entities/inline-fragments/specs/ParentInlineNode.spec.ts b/packages/model/src/entities/inline-fragments/specs/ParentInlineNode.spec.ts deleted file mode 100644 index ea897bcd..00000000 --- a/packages/model/src/entities/inline-fragments/specs/ParentInlineNode.spec.ts +++ /dev/null @@ -1,575 +0,0 @@ -import { createInlineToolData } from '@editorjs/model-types'; -import type { InlineToolName } from '@editorjs/model-types'; -import type { InlineNode } from '../InlineNode/index.js'; -import type { ChildNode } from '../index.js'; -import { TextInlineNode, FormattingInlineNode } from '../index.js'; -import { ParentInlineNode } from '../ParentInlineNode/index.js'; -import { EventType, EventAction } from '@editorjs/model-types'; -import { - TextAddedEvent, - TextFormattedEvent, - TextRemovedEvent, - TextUnformattedEvent -} from '@editorjs/model-types'; - -jest.mock('../TextInlineNode'); -jest.mock('../FormattingInlineNode'); - -describe('ParentInlineNode', () => { - let childMock: TextInlineNode; - let anotherChildMock: TextInlineNode; - let formattingNodeMock: FormattingInlineNode; - let anotherFormattingNodeMock: FormattingInlineNode; - let children: ChildNode[]; - - let node: ParentInlineNode; - - beforeEach(() => { - childMock = new TextInlineNode({ value: 'Some text here. ' }); - anotherChildMock = new TextInlineNode({ value: 'Another text here.' }); - formattingNodeMock = new FormattingInlineNode({ - tool: 'bold' as InlineToolName, - children: [anotherChildMock], - }); - anotherFormattingNodeMock = new FormattingInlineNode({ - tool: 'italic' as InlineToolName, - children: [new TextInlineNode({ value: 'Some italic text.' })], - }); - - children = [childMock, formattingNodeMock, anotherFormattingNodeMock]; - - node = new ParentInlineNode({ - children: children, - }); - }); - - describe('.length', () => { - it('should return sum of lengths of children', () => { - expect(node.length).toEqual(childMock.length + formattingNodeMock.length + anotherFormattingNodeMock.length); - }); - }); - - describe('.serialized', () => { - it('should get node\'s text', () => { - const spy = jest.spyOn(node, 'getText'); - - node.serialized; - - expect(spy).toHaveBeenCalled(); - }); - - it('should get node\'s fragments', () => { - const spy = jest.spyOn(node, 'getFragments'); - - node.serialized; - - expect(spy).toHaveBeenCalled(); - }); - - it('should have correct data format', () => { - const result = node.serialized; - - expect(result).toHaveProperty('value'); - expect(result).toHaveProperty('fragments'); - }); - }); - - describe('.getText()', () => { - const start = 3; - const end = 5; - - it('should throw an error if start index is invalid', () => { - expect(() => node.getText(-1)).toThrow(); - expect(() => node.getText(node.length + 1)).toThrow(); - }); - - it('should throw an error if end index is invalid', () => { - expect(() => node.getText(0, -1)).toThrow(); - expect(() => node.getText(0, node.length + 1)).toThrow(); - }); - - it('should throw an error if end is less than start', () => { - expect(() => node.getText(end, start)).toThrow(); - }); - - it('should call getText() for the relevant child', () => { - const spy = jest.spyOn(childMock, 'getText'); - - node.getText(start, end); - - expect(spy).toHaveBeenCalledWith(start, end); - }); - - it('should adjust index by child offset', () => { - const spy = jest.spyOn(formattingNodeMock, 'getText'); - - const offset = childMock.length; - - node.getText(offset + start, offset + end); - - expect(spy).toHaveBeenCalledWith(start, end); - }); - - it('should not call getText() for previous child if start equals its length', () => { - const spy = jest.spyOn(childMock, 'getText'); - - const childLength = childMock.length; - - node.getText(childLength, childLength + end); - - expect(spy).not.toHaveBeenCalled(); - }); - - it('should not call getText() for next child if end equals its start index', () => { - const spy = jest.spyOn(formattingNodeMock, 'getText'); - - node.getText(start, childMock.length); - - expect(spy).not.toHaveBeenCalled(); - }); - - it('should not call getText() for if start equals end', () => { - const spy = jest.spyOn(childMock, 'getText'); - - node.getText(start, start); - - expect(spy).not.toHaveBeenCalled(); - }); - - it('should call getText for all relevant children', () => { - const spy = jest.spyOn(childMock, 'getText'); - const anotherSpy = jest.spyOn(formattingNodeMock, 'getText'); - const offset = childMock.length; - - node.getText(start, offset + end); - - expect(spy).toHaveBeenCalledWith(start, offset); - expect(anotherSpy).toHaveBeenCalledWith(0, end); - }); - - it('should return all text by default', () => { - const spy = jest.spyOn(childMock, 'getText'); - const anotherSpy = jest.spyOn(formattingNodeMock, 'getText'); - - node.getText(); - - expect(spy).toHaveBeenCalledWith(0, childMock.length); - expect(anotherSpy).toHaveBeenCalledWith(0, anotherChildMock.length); - }); - }); - - describe('.insertText()', () => { - const newText = 'new text'; - const index = 3; - - it('should throw a error if index is invalid', () => { - expect(() => node.insertText(newText, -1)).toThrow(); - expect(() => node.insertText(newText, node.length + 1)).toThrow(); - }); - - it('should create empty text node if node is empty', () => { - node = new ParentInlineNode(); - - node.insertText(newText); - - expect(node.children).toEqual([expect.any(TextInlineNode)]); - }); - - it('should not append empty node if there is already a child node', () => { - const spy = jest.spyOn(node, 'append'); - - node.insertText(newText); - - expect(spy).not.toHaveBeenCalled(); - }); - - it('should call insertText() of the child with the passed index', () => { - const spy = jest.spyOn(childMock, 'insertText'); - - node.insertText(newText, index); - - expect(spy).toHaveBeenCalledWith(newText, index); - }); - - it('should adjust index by child offset', () => { - const spy = jest.spyOn(formattingNodeMock, 'insertText'); - - const offset = childMock.length; - - node.insertText(newText, index + offset); - - expect(spy).toHaveBeenCalledWith(newText, index); - }); - - it('should append text to the last child by default', () => { - const spy = jest.spyOn(anotherFormattingNodeMock, 'insertText'); - - node.insertText(newText); - - expect(spy).toHaveBeenCalledWith(newText, anotherFormattingNodeMock.length); - }); - - it('should normalize subtree on insertion', () => { - const spy = jest.spyOn(node, 'normalize'); - - node.insertText(newText); - - expect(spy).toHaveBeenCalled(); - }); - - it('should emit TextAddedEvent with correct text as data and text range as index', () => { - let event: TextAddedEvent | null = null; - - node.addEventListener(EventType.Changed, e => event = e as TextAddedEvent); - - node.insertText(newText, index); - - expect(event).toBeInstanceOf(TextAddedEvent); - expect(event).toHaveProperty('detail', expect.objectContaining({ - action: EventAction.Added, - index: expect.objectContaining({ textRange: [index, index] }), - data: newText, - })); - }); - }); - - describe('.removeText()', () => { - const start = 3; - const end = 5; - - it('should throw a error if start index is invalid', () => { - expect(() => node.removeText(-1)).toThrow(); - expect(() => node.removeText(node.length + 1)).toThrow(); - }); - - it('should throw an error if end index is invalid', () => { - expect(() => node.removeText(0, -1)).toThrow(); - expect(() => node.removeText(0, node.length + 1)).toThrow(); - }); - - it('should throw an error if end is less than start', () => { - expect(() => node.removeText(end, start)).toThrow(); - }); - - it('should remove text from appropriate child', () => { - const spy = jest.spyOn(childMock, 'removeText'); - - node.removeText(start, end); - - expect(spy).toHaveBeenCalledWith(start, end); - }); - - it('should adjust indices by child offset', () => { - const spy = jest.spyOn(formattingNodeMock, 'removeText'); - - const offset = childMock.length; - - node.removeText(offset + start, offset + end); - - expect(spy).toHaveBeenCalledWith(start, end); - }); - - it('should call removeText for each affected child', () => { - const spy = jest.spyOn(childMock, 'removeText'); - const anotherSpy = jest.spyOn(formattingNodeMock, 'removeText'); - - const offset = childMock.length; - - node.removeText(start, offset + end); - - expect(spy).toHaveBeenCalledWith(start, offset); - expect(anotherSpy).toHaveBeenCalledWith(0, end); - }); - - it('should remove all text by default', () => { - const spy = jest.spyOn(childMock, 'removeText'); - const anotherSpy = jest.spyOn(formattingNodeMock, 'removeText'); - - node.removeText(); - - expect(spy).toHaveBeenCalledWith(0, childMock.length); - expect(anotherSpy).toHaveBeenCalledWith(0, formattingNodeMock.length); - }); - - it('should normalize subtree on removal', () => { - const spy = jest.spyOn(node, 'normalize'); - - node.removeText(); - - expect(spy).toHaveBeenCalled(); - }); - - it('should emit TextRemovedEvent with removed text as data and range as index', () => { - let event: TextRemovedEvent | null = null; - - node.addEventListener(EventType.Changed, e => event = e as TextRemovedEvent); - - node.removeText(start, end); - - expect(event).toBeInstanceOf(TextRemovedEvent); - expect(event).toHaveProperty('detail', expect.objectContaining({ - action: EventAction.Removed, - index: expect.objectContaining({ textRange: [start, end] }), - })); - }); - }); - - describe('.getFragments()', () => { - let start: number; - let end: number; - const offset = 3; - - beforeEach(() => { - start = childMock.length; - end = start + offset; - }); - - it('should throw a error if start index is invalid', () => { - expect(() => node.getFragments(-1)).toThrow(); - expect(() => node.getFragments(node.length + 1)).toThrow(); - }); - - it('should throw an error if end index is invalid', () => { - expect(() => node.getFragments(0, -1)).toThrow(); - expect(() => node.getFragments(0, node.length + 1)).toThrow(); - }); - - it('should throw an error if end is less than start', () => { - expect(() => node.getFragments(end, start)).toThrow(); - }); - - it('should call getFragments for relevant children', () => { - const spyToBeCalled = jest.spyOn(formattingNodeMock, 'getFragments'); - const spyNotToBeCalled = jest.spyOn(anotherFormattingNodeMock, 'getFragments'); - - node.getFragments(start, end); - - expect(spyToBeCalled).toHaveBeenCalledWith(start - childMock.length, end - childMock.length); - expect(spyNotToBeCalled).not.toHaveBeenCalled(); - }); - - it('should not get fragments for text nodes', () => { - const result = node.getFragments(0, start - 1); - - expect(result).toHaveLength(0); - }); - - it('should normalize fragments for same tools', () => { - jest - .spyOn(formattingNodeMock, 'getFragments') - .mockImplementationOnce(() => ([ - { - tool: 'bold' as InlineToolName, - range: [0, formattingNodeMock.length], - }, - ])); - jest - .spyOn(anotherFormattingNodeMock, 'getFragments') - .mockImplementationOnce(() => ([ - { - tool: 'bold' as InlineToolName, - range: [0, anotherFormattingNodeMock.length], - }, - ])); - - const result = node.getFragments(); - - expect(result).toEqual([{ - tool: 'bold', - range: [childMock.length, node.length], - }]); - }); - - it('should not normalize fragments for different tools', () => { - jest - .spyOn(formattingNodeMock, 'getFragments') - .mockImplementationOnce(() => ([ - { - tool: 'bold' as InlineToolName, - range: [0, formattingNodeMock.length], - }, - ])); - jest - .spyOn(anotherFormattingNodeMock, 'getFragments') - .mockImplementationOnce(() => ([ - { - tool: 'italic' as InlineToolName, - range: [0, anotherFormattingNodeMock.length], - }, - ])); - - const result = node.getFragments(); - - expect(result).toEqual([ - { - tool: 'bold', - range: [childMock.length, childMock.length + formattingNodeMock.length], - }, - { - tool: 'italic', - range: [childMock.length + formattingNodeMock.length, node.length], - }, - ]); - }); - }); - - describe('.format()', () => { - const start = 3; - const end = 5; - const tool = 'bold' as InlineToolName; - - it('should throw a error if start index is invalid', () => { - expect(() => node.format(tool, -1, 0)).toThrow(); - expect(() => node.format(tool, node.length + 1, node.length)).toThrow(); - }); - - it('should throw an error if end index is invalid', () => { - expect(() => node.format(tool, 0, -1)).toThrow(); - expect(() => node.format(tool, 0, node.length + 1)).toThrow(); - }); - - it('should throw an error if end is less than start', () => { - expect(() => node.format(tool, end, start)).toThrow(); - }); - - it('should not throw an error if end equals start', () => { - expect(() => node.format(tool, start, start)).not.toThrow(); - }); - - it('should apply formatting to the relevant child', () => { - const spy = jest.spyOn(childMock, 'format'); - - node.format(tool, start, end); - - expect(spy).toHaveBeenCalledWith(tool, start, end, undefined); - }); - - it('should adjust index by child offset', () => { - const spy = jest.spyOn(formattingNodeMock, 'format'); - - const offset = childMock.length; - - node.format(tool, offset + start, offset + end); - - expect(spy).toHaveBeenCalledWith(tool, start, end, undefined); - }); - - it('should format all relevant children', () => { - const spy = jest.spyOn(childMock, 'format'); - const anotherSpy = jest.spyOn(formattingNodeMock, 'format'); - - const offset = childMock.length; - - node.format(tool, start, offset + end); - - expect(spy).toHaveBeenCalledWith(tool, start, offset, undefined); - expect(anotherSpy).toHaveBeenCalledWith(tool, 0, end, undefined); - }); - - it('should normalize subtree on format', () => { - const spy = jest.spyOn(node, 'normalize'); - - node.format(tool, start, end); - - expect(spy).toHaveBeenCalled(); - }); - - it('should emit TextFormattedEvent with inline fragment as data and affected range as index', () => { - let event: TextFormattedEvent | null = null; - const data = createInlineToolData({ - url: 'https://editorjs.io', - }); - - node.addEventListener(EventType.Changed, e => event = e as TextFormattedEvent); - - node.format(tool, start, end, data); - - expect(event).toBeInstanceOf(TextFormattedEvent); - expect(event).toHaveProperty('detail', expect.objectContaining({ - action: EventAction.Modified, - index: expect.objectContaining({ textRange: [start, end] }), - data: { - tool, - data, - }, - })); - }); - }); - - describe('.unformat()', () => { - let start: number; - let end: number; - - const tool = 'bold' as InlineToolName; - - beforeEach(() => { - start = childMock.length; - end = childMock.length + Math.round(formattingNodeMock.length / 2); - }); - - it('should remove formatting from the relevant child', () => { - const spy = jest.spyOn(formattingNodeMock, 'unformat'); - - node.unformat(tool, start, end); - - expect(spy).toHaveBeenCalledWith(tool, start - childMock.length, end - childMock.length); - }); - - it('should call unformat for all relevant children', () => { - const spy = jest.spyOn(formattingNodeMock, 'unformat'); - const anotherSpy = jest.spyOn(anotherFormattingNodeMock, 'unformat'); - - const offset = formattingNodeMock.length; - - node.unformat(tool, start, offset + end); - - expect(spy).toHaveBeenCalledWith(tool, start - childMock.length, offset); - expect(anotherSpy).toHaveBeenCalledWith(tool, 0, end - childMock.length); - }); - - it('should not unformat text nodes', () => { - const result = node.unformat(tool, 0, start - 1); - - expect(result).toHaveLength(0); - }); - - it('should normalize subtree on unformat', () => { - const spy = jest.spyOn(node, 'normalize'); - - node.unformat(tool, start, end); - - expect(spy).toHaveBeenCalled(); - }); - - it('should emit TextUnformattedEvent with inline fragment as data and range as index', () => { - let event: TextUnformattedEvent | null = null; - - node.addEventListener(EventType.Changed, e => event = e as TextUnformattedEvent); - - node.unformat(tool, start, end); - - expect(event).toBeInstanceOf(TextUnformattedEvent); - expect(event).toHaveProperty('detail', expect.objectContaining({ - action: EventAction.Modified, - index: expect.objectContaining({ textRange: [start, end] }), - data: { - tool, - }, - })); - }); - }); - - describe('.isEqual()', () => { - it('should return true for InlineParentNode', () => { - const result = node.isEqual(new ParentInlineNode()); - - expect(result).toEqual(true); - }); - - it('should return false for anything else', () => { - const result = node.isEqual({} as InlineNode); - - expect(result).toEqual(false); - }); - }); -}); diff --git a/packages/model/src/entities/inline-fragments/specs/ParentNode.spec.ts b/packages/model/src/entities/inline-fragments/specs/ParentNode.spec.ts deleted file mode 100644 index 02d2e9ef..00000000 --- a/packages/model/src/entities/inline-fragments/specs/ParentNode.spec.ts +++ /dev/null @@ -1,291 +0,0 @@ -import { ParentNode } from '../mixins/ParentNode/index.js'; -import { ChildNode } from '../mixins/ChildNode/index.js'; - -jest.mock('../mixins/ChildNode'); - -// eslint-disable-next-line @typescript-eslint/no-empty-object-type -interface Dummy extends ParentNode { -} - -/** - * ParentNode class dummy - */ -@ParentNode -class Dummy { - /** - * - * @param _options - dummy options - */ - // eslint-disable-next-line @typescript-eslint/no-empty-function,@typescript-eslint/no-unused-vars,no-unused-vars - constructor(_options?: unknown) {} -} - -// eslint-disable-next-line @typescript-eslint/no-empty-object-type -interface ChildDummy extends ChildNode {} - -/** - * ChildNode class dummy - */ -@ChildNode -class ChildDummy {} - -describe('ParentNode mixin', () => { - let dummy: Dummy; - - beforeEach(() => { - dummy = new Dummy(); - }); - - afterEach(() => { - jest.resetAllMocks(); - }); - - it('should add removeChild method to the decorated class', () => { - expect(dummy.removeChild).toBeInstanceOf(Function); - }); - - it('should add append method to the decorated class', () => { - expect(dummy.append).toBeInstanceOf(Function); - }); - - it('should add insertAfter method to the decorated class', () => { - expect(dummy.insertAfter).toBeInstanceOf(Function); - }); - - describe('constructor', () => { - it('should append passed children to new parent', () => { - const childMock = new ChildDummy(); - const spy = jest.spyOn(childMock, 'appendTo'); - - dummy = new Dummy({ - children: [childMock], - }); - - expect(spy).toHaveBeenCalledWith(dummy); - }); - }); - - describe('.length', () => { - it('should return sum of children lengths', () => { - const childMock = new ChildDummy(); - const anotherChildMock = new ChildDummy(); - - dummy.append(childMock, anotherChildMock); - - expect(dummy.length).toEqual(childMock.length + anotherChildMock.length); - }); - }); - - describe('.children', () => { - it('should return empty array by default', () => { - expect(dummy.children).toEqual([]); - }); - - it('should append children passed via constructor', () => { - const childMock = new ChildDummy(); - const spy = jest.spyOn(childMock, 'appendTo'); - - dummy = new Dummy({ - children: [childMock], - }); - - expect(spy).toHaveBeenCalledWith(dummy); - }); - }); - - describe('.append()', () => { - it('should add child to the children array', () => { - const childMock = new ChildDummy(); - - dummy.append(childMock); - - expect(dummy.children).toContain(childMock); - }); - - it('should add several children to the children array', () => { - const childMock = new ChildDummy(); - const anotherChildMock = new ChildDummy(); - - dummy.append(childMock, anotherChildMock); - - expect(dummy.children).toEqual([childMock, anotherChildMock]); - }); - - it('should append a child to the end of children array if it is already there', () => { - const childMock = new ChildDummy(); - const anotherChildMock = new ChildDummy(); - const oneMoreChildMock = new ChildDummy(); - - dummy.append(childMock, anotherChildMock, oneMoreChildMock); - - dummy.append(anotherChildMock); - - expect(dummy.children).toEqual([childMock, oneMoreChildMock, anotherChildMock]); - }); - - it('should preserve already existing children', () => { - const childMock = new ChildDummy(); - const anotherChildMock = new ChildDummy(); - const oneMoreChildMock = new ChildDummy(); - - dummy.append(childMock, anotherChildMock); - - dummy.append(oneMoreChildMock); - - expect(dummy.children).toEqual([childMock, anotherChildMock, oneMoreChildMock]); - }); - }); - - describe('.insertAfter()', () => { - it('should call child\'s appendTo methods', () => { - const childMock = new ChildDummy(); - const anotherChildMock = new ChildDummy(); - const childMockToInsert = new ChildDummy(); - - const spy = jest.spyOn(childMockToInsert, 'appendTo'); - - dummy = new Dummy({ - children: [childMock, anotherChildMock], - }); - - dummy.insertAfter(childMock, childMockToInsert); - - expect(spy).toHaveBeenCalledWith(dummy); - }); - - it('should call appendTo for each passed child', () => { - const childMock = new ChildDummy(); - const anotherChildMock = new ChildDummy(); - const childMockToInsert = new ChildDummy(); - const anotherChildMockToInsert = new ChildDummy(); - - const spies = [childMockToInsert, anotherChildMockToInsert].map(child => jest.spyOn(child, 'appendTo')); - - dummy = new Dummy({ - children: [childMock, anotherChildMock], - }); - - dummy.insertAfter(childMock, childMockToInsert, anotherChildMockToInsert); - - spies.forEach((spy) => { - expect(spy).toHaveBeenCalledWith(dummy); - }); - }); - - it('should remove existing child and insert it to the new place', () => { - const childMock = new ChildDummy(); - const anotherChildMock = new ChildDummy(); - const childMockToInsert = new ChildDummy(); - - dummy.append(childMock, childMockToInsert, anotherChildMock); - - dummy.insertAfter(anotherChildMock, childMockToInsert); - - expect(dummy.children).toEqual([childMock, anotherChildMock, childMockToInsert]); - }); - - it('should correctly insert children when it contains the target child', () => { - const childMock = new ChildDummy(); - const anotherChildMock = new ChildDummy(); - const childMockToInsert = new ChildDummy(); - const anotherChildMockToInsert = new ChildDummy(); - - dummy.append(childMock, childMockToInsert, anotherChildMock); - - dummy.insertAfter(childMockToInsert, anotherChildMockToInsert, childMockToInsert); - - expect(dummy.children).toEqual([childMock, anotherChildMock, anotherChildMockToInsert, childMockToInsert]); - }); - }); - - describe('.removeChild()', () => { - it('should remove child from the children array', () => { - const childMock = new ChildDummy(); - - dummy = new Dummy({ - children: [childMock], - }); - - dummy.removeChild(childMock); - - expect(dummy.children).toHaveLength(0); - }); - - it('should call remove method of child', () => { - const childMock = new ChildDummy(); - const spy = jest.spyOn(childMock, 'remove'); - - dummy = new Dummy({ - children: [childMock], - }); - - dummy.removeChild(childMock); - - expect(spy).toHaveBeenCalled(); - }); - }); - - describe('.normalize()', () => { - it('should call normalize for each child', () => { - const childMock = new ChildDummy(); - const anotherChildMock = new ChildDummy(); - - const spies = [childMock, anotherChildMock].map(child => jest.spyOn(child, 'normalize')); - - dummy.append(childMock, anotherChildMock); - - dummy.normalize(); - - spies.forEach(spy => expect(spy).toHaveBeenCalled()); - }); - - it('should merge two equal children', () => { - const childMock = new ChildDummy(); - const anotherChildMock = new ChildDummy(); - - jest.spyOn(childMock, 'isEqual').mockImplementation(() => true); - - const spy = jest.spyOn(childMock, 'mergeWith'); - - dummy.append(childMock, anotherChildMock); - - dummy.normalize(); - - expect(spy).toHaveBeenCalledWith(anotherChildMock); - }); - - it('should merge more than two equal children', () => { - const childMock = new ChildDummy(); - const anotherChildMock = new ChildDummy(); - const oneMoreChildMock = new ChildDummy(); - - jest.spyOn(childMock, 'isEqual').mockImplementation(() => true); - - const spy = jest.spyOn(childMock, 'mergeWith'); - - dummy.append(childMock, anotherChildMock, oneMoreChildMock); - - dummy.normalize(); - - expect(spy).toHaveBeenCalledWith(oneMoreChildMock); - }); - - it('should remove child if it\'s length is 0', () => { - const childMock = new ChildDummy(); - - jest.replaceProperty(childMock, 'length', 0); - - const spy = jest.spyOn(childMock, 'remove'); - - dummy.append(childMock); - - dummy.normalize(); - - expect(spy).toHaveBeenCalled(); - }); - - it('should not throw an error if there is no children', () => { - expect(() => dummy.normalize()).not.toThrow(); - }); - }); -}); diff --git a/packages/model/src/entities/inline-fragments/specs/TextInlineNode.spec.ts b/packages/model/src/entities/inline-fragments/specs/TextInlineNode.spec.ts deleted file mode 100644 index 57d08686..00000000 --- a/packages/model/src/entities/inline-fragments/specs/TextInlineNode.spec.ts +++ /dev/null @@ -1,315 +0,0 @@ -import { TextInlineNode } from '../TextInlineNode/index.js'; -import type { InlineToolName } from '@editorjs/model-types'; -import { FormattingInlineNode } from '../FormattingInlineNode/index.js'; -import type { ParentNode } from '../mixins/ParentNode/index.js'; -import type { InlineNode } from '../InlineNode/index.js'; - -jest.mock('../FormattingInlineNode'); - -describe('TextInlineNode', () => { - const initialText = 'initial text'; - const text = 'some text'; - const parentMock = { - insertAfter: jest.fn(), - removeChild: jest.fn(), - append: jest.fn(), - children: [], - } as unknown as ParentNode; - let node: TextInlineNode; - - beforeEach(() => { - node = new TextInlineNode({ - value: initialText, - parent: parentMock as FormattingInlineNode, - }); - }); - - it('should have empty value by default', () => { - node = new TextInlineNode(); - - expect(node.getText()).toEqual(''); - }); - - describe('.insertText()', () => { - it('should set text to value if node is empty', () => { - node = new TextInlineNode(); - - node.insertText(text); - - expect(node.getText()).toEqual(text); - }); - - it('should append text if not empty', () => { - node.insertText(text); - - expect(node.getText()).toEqual(initialText + text); - }); - - it('should prepend text if index is 0 and node is not empty', () => { - node.insertText(text, 0); - - expect(node.getText()).toEqual(text + initialText); - }); - - it('should insert text at index if not empty', () => { - const index = 5; - - node.insertText(text, index); - - expect(node.getText()).toEqual(initialText.slice(0, index) + text + initialText.slice(index)); - }); - - it('should throw an error if index is less than 0', () => { - const f = (): void => node.insertText(text, -1); - - expect(f).toThrow(); - }); - - it('should throw an error if index is greater than node length', () => { - const f = (): void => node.insertText(text, initialText.length + 1); - - expect(f).toThrow(); - }); - }); - - describe('.getText()', () => { - it('should return sliced value if start provided', () => { - const start = 5; - - expect(node.getText(start)).toEqual(initialText.slice(start)); - }); - - it('should return sliced value if end provided', () => { - const end = 6; - - expect(node.getText(0, end)).toEqual(initialText.slice(0, end)); - }); - - it('should return sliced value if full range provided', () => { - const start = 3; - const end = 9; - - expect(node.getText(start, end)).toEqual(initialText.slice(start, end)); - }); - - it('should throw an error if start is invalid index', () => { - expect(() => node.getText(-1)).toThrow(); - expect(() => node.getText(initialText.length + 1)).toThrow(); - }); - - it('should throw an error if end is invalid index', () => { - expect(() => node.getText(0, initialText.length + 1)).toThrow(); - }); - - it('should throw an error if end index is greater than start index', () => { - const start = 5; - const end = 3; - - expect(() => node.getText(start, end)).toThrow(); - }); - - it('should not throw an error if end index is equal to start index', () => { - const start = 5; - const end = 5; - - expect(() => node.getText(start, end)).not.toThrow(); - }); - }); - - describe('.removeText()', () => { - it('should remove all text by default', () => { - node.removeText(); - - expect(node.getText()).toEqual(''); - }); - - it('should remove text from specified index', () => { - const start = 3; - - node.removeText(start); - - expect(node.getText()).toEqual(initialText.slice(0, start)); - }); - - it('should remove text from 0 to specified end index', () => { - const end = 8; - - node.removeText(0, end); - - expect(node.getText()).toEqual(initialText.slice(end)); - }); - - it('should remove text from specified start and end indecies', () => { - const start = 3; - const end = 8; - - node.removeText(start, end); - - expect(node.getText()).toEqual(initialText.slice(0, start) + initialText.slice(end)); - }); - - it('should call remove() method if node is empty after removeText() call', () => { - jest.spyOn(node, 'remove'); - - node.removeText(); - - expect(node.remove).toHaveBeenCalled(); - }); - }); - - describe('.format()', () => { - const name = 'bold' as InlineToolName; - - it('should return just one FormattingInlineNode, if formatting full TextInlineNode', () => { - const fragments = node.format(name, 0, initialText.length); - - expect(fragments).toHaveLength(1); - expect(fragments[0]).toBeInstanceOf(FormattingInlineNode); - }); - - it('should return two fragments if formatting from the start, but not to the end', () => { - const end = 5; - - const fragments = node.format(name, 0, end); - - expect(fragments).toHaveLength(2); - expect(fragments[0]).toBeInstanceOf(FormattingInlineNode); - expect(fragments[1]).toBeInstanceOf(TextInlineNode); - }); - - it('should return two fragments if formatting to the end, but not from the start', () => { - const start = 5; - - const fragments = node.format(name, start, initialText.length); - - expect(fragments).toHaveLength(2); - expect(fragments[0]).toBeInstanceOf(TextInlineNode); - expect(fragments[1]).toBeInstanceOf(FormattingInlineNode); - }); - - it('should return three fragments if formatting in the middle', () => { - const start = 5; - const end = 8; - - const fragments = node.format(name, start, end); - - // eslint-disable-next-line @typescript-eslint/no-magic-numbers - expect(fragments).toHaveLength(3); - expect(fragments[0]).toBeInstanceOf(TextInlineNode); - expect(fragments[1]).toBeInstanceOf(FormattingInlineNode); - expect(fragments[2]).toBeInstanceOf(TextInlineNode); - }); - - it('should return FormattingInlineNode with a TextInlineNode as a child', () => { - const start = 5; - const end = 8; - - const fragments = node.format(name, start, end); - const formattingNode = fragments[1] as FormattingInlineNode; - - expect(formattingNode.children[0].getText()).toEqual(initialText.slice(start, end)); - }); - - it('should call parent\'s insertAfter with new nodes', () => { - const start = 5; - const end = 8; - - const fragments = node.format(name, start, end); - - expect(parentMock.insertAfter).toHaveBeenCalledWith(node, ...fragments); - }); - }); - - describe('.split()', () => { - const index = 5; - - it('should not split (return null) if index is 0', () => { - const newNode = node.split(0); - - expect(newNode).toBeNull(); - }); - - it('should not split (return null) if index equals text length', () => { - const newNode = node.split(initialText.length); - - expect(newNode).toBeNull(); - }); - - it('should create new TextInlineNode on split', () => { - const newNode = node.split(index); - - expect(newNode).toBeInstanceOf(TextInlineNode); - }); - - it('should create new TextInlineNode with text value splitted from the original one', () => { - const newNode = node.split(index); - - expect(newNode?.getText()).toEqual(initialText.slice(index)); - }); - - it('should remove split text value from the original node', () => { - node.split(index); - - expect(node.getText()).toEqual(initialText.slice(0, index)); - }); - - it('should insert new node to the parent', () => { - const newNode = node.split(index); - - expect(parentMock.insertAfter).toHaveBeenCalledWith(node, newNode); - }); - }); - - describe('.serialized', () => { - it('should return text value and empty array of fragments', () => { - const result = node.serialized; - - expect(result).toEqual({ - value: initialText, - fragments: [], - }); - }); - }); - - describe('.isEqual()', () => { - it('should return true for TextInlineNode', () => { - const nodeToCompare = new TextInlineNode(); - - expect(node.isEqual(nodeToCompare)).toEqual(true); - }); - - it('should return false for not TextInlineNode', () => { - const nodeToCompare = {} as InlineNode; - - expect(node.isEqual(nodeToCompare)).toEqual(false); - }); - }); - - describe('.mergeWith()', () => { - it('should concat nodes values', () => { - const nodeToMerge = new TextInlineNode({ - value: text, - }); - - node.mergeWith(nodeToMerge); - - expect(node.value).toEqual(initialText + text); - }); - - it('should remove merged node', () => { - const nodeToMerge = new TextInlineNode({ - value: text, - }); - - const spy = jest.spyOn(nodeToMerge, 'remove'); - - node.mergeWith(nodeToMerge); - - expect(spy).toHaveBeenCalled(); - }); - - it('should throw an error if node to merge is not TextInlineNode', () => { - expect(() => node.mergeWith({} as InlineNode)).toThrow(); - }); - }); -}); diff --git a/packages/model/src/entities/inline-fragments/specs/TextNode.spec.ts b/packages/model/src/entities/inline-fragments/specs/TextNode.spec.ts deleted file mode 100644 index 19731d28..00000000 --- a/packages/model/src/entities/inline-fragments/specs/TextNode.spec.ts +++ /dev/null @@ -1,83 +0,0 @@ -/* eslint-disable @typescript-eslint/no-magic-numbers */ -import { TextNode } from '../TextNode/index.js'; -import type { InlineToolData, InlineToolName } from '@editorjs/model-types'; - -jest.mock('../mixins/ChildNode'); -jest.mock('../mixins/ParentNode'); -jest.mock('../ParentInlineNode'); - -describe('TextNode', () => { - describe('initialization', () => { - afterEach(() => { - jest.clearAllMocks(); - }); - - it('should not call insertText() method if initial value is not passed', () => { - const spy = jest.spyOn(TextNode.prototype, 'insertText'); - - new TextNode(); - - expect(spy).not.toHaveBeenCalled(); - }); - - it('should call insertText() method if initial value is passed', () => { - const value = 'Editor.js is a block-styled editor'; - const spy = jest.spyOn(TextNode.prototype, 'insertText'); - - new TextNode({ value }); - - expect(spy).toHaveBeenCalledWith(value); - }); - - it('should not call format() method if initial fragments are not passed', () => { - const spy = jest.spyOn(TextNode.prototype, 'format'); - - new TextNode(); - - expect(spy).not.toHaveBeenCalled(); - }); - - it('should call format() method if initial fragments are passed', () => { - const value = 'Editor.js is a block-styled editor'; - const fragments = [ - { - tool: 'bold' as InlineToolName, - range: [0, 5] as [number, number], - data: {} as InlineToolData, - }, - ]; - const spy = jest.spyOn(TextNode.prototype, 'format'); - - new TextNode({ - value, - fragments, - }); - - expect(spy).toHaveBeenCalledWith(fragments[0].tool, ...fragments[0].range, fragments[0].data); - }); - - it('should call format() method for each passed fragment', () => { - const value = 'Editor.js is a block-styled editor'; - const fragments = [ - { - tool: 'bold' as InlineToolName, - range: [0, 5] as [number, number], - data: {} as InlineToolData, - }, - { - tool: 'italic' as InlineToolName, - range: [10, 14] as [number, number], - data: {} as InlineToolData, - }, - ]; - const spy = jest.spyOn(TextNode.prototype, 'format'); - - new TextNode({ - value, - fragments, - }); - - expect(spy).toHaveBeenCalledTimes(fragments.length); - }); - }); -}); diff --git a/packages/model/src/entities/inline-text/RunList/RunList.random.spec.ts b/packages/model/src/entities/inline-text/RunList/RunList.random.spec.ts new file mode 100644 index 00000000..960dc9d9 --- /dev/null +++ b/packages/model/src/entities/inline-text/RunList/RunList.random.spec.ts @@ -0,0 +1,54 @@ +import type { TextOperation } from '../specs/randomOperations.testing.js'; +import { createRandom, randomOperation, randomText, ReferenceText } from '../specs/randomOperations.testing.js'; +import { TextMark } from '../TextMark/index.js'; +import { RunList } from './index.js'; +import { expectRunInvariants } from './runInvariants.testing.js'; + +const SEQUENCES = 200; +const OPERATIONS_PER_SEQUENCE = 30; + +/** + * Applies the operation to the RunList + * @param list - RunList under test + * @param operation - operation to apply + */ +function apply(list: RunList, operation: TextOperation): void { + switch (operation.type) { + case 'insert': + list.insert(operation.text, operation.index); + break; + case 'remove': + list.remove(operation.start, operation.end); + break; + case 'format': + list.setMark(operation.start, operation.end, new TextMark(operation.tool, operation.data)); + break; + case 'unformat': + list.removeMark(operation.start, operation.end, operation.tool); + break; + } +} + +describe('RunList random operation sequences', () => { + for (let seed = 1; seed <= SEQUENCES; seed++) { + it(`should keep runs canonical and match the reference model (seed ${seed})`, () => { + const random = createRandom(seed); + const initialText = randomText(random); + const list = new RunList(); + const reference = new ReferenceText(initialText); + + list.insert(initialText, 0); + + for (let step = 0; step < OPERATIONS_PER_SEQUENCE; step++) { + const operation = randomOperation(random, reference.length); + + apply(list, operation); + reference.apply(operation); + + expectRunInvariants(list); + expect(list.getText()).toBe(reference.getText()); + expect(list.toFragments()).toEqual(reference.getFragments()); + } + }); + } +}); diff --git a/packages/model/src/entities/inline-text/RunList/RunList.spec.ts b/packages/model/src/entities/inline-text/RunList/RunList.spec.ts new file mode 100644 index 00000000..257f6a47 --- /dev/null +++ b/packages/model/src/entities/inline-text/RunList/RunList.spec.ts @@ -0,0 +1,372 @@ +/* eslint-disable @typescript-eslint/no-magic-numbers */ +import { createInlineToolData, createInlineToolName } from '@editorjs/model-types'; +import { TextMark } from '../TextMark/index.js'; +import { TextRun } from '../TextRun/index.js'; +import { RunList } from './index.js'; +import { expectRunInvariants } from './runInvariants.testing.js'; + +const bold = createInlineToolName('bold'); +const italic = createInlineToolName('italic'); +const link = createInlineToolName('link'); + +const boldMark = new TextMark(bold); +const italicMark = new TextMark(italic); + +/** + * Creates link mark with passed href + * @param href - link href + */ +function linkMark(href: string): TextMark { + return new TextMark(link, createInlineToolData({ href })); +} + +/** + * Lists created by the current test, checked for run invariants after each test + */ +let createdLists: RunList[] = []; + +/** + * Creates an empty run list and tracks it for the run invariants check + */ +function createEmptyList(): RunList { + const list = new RunList(); + + createdLists.push(list); + + return list; +} + +/** + * Creates a run list with the passed text and tracks it for the run invariants check + * @param text - initial text + */ +function createList(text: string): RunList { + const list = createEmptyList(); + + list.insert(text, 0); + + return list; +} + +describe('RunList', () => { + afterEach(() => { + createdLists.forEach(list => expectRunInvariants(list)); + createdLists = []; + }); + + describe('.insert()', () => { + it('should create a run without marks when inserting into an empty list', () => { + const list = createEmptyList(); + + list.insert('abc', 0); + + expect(list.runs).toEqual([new TextRun('abc')]); + expect(list.length).toBe(3); + expect(list.getText()).toBe('abc'); + }); + + it('should not create a run when inserting an empty string into an empty list', () => { + const list = createEmptyList(); + + list.insert('', 0); + + expect(list.runs).toEqual([]); + }); + + it('should insert into the run containing the previous character', () => { + const list = createList('abcd'); + + list.setMark(0, 2, boldMark); + list.insert('X', 2); + + expect(list.runs).toEqual([new TextRun('abX', [boldMark]), new TextRun('cd')]); + }); + + it('should insert into the first run at the zero offset', () => { + const list = createList('abcd'); + + list.setMark(0, 2, boldMark); + list.insert('X', 0); + + expect(list.runs).toEqual([new TextRun('Xab', [boldMark]), new TextRun('cd')]); + }); + + it('should insert into the middle of a later run', () => { + const list = createList('abcd'); + + list.setMark(0, 2, boldMark); + list.insert('X', 3); + + expect(list.runs).toEqual([new TextRun('ab', [boldMark]), new TextRun('cXd')]); + }); + }); + + describe('.remove()', () => { + it('should return removed text across runs', () => { + const list = createList('abcdef'); + + list.setMark(1, 3, boldMark); + + expect(list.remove(2, 5)).toBe('cde'); + expect(list.runs).toEqual([new TextRun('a'), new TextRun('b', [boldMark]), new TextRun('f')]); + }); + + it('should join runs with equal marks around the removed text', () => { + const list = createList('abcdef'); + + list.setMark(0, 2, boldMark); + list.setMark(2, 4, italicMark); + list.setMark(4, 6, boldMark); + list.remove(2, 4); + + expect(list.runs).toEqual([new TextRun('abef', [boldMark])]); + }); + + it('should leave no runs when all text is removed', () => { + const list = createList('abcd'); + + list.setMark(1, 3, boldMark); + + expect(list.remove(0, 4)).toBe('abcd'); + expect(list.runs).toEqual([]); + expect(list.length).toBe(0); + }); + + it('should not change runs for an empty range', () => { + const list = createList('abcd'); + + expect(list.remove(2, 2)).toBe(''); + expect(list.runs).toEqual([new TextRun('abcd')]); + }); + }); + + describe('.setMark()', () => { + it('should cut runs at the range edges', () => { + const list = createList('abcd'); + + list.setMark(1, 3, boldMark); + + expect(list.runs).toEqual([new TextRun('a'), new TextRun('bc', [boldMark]), new TextRun('d')]); + }); + + it('should not cut runs when the range edges are on run boundaries', () => { + const list = createList('abcd'); + + list.setMark(0, 2, boldMark); + list.setMark(0, 2, italicMark); + + expect(list.runs).toEqual([new TextRun('ab', [boldMark, italicMark]), new TextRun('cd')]); + }); + + it('should keep marks sorted by tool name', () => { + const list = createList('abcd'); + + list.setMark(0, 4, italicMark); + list.setMark(0, 4, boldMark); + + expect(list.runs).toEqual([new TextRun('abcd', [boldMark, italicMark])]); + }); + + it('should replace the mark of the same tool', () => { + const list = createList('abcd'); + + list.setMark(0, 4, linkMark('a')); + list.setMark(1, 3, linkMark('b')); + + expect(list.runs).toEqual([ + new TextRun('a', [linkMark('a')]), + new TextRun('bc', [linkMark('b')]), + new TextRun('d', [linkMark('a')]), + ]); + }); + + it('should keep a single run when the same mark is set again', () => { + const list = createList('abcd'); + + list.setMark(0, 4, linkMark('a')); + list.setMark(1, 3, linkMark('a')); + + expect(list.runs).toEqual([new TextRun('abcd', [linkMark('a')])]); + }); + + it('should join adjacent runs with equal data', () => { + const list = createList('abcd'); + + list.setMark(0, 2, linkMark('a')); + list.setMark(2, 4, linkMark('a')); + + expect(list.runs).toEqual([new TextRun('abcd', [linkMark('a')])]); + }); + + it('should keep adjacent runs with different data apart', () => { + const list = createList('abcd'); + + list.setMark(0, 2, linkMark('a')); + list.setMark(2, 4, linkMark('b')); + + expect(list.runs).toEqual([new TextRun('ab', [linkMark('a')]), new TextRun('cd', [linkMark('b')])]); + }); + + it('should not change runs for an empty range', () => { + const list = createList('abcd'); + + list.setMark(2, 2, boldMark); + + expect(list.runs).toEqual([new TextRun('abcd')]); + }); + }); + + describe('.removeMark()', () => { + it('should remove the mark only within the range', () => { + const list = createList('abcdef'); + + list.setMark(0, 6, boldMark); + list.removeMark(2, 4, bold); + + expect(list.runs).toEqual([new TextRun('ab', [boldMark]), new TextRun('cd'), new TextRun('ef', [boldMark])]); + }); + + it('should join runs that become equal', () => { + const list = createList('abcd'); + + list.setMark(0, 4, boldMark); + list.setMark(1, 3, italicMark); + list.removeMark(1, 3, italic); + + expect(list.runs).toEqual([new TextRun('abcd', [boldMark])]); + }); + + it('should keep marks of other tools', () => { + const list = createList('abcd'); + + list.setMark(0, 4, boldMark); + list.setMark(0, 4, italicMark); + list.removeMark(0, 4, bold); + + expect(list.runs).toEqual([new TextRun('abcd', [italicMark])]); + }); + }); + + describe('.getText()', () => { + it('should return the text of all runs', () => { + const list = createList('abcd'); + + list.setMark(1, 3, boldMark); + + expect(list.getText()).toBe('abcd'); + }); + }); + + describe('.runs', () => { + it('should not expose the internal array', () => { + const list = createList('abcd'); + + (list.runs as TextRun[]).push(new TextRun('x')); + + expect(list.runs).toEqual([new TextRun('abcd')]); + }); + }); + + describe('.toFragments()', () => { + it('should return no fragments for text without marks', () => { + expect(createList('abcd').toFragments()).toEqual([]); + }); + + it('should return a fragment spanning several runs while the mark continues', () => { + const list = createList('abcd'); + + list.setMark(0, 3, boldMark); + list.setMark(1, 4, italicMark); + + expect(list.toFragments()).toEqual([ + { + tool: bold, + range: [0, 3], + }, + { + tool: italic, + range: [1, 4], + }, + ]); + }); + + it('should close a fragment when the data of its tool changes', () => { + const list = createList('abcd'); + + list.setMark(0, 2, linkMark('a')); + list.setMark(2, 4, linkMark('b')); + + expect(list.toFragments()).toEqual([ + { + tool: link, + range: [0, 2], + data: createInlineToolData({ href: 'a' }), + }, + { + tool: link, + range: [2, 4], + data: createInlineToolData({ href: 'b' }), + }, + ]); + }); + + it('should open a new fragment when a mark comes back after a gap', () => { + const list = createList('abc'); + + list.setMark(0, 1, boldMark); + list.setMark(2, 3, boldMark); + + expect(list.toFragments()).toEqual([ + { + tool: bold, + range: [0, 1], + }, + { + tool: bold, + range: [2, 3], + }, + ]); + }); + + it('should not add a data key for marks without data', () => { + const list = createList('ab'); + + list.setMark(0, 2, boldMark); + + expect(Object.keys(list.toFragments()[0])).toEqual(['tool', 'range']); + }); + + it('should sort fragments by start, then by end descending, then by tool name', () => { + const list = createList('abc'); + + list.setMark(0, 2, italicMark); + list.setMark(1, 3, boldMark); + list.setMark(1, 2, linkMark('a')); + + expect(list.toFragments()).toEqual([ + { + tool: italic, + range: [0, 2], + }, + { + tool: bold, + range: [1, 3], + }, + { + tool: link, + range: [1, 2], + data: createInlineToolData({ href: 'a' }), + }, + ]); + }); + + it('should order fragments with equal ranges by tool name', () => { + const list = createList('ab'); + + list.setMark(0, 2, italicMark); + list.setMark(0, 2, boldMark); + + expect(list.toFragments().map(fragment => fragment.tool)).toEqual([bold, italic]); + }); + }); +}); diff --git a/packages/model/src/entities/inline-text/RunList/index.ts b/packages/model/src/entities/inline-text/RunList/index.ts new file mode 100644 index 00000000..591fd8dc --- /dev/null +++ b/packages/model/src/entities/inline-text/RunList/index.ts @@ -0,0 +1,296 @@ +import type { InlineFragment, InlineToolName } from '@editorjs/model-types'; +import { cloneInlineData } from '../../../utils/index.js'; +import type { TextMark } from '../TextMark/index.js'; +import { TextRun } from '../TextRun/index.js'; + +/** + * Fragment being built while sweeping the runs, with the mark it was opened for + */ +interface OpenFragment { + /** + * Mark the fragment was opened for + */ + mark: TextMark; + + /** + * Fragment with its end not set yet + */ + fragment: InlineFragment; +} + +/** + * Text with inline formatting stored as a list of runs. + * + * Keeps the runs canonical after every operation, so the same formatting always gives the same runs: + * - there are no empty runs + * - adjacent runs never have equal mark sets + * - a run has at most one mark per tool, and marks are sorted by tool name + * + * Offsets are expected to be valid: validation is up to the caller + */ +export class RunList { + /** + * Canonical runs + */ + #runs: TextRun[] = []; + + /** + * Text length, kept in sync by insert() and remove() + */ + #length = 0; + + /** + * Returns text length + */ + public get length(): number { + return this.#length; + } + + /** + * Returns a copy of the runs + */ + public get runs(): readonly TextRun[] { + return [...this.#runs]; + } + + /** + * Returns the whole text + */ + public getText(): string { + return this.#runs.map(run => run.text).join(''); + } + + /** + * Inserts text at the offset. Inserted text gets marks of the previous character, + * or of the first character when inserted at the zero offset + * @param text - text to insert + * @param offset - char offset to insert text at + */ + public insert(text: string, offset: number): void { + if (text.length === 0) { + return; + } + + this.#length += text.length; + + if (this.#runs.length === 0) { + this.#runs = [new TextRun(text)]; + + return; + } + + const [index, runStart] = this.#findRunForInsert(offset); + const run = this.#runs[index]; + const cut = offset - runStart; + + this.#runs[index] = new TextRun(run.text.slice(0, cut) + text + run.text.slice(cut), run.marks); + } + + /** + * Removes text in the range + * @param start - char start offset of the range + * @param end - char end offset of the range + * @returns removed text + */ + public remove(start: number, end: number): string { + const startIndex = this.#splitAt(start); + const endIndex = this.#splitAt(end); + const removedText = this.#runs + .splice(startIndex, endIndex - startIndex) + .map(run => run.text) + .join(''); + + this.#length -= removedText.length; + this.#runs = RunList.#merge(this.#runs); + + return removedText; + } + + /** + * Applies the mark to the range, replacing a mark of the same tool where there is one + * @param start - char start offset of the range + * @param end - char end offset of the range + * @param mark - mark to apply + */ + public setMark(start: number, end: number, mark: TextMark): void { + this.#updateMarks(start, end, marks => [...RunList.#withoutTool(marks, mark.tool), mark].sort((a, b) => RunList.#compareTools(a.tool, b.tool))); + } + + /** + * Removes the mark of the tool from the range + * @param start - char start offset of the range + * @param end - char end offset of the range + * @param tool - tool to remove the mark of + */ + public removeMark(start: number, end: number, tool: InlineToolName): void { + this.#updateMarks(start, end, marks => RunList.#withoutTool(marks, tool)); + } + + /** + * Returns maximal inline fragments: one fragment per stretch of characters with the same mark, + * sorted by start, then by end descending, then by tool name + */ + public toFragments(): InlineFragment[] { + const fragments: InlineFragment[] = []; + const open = new Map(); + let offset = 0; + + for (const run of this.#runs) { + for (const [tool, { mark, fragment }] of open) { + if (!run.marks.some(runMark => runMark.equals(mark))) { + fragment.range[1] = offset; + open.delete(tool); + } + } + + for (const mark of run.marks) { + if (open.has(mark.tool)) { + continue; + } + + const fragment: InlineFragment = { + tool: mark.tool, + range: [offset, offset], + }; + + if (mark.data !== undefined) { + fragment.data = cloneInlineData(mark.data); + } + + open.set(mark.tool, { + mark, + fragment, + }); + fragments.push(fragment); + } + + offset += run.text.length; + } + + for (const { fragment } of open.values()) { + fragment.range[1] = offset; + } + + return fragments.sort((a, b) => a.range[0] - b.range[0] || b.range[1] - a.range[1] || RunList.#compareTools(a.tool, b.tool)); + } + + /** + * Replaces marks of the runs in the range and restores canonical runs + * @param start - char start offset of the range + * @param end - char end offset of the range + * @param update - returns new marks for the passed ones + */ + #updateMarks(start: number, end: number, update: (marks: readonly TextMark[]) => readonly TextMark[]): void { + const startIndex = this.#splitAt(start); + const endIndex = this.#splitAt(end); + + for (let index = startIndex; index < endIndex; index++) { + const run = this.#runs[index]; + + this.#runs[index] = new TextRun(run.text, update(run.marks)); + } + + this.#runs = RunList.#merge(this.#runs); + } + + /** + * Makes sure there is a run boundary at the offset, cutting a run in two if needed + * @param offset - char offset + * @returns index of the run starting at the offset (number of runs for the offset at the end) + */ + #splitAt(offset: number): number { + let runStart = 0; + + for (const [index, run] of this.#runs.entries()) { + if (runStart === offset) { + return index; + } + + const runEnd = runStart + run.text.length; + + if (offset < runEnd) { + const cut = offset - runStart; + + this.#runs.splice(index, 1, new TextRun(run.text.slice(0, cut), run.marks), new TextRun(run.text.slice(cut), run.marks)); + + return index + 1; + } + + runStart = runEnd; + } + + return this.#runs.length; + } + + /** + * Returns the run text inserted at the offset goes to, with the offset of its start: + * the run containing the previous character, or the first run for the zero offset + * @param offset - char offset + */ + #findRunForInsert(offset: number): [index: number, runStart: number] { + let runStart = 0; + + const index = this.#runs.findIndex((run) => { + if (offset <= runStart + run.text.length) { + return true; + } + + runStart += run.text.length; + + return false; + }); + + return [index, runStart]; + } + + /** + * Returns canonical runs: neighbours with equal mark sets are joined. + * Runs are never empty here: splitting only cuts inside a run, and empty text is never inserted + * @param runs - runs to merge + */ + static #merge(runs: TextRun[]): TextRun[] { + const result: TextRun[] = []; + + for (const run of runs) { + const previous = result[result.length - 1]; + + if (previous !== undefined && RunList.#isSameMarkSet(previous.marks, run.marks)) { + result[result.length - 1] = new TextRun(previous.text + run.text, previous.marks); + + continue; + } + + result.push(run); + } + + return result; + } + + /** + * Checks if two sorted mark sets are equal + * @param a - first mark set + * @param b - second mark set + */ + static #isSameMarkSet(a: readonly TextMark[], b: readonly TextMark[]): boolean { + return a.length === b.length && a.every((mark, index) => mark.equals(b[index])); + } + + /** + * Returns marks without the mark of the tool + * @param marks - sorted marks + * @param tool - tool to remove the mark of + */ + static #withoutTool(marks: readonly TextMark[], tool: InlineToolName): TextMark[] { + return marks.filter(mark => mark.tool !== tool); + } + + /** + * Compares tool names by code units so the order is the same in every environment. + * Never called with equal names: a run has one mark per tool, and fragments of one tool never share a range + * @param a - first tool name + * @param b - second tool name + */ + static #compareTools(a: InlineToolName, b: InlineToolName): number { + return a < b ? -1 : 1; + } +} diff --git a/packages/model/src/entities/inline-text/RunList/runInvariants.testing.ts b/packages/model/src/entities/inline-text/RunList/runInvariants.testing.ts new file mode 100644 index 00000000..8e9a44de --- /dev/null +++ b/packages/model/src/entities/inline-text/RunList/runInvariants.testing.ts @@ -0,0 +1,26 @@ +import type { RunList } from './index.js'; + +/** + * Asserts the canonical run invariants of the RunList: + * no empty runs, no neighbours with equal mark sets, at most one mark per tool, marks sorted by tool name + * @param list - RunList to check + */ +export function expectRunInvariants(list: RunList): void { + const runs = list.runs; + + runs.forEach((run, index) => { + expect(run.text).not.toBe(''); + + const tools = run.marks.map(mark => mark.tool); + + expect(new Set(tools).size).toBe(tools.length); + expect([...tools].sort()).toEqual(tools); + + if (index > 0) { + const previous = runs[index - 1].marks; + const isSameMarkSet = previous.length === run.marks.length && previous.every((mark, markIndex) => mark.equals(run.marks[markIndex])); + + expect(isSameMarkSet).toBe(false); + } + }); +} diff --git a/packages/model/src/entities/inline-text/TextMark/TextMark.spec.ts b/packages/model/src/entities/inline-text/TextMark/TextMark.spec.ts new file mode 100644 index 00000000..d1cf2d7c --- /dev/null +++ b/packages/model/src/entities/inline-text/TextMark/TextMark.spec.ts @@ -0,0 +1,51 @@ +import { createInlineToolData, createInlineToolName } from '@editorjs/model-types'; +import { TextMark } from './index.js'; + +describe('TextMark', () => { + const link = createInlineToolName('link'); + + it('should store the tool and data', () => { + const data = createInlineToolData({ href: 'a' }); + const mark = new TextMark(link, data); + + expect(mark.tool).toBe(link); + expect(mark.data).toStrictEqual(data); + }); + + it('should keep its own copy of the data', () => { + const data = { href: 'a' }; + const mark = new TextMark(link, createInlineToolData(data)); + + data.href = 'b'; + + expect(mark.data).toStrictEqual(createInlineToolData({ href: 'a' })); + }); + + it('should store empty data as no data', () => { + expect(new TextMark(link, createInlineToolData({})).data).toBeUndefined(); + }); + + it('should store missing data as no data', () => { + expect(new TextMark(link).data).toBeUndefined(); + }); + + describe('.equals()', () => { + it('should return true for the same tool and equal data', () => { + expect(new TextMark(link, createInlineToolData({ href: 'a' })).equals(new TextMark(link, createInlineToolData({ href: 'a' })))).toBe(true); + }); + + it('should return true for the same tool without data', () => { + const bold = createInlineToolName('bold'); + + expect(new TextMark(bold).equals(new TextMark(bold))).toBe(true); + }); + + it('should return false for different tools', () => { + expect(new TextMark(createInlineToolName('bold')).equals(new TextMark(createInlineToolName('italic')))).toBe(false); + }); + + it('should return false for the same tool with different data', () => { + expect(new TextMark(link, createInlineToolData({ href: 'a' })).equals(new TextMark(link, createInlineToolData({ href: 'b' })))).toBe(false); + }); + }); +}); diff --git a/packages/model/src/entities/inline-text/TextMark/index.ts b/packages/model/src/entities/inline-text/TextMark/index.ts new file mode 100644 index 00000000..9fbfeea4 --- /dev/null +++ b/packages/model/src/entities/inline-text/TextMark/index.ts @@ -0,0 +1,47 @@ +import type { InlineToolData, InlineToolName } from '@editorjs/model-types'; +import { cloneInlineData, isSameInlineData } from '../../../utils/index.js'; + +/** + * Inline tool with its data applied to a piece of text. + * + * Immutable, so the same instance can be shared between runs. The mark keeps its own copy of the data, + * so changes to the object passed in don't reach the model. Empty data is stored as no data, + * since the two are equal and the stored form must not depend on which one was passed + */ +export class TextMark { + /** + * Name of the inline tool + */ + public readonly tool: InlineToolName; + + /** + * Inline tool data if applicable + */ + public readonly data?: InlineToolData; + + /** + * TextMark constructor + * @param tool - name of the inline tool + * @param [data] - inline tool data if applicable + */ + constructor(tool: InlineToolName, data?: InlineToolData) { + this.tool = tool; + this.data = data === undefined || TextMark.#isEmpty(data) ? undefined : cloneInlineData(data); + } + + /** + * Checks if the passed mark is equal to this one: same tool and equal data + * @param mark - mark to compare with + */ + public equals(mark: TextMark): boolean { + return this.tool === mark.tool && isSameInlineData(this.data, mark.data); + } + + /** + * Checks if the data is an empty object + * @param data - inline tool data + */ + static #isEmpty(data: InlineToolData): boolean { + return Object.keys(data).length === 0; + } +} diff --git a/packages/model/src/entities/inline-text/TextNode/TextNode.integration.spec.ts b/packages/model/src/entities/inline-text/TextNode/TextNode.integration.spec.ts new file mode 100644 index 00000000..33c208a4 --- /dev/null +++ b/packages/model/src/entities/inline-text/TextNode/TextNode.integration.spec.ts @@ -0,0 +1,636 @@ +/* eslint-disable @typescript-eslint/no-magic-numbers */ +import type { InlineFragment, InlineToolData, InlineToolName } from '@editorjs/model-types'; +import { + createInlineToolData, + createInlineToolName, + EventAction, + EventType, + TextAddedEvent, + TextFormattedEvent, + TextRemovedEvent, + TextUnformattedEvent +} from '@editorjs/model-types'; +import { TextNode } from './index.js'; + +const bold = createInlineToolName('bold'); +const italic = createInlineToolName('italic'); +const link = createInlineToolName('link'); + +/** + * Creates an inline fragment + * @param tool - inline tool name + * @param start - range start + * @param end - range end + * @param [data] - inline tool data + */ +function fragment(tool: InlineToolName, start: number, end: number, data?: InlineToolData): InlineFragment { + const result: InlineFragment = { + tool, + range: [start, end], + }; + + if (data !== undefined) { + result.data = data; + } + + return result; +} + +/** + * Creates link data with passed href + * @param value - link href + */ +function href(value: string): InlineToolData { + return createInlineToolData({ href: value }); +} + +describe('TextNode', () => { + describe('canonical formatting state', () => { + it('should return the same fragments when equal formatting is applied in a different order', () => { + const first = new TextNode({ value: 'abcd' }); + const second = new TextNode({ value: 'abcd' }); + + first.format(bold, 0, 2); + first.format(italic, 0, 4); + first.format(bold, 2, 4); + + second.format(bold, 0, 4); + second.format(italic, 0, 4); + + expect(first.getFragments()).toEqual([fragment(bold, 0, 4), fragment(italic, 0, 4)]); + expect(second.getFragments()).toEqual(first.getFragments()); + }); + + it('should merge fragments split by other formatting', () => { + const node = new TextNode({ value: 'abcdef' }); + + node.format(bold, 0, 3); + node.format(italic, 1, 3); + node.format(italic, 3, 6); + node.format(bold, 3, 5); + + expect(node.getFragments()).toEqual([fragment(bold, 0, 5), fragment(italic, 1, 6)]); + }); + + it('should return a single fragment when a tool is applied over a shorter fragment of another tool', () => { + const node = new TextNode({ value: 'abcd' }); + + node.format(italic, 1, 3); + node.format(bold, 0, 4); + + expect(node.getFragments()).toEqual([fragment(bold, 0, 4), fragment(italic, 1, 3)]); + }); + + it('should return the same fragments when constructed with fragments in a different order', () => { + const fragments = [fragment(bold, 0, 3), fragment(italic, 1, 5)]; + + const first = new TextNode({ + value: 'abcdef', + fragments, + }); + const second = new TextNode({ + value: 'abcdef', + fragments: [...fragments].reverse(), + }); + + expect(first.getFragments()).toEqual(fragments); + expect(second.getFragments()).toEqual(fragments); + }); + + it('should restore the previous state when formatting is applied and removed', () => { + const node = new TextNode({ value: 'abcd' }); + + node.format(bold, 0, 4); + node.format(italic, 1, 3); + node.unformat(italic, 1, 3); + + expect(node.getFragments()).toEqual([fragment(bold, 0, 4)]); + }); + }); + + describe('fragment order', () => { + it('should return a containing fragment before the contained one', () => { + const node = new TextNode({ value: 'abcd' }); + + node.format(italic, 1, 3); + node.format(bold, 0, 4); + + expect(node.getFragments()).toEqual([fragment(bold, 0, 4), fragment(italic, 1, 3)]); + }); + + it('should order fragments with equal ranges by tool name', () => { + const node = new TextNode({ value: 'abcd' }); + + node.format(italic, 0, 4); + node.format(bold, 0, 4); + + expect(node.getFragments()).toEqual([fragment(bold, 0, 4), fragment(italic, 0, 4)]); + }); + + it('should order fragments by start', () => { + const node = new TextNode({ value: 'abcdef' }); + + node.format(italic, 4, 6); + node.format(bold, 0, 2); + + expect(node.getFragments()).toEqual([fragment(bold, 0, 2), fragment(italic, 4, 6)]); + }); + }); + + describe('maximal fragments', () => { + it('should merge adjacent formatting with equal data', () => { + const node = new TextNode({ value: 'abcd' }); + + node.format(link, 0, 2, href('a')); + node.format(link, 2, 4, href('a')); + + expect(node.getFragments()).toEqual([fragment(link, 0, 4, href('a'))]); + }); + + it('should keep adjacent formatting with different data separate', () => { + const node = new TextNode({ value: 'abcd' }); + + node.format(link, 0, 2, href('a')); + node.format(link, 2, 4, href('b')); + + expect(node.getFragments()).toEqual([fragment(link, 0, 2, href('a')), fragment(link, 2, 4, href('b'))]); + }); + + it('should join equal fragments when the text between them is removed', () => { + const node = new TextNode({ value: 'abcdef' }); + + node.format(bold, 0, 2); + node.format(italic, 2, 4); + node.format(bold, 4, 6); + node.removeText(2, 4); + + expect(node.getFragments()).toEqual([fragment(bold, 0, 4)]); + }); + }); + + describe('re-applying an inline tool', () => { + it('should replace data only within the re-applied range', () => { + const node = new TextNode({ value: 'abcd' }); + + node.format(link, 0, 4, href('a')); + node.format(link, 1, 3, href('b')); + + expect(node.getFragments()).toEqual([ + fragment(link, 0, 1, href('a')), + fragment(link, 1, 3, href('b')), + fragment(link, 3, 4, href('a')), + ]); + }); + + it('should leave formatting unchanged when re-applied with identical data', () => { + const node = new TextNode({ value: 'abcd' }); + + node.format(link, 0, 4, href('a')); + node.format(link, 1, 3, href('a')); + + expect(node.getFragments()).toEqual([fragment(link, 0, 4, href('a'))]); + }); + + it('should dispatch TextFormattedEvent when re-applied with identical data', () => { + const node = new TextNode({ value: 'abcd' }); + let event: TextFormattedEvent | null = null; + + node.format(link, 0, 4, href('a')); + node.addEventListener(EventType.Changed, e => event = e as TextFormattedEvent); + node.format(link, 1, 3, href('a')); + + expect(event).toBeInstanceOf(TextFormattedEvent); + }); + }); + + describe('fragments in a range', () => { + it('should return a partially covered fragment whole', () => { + const node = new TextNode({ value: 'abcdef' }); + + node.format(bold, 1, 5); + + expect(node.getFragments(0, 2)).toEqual([fragment(bold, 1, 5)]); + }); + + it('should not return fragments touching the range boundaries', () => { + const node = new TextNode({ value: 'abcdef' }); + + node.format(bold, 0, 2); + node.format(italic, 4, 6); + + expect(node.getFragments(2, 4)).toEqual([]); + }); + + it('should return no fragments for an empty range', () => { + const node = new TextNode({ value: 'abcd' }); + + node.format(bold, 0, 4); + + expect(node.getFragments(1, 1)).toEqual([]); + }); + + it('should filter fragments by tool', () => { + const node = new TextNode({ value: 'abcd' }); + + node.format(bold, 0, 4); + node.format(italic, 1, 3); + + expect(node.getFragments(0, 4, italic)).toEqual([fragment(italic, 1, 3)]); + }); + + it('should return the whole merged fragment for a range covering one of its parts', () => { + const node = new TextNode({ value: 'abcd' }); + + node.format(bold, 0, 2); + node.format(italic, 0, 4); + node.format(bold, 2, 4); + + expect(node.getFragments(3, 4, bold)).toEqual([fragment(bold, 0, 4)]); + }); + + it('should not expose internal state through returned fragments', () => { + const node = new TextNode({ value: 'abcd' }); + + node.format(bold, 0, 2); + node.getFragments()[0].range[1] = 4; + + expect(node.getFragments()).toEqual([fragment(bold, 0, 2)]); + }); + }); + + describe('inserted text formatting', () => { + it('should extend formatting when text is inserted at the end of a formatted stretch', () => { + const node = new TextNode({ value: 'abcd' }); + + node.format(bold, 0, 2); + node.insertText('X', 2); + + expect(node.getText()).toBe('abXcd'); + expect(node.getFragments()).toEqual([fragment(bold, 0, 3)]); + }); + + it('should take formatting of the first character when text is inserted at the start', () => { + const node = new TextNode({ value: 'abcd' }); + + node.format(bold, 0, 2); + node.insertText('X', 0); + + expect(node.getText()).toBe('Xabcd'); + expect(node.getFragments()).toEqual([fragment(bold, 0, 3)]); + }); + + it('should not format text inserted after unformatted text', () => { + const node = new TextNode({ value: 'abcd' }); + + node.format(bold, 2, 4); + node.insertText('X', 2); + + expect(node.getFragments()).toEqual([fragment(bold, 3, 5)]); + }); + + it('should append text to the end by default', () => { + const node = new TextNode({ value: 'abcd' }); + + node.format(bold, 2, 4); + node.insertText('X'); + + expect(node.getText()).toBe('abcdX'); + expect(node.getFragments()).toEqual([fragment(bold, 2, 5)]); + }); + + it('should not format text inserted into empty text', () => { + const node = new TextNode(); + + node.insertText('abc'); + + expect(node.getText()).toBe('abc'); + expect(node.length).toBe(3); + expect(node.getFragments()).toEqual([]); + }); + }); + + describe('text removal', () => { + it('should return removed text and shrink formatting around it', () => { + const node = new TextNode({ value: 'abcdef' }); + + node.format(bold, 1, 5); + + expect(node.removeText(2, 4)).toBe('cd'); + expect(node.getText()).toBe('abef'); + expect(node.getFragments()).toEqual([fragment(bold, 1, 3)]); + }); + + it('should drop a fragment when all of its text is removed', () => { + const node = new TextNode({ value: 'abcd' }); + + node.format(bold, 1, 3); + node.removeText(1, 3); + + expect(node.getText()).toBe('ad'); + expect(node.getFragments()).toEqual([]); + }); + + it('should remove all text by default', () => { + const node = new TextNode({ value: 'abcd' }); + + node.format(bold, 1, 3); + + expect(node.removeText()).toBe('abcd'); + expect(node.length).toBe(0); + expect(node.getFragments()).toEqual([]); + }); + + it('should allow inserting text after all text was removed', () => { + const node = new TextNode({ value: 'abcd' }); + + node.format(bold, 0, 4); + node.removeText(); + node.insertText('xy'); + + expect(node.getText()).toBe('xy'); + expect(node.getFragments()).toEqual([]); + }); + }); + + describe('unformatting', () => { + it('should remove formatting only within the range', () => { + const node = new TextNode({ value: 'abcdef' }); + + node.format(bold, 0, 6); + node.unformat(bold, 2, 4); + + expect(node.getFragments()).toEqual([fragment(bold, 0, 2), fragment(bold, 4, 6)]); + }); + + it('should remove formatting when the range is wider than the fragment', () => { + const node = new TextNode({ value: 'abcd' }); + + node.format(bold, 1, 2); + node.unformat(bold, 0, 4); + + expect(node.getFragments()).toEqual([]); + }); + + it('should not touch formatting of other tools', () => { + const node = new TextNode({ value: 'abcd' }); + + node.format(bold, 0, 4); + node.format(italic, 0, 4); + node.unformat(bold, 0, 4); + + expect(node.getFragments()).toEqual([fragment(italic, 0, 4)]); + }); + }); + + describe('zero-length ranges', () => { + it('should not add formatting for an empty range', () => { + const node = new TextNode({ value: 'abcd' }); + + node.format(bold, 2, 2); + + expect(node.getFragments()).toEqual([]); + }); + + it('should not remove text for an empty range', () => { + const node = new TextNode({ value: 'abcd' }); + + expect(node.removeText(2, 2)).toBe(''); + expect(node.getText()).toBe('abcd'); + }); + }); + + describe('text reading', () => { + it('should return text from the range across formatting', () => { + const node = new TextNode({ value: 'abcdef' }); + + node.format(bold, 1, 3); + node.format(italic, 2, 5); + + expect(node.getText(1, 5)).toBe('bcde'); + }); + }); + + describe('validation', () => { + it('should throw when an index is out of range', () => { + const node = new TextNode({ value: 'abc' }); + + expect(() => node.removeText(0, 5)).toThrow('Index 5 is not in valid range [0, 3]'); + expect(node.getText()).toBe('abc'); + }); + + it('should throw when a negative index is passed', () => { + const node = new TextNode({ value: 'abc' }); + + expect(() => node.insertText('X', -1)).toThrow('Index -1 is not in valid range [0, 3]'); + }); + + it('should throw when the range end is lower than its start', () => { + const node = new TextNode({ value: 'abcd' }); + + expect(() => node.format(bold, 3, 1)).toThrow('The end of range must be greater or equal than the start: [3, 1]'); + }); + }); + + describe('events', () => { + it('should dispatch TextAddedEvent with the inserted text and range', () => { + const node = new TextNode({ value: 'abcd' }); + let event: TextAddedEvent | null = null; + + node.addEventListener(EventType.Changed, e => event = e as TextAddedEvent); + node.insertText('X', 2); + + expect(event).toBeInstanceOf(TextAddedEvent); + expect(event).toHaveProperty('detail', expect.objectContaining({ + action: EventAction.Added, + index: expect.objectContaining({ textRange: [2, 2] }), + data: 'X', + })); + }); + + it('should dispatch TextRemovedEvent with the removed text and range', () => { + const node = new TextNode({ value: 'abcd' }); + let event: TextRemovedEvent | null = null; + + node.addEventListener(EventType.Changed, e => event = e as TextRemovedEvent); + node.removeText(1, 3); + + expect(event).toBeInstanceOf(TextRemovedEvent); + expect(event).toHaveProperty('detail', expect.objectContaining({ + action: EventAction.Removed, + index: expect.objectContaining({ textRange: [1, 3] }), + data: 'bc', + })); + }); + + it('should dispatch TextFormattedEvent with the tool, data and range', () => { + const node = new TextNode({ value: 'abcd' }); + let event: TextFormattedEvent | null = null; + + node.addEventListener(EventType.Changed, e => event = e as TextFormattedEvent); + node.format(link, 1, 3, href('a')); + + expect(event).toBeInstanceOf(TextFormattedEvent); + expect(event).toHaveProperty('detail', expect.objectContaining({ + action: EventAction.Modified, + index: expect.objectContaining({ textRange: [1, 3] }), + data: { + tool: link, + data: href('a'), + }, + })); + }); + + it('should dispatch TextUnformattedEvent with the tool and range', () => { + const node = new TextNode({ value: 'abcd' }); + let event: TextUnformattedEvent | null = null; + + node.format(bold, 0, 4); + node.addEventListener(EventType.Changed, e => event = e as TextUnformattedEvent); + node.unformat(bold, 1, 3); + + expect(event).toBeInstanceOf(TextUnformattedEvent); + expect(event).toHaveProperty('detail', expect.objectContaining({ + action: EventAction.Modified, + index: expect.objectContaining({ textRange: [1, 3] }), + data: { tool: bold }, + })); + }); + }); + + describe('empty data', () => { + const empty = createInlineToolData({}); + + it('should return a fragment without data when a tool is applied with empty data', () => { + const node = new TextNode({ value: 'abcd' }); + + node.format(bold, 0, 4, empty); + + expect(node.getFragments()).toStrictEqual([fragment(bold, 0, 4)]); + }); + + it('should return the same fragments whichever part was formatted with empty data', () => { + const first = new TextNode({ value: 'abcd' }); + const second = new TextNode({ value: 'abcd' }); + + first.format(bold, 0, 2, empty); + first.format(bold, 2, 4); + + second.format(bold, 0, 2); + second.format(bold, 2, 4, empty); + + expect(first.getFragments()).toStrictEqual([fragment(bold, 0, 4)]); + expect(second.getFragments()).toStrictEqual(first.getFragments()); + }); + + it('should leave formatting unchanged when a tool with empty data is re-applied without data', () => { + const node = new TextNode({ value: 'abcd' }); + + node.format(bold, 0, 4, empty); + node.format(bold, 1, 3); + + expect(node.getFragments()).toStrictEqual([fragment(bold, 0, 4)]); + }); + }); + + describe('data ownership', () => { + it('should not change formatting when the data passed to format() is mutated later', () => { + const node = new TextNode({ value: 'abcd' }); + const data = { href: 'a' }; + + node.format(link, 0, 4, createInlineToolData(data)); + data.href = 'b'; + + expect(node.getFragments()).toEqual([fragment(link, 0, 4, href('a'))]); + }); + + it('should not change the dispatched event when the data passed to format() is mutated later', () => { + const node = new TextNode({ value: 'abcd' }); + const data = { href: 'a' }; + let event: TextFormattedEvent | null = null; + + node.addEventListener(EventType.Changed, e => event = e as TextFormattedEvent); + node.format(link, 0, 4, createInlineToolData(data)); + data.href = 'b'; + + expect(event).toHaveProperty('detail', expect.objectContaining({ + data: { + tool: link, + data: href('a'), + }, + })); + }); + + it('should keep empty data in the dispatched event', () => { + const node = new TextNode({ value: 'abcd' }); + let event: TextFormattedEvent | null = null; + + node.addEventListener(EventType.Changed, e => event = e as TextFormattedEvent); + node.format(bold, 0, 4, createInlineToolData({})); + + expect(event).toHaveProperty('detail', expect.objectContaining({ + data: { + tool: bold, + data: createInlineToolData({}), + }, + })); + }); + + it('should not change formatting when data of a returned fragment is mutated', () => { + const node = new TextNode({ value: 'abcd' }); + + node.format(link, 0, 4, href('a')); + (node.getFragments()[0].data as unknown as { href: string }).href = 'b'; + + expect(node.getFragments()).toEqual([fragment(link, 0, 4, href('a'))]); + }); + }); + + describe('loading conflicting fragments', () => { + it('should resolve overlapping fragments of the same tool the same way whatever their order', () => { + const fragments = [fragment(link, 0, 4, href('a')), fragment(link, 2, 6, href('b'))]; + + const first = new TextNode({ + value: 'abcdef', + fragments, + }); + const second = new TextNode({ + value: 'abcdef', + fragments: [...fragments].reverse(), + }); + + expect(first.getFragments()).toEqual([fragment(link, 0, 2, href('a')), fragment(link, 2, 6, href('b'))]); + expect(second.getFragments()).toEqual(first.getFragments()); + }); + + it('should resolve fragments of the same tool with equal ranges the same way whatever their order', () => { + const fragments = [fragment(link, 0, 4, href('b')), fragment(link, 0, 4, href('a'))]; + + const first = new TextNode({ + value: 'abcd', + fragments, + }); + const second = new TextNode({ + value: 'abcd', + fragments: [...fragments].reverse(), + }); + + expect(first.getFragments()).toEqual([fragment(link, 0, 4, href('b'))]); + expect(second.getFragments()).toEqual(first.getFragments()); + }); + }); + + describe('.serialized', () => { + it('should return text value and merged fragments', () => { + const node = new TextNode({ value: 'abcd' }); + + node.format(bold, 0, 2); + node.format(italic, 0, 4); + node.format(bold, 2, 4); + + expect(node.serialized).toEqual(expect.objectContaining({ + value: 'abcd', + fragments: [fragment(bold, 0, 4), fragment(italic, 0, 4)], + })); + }); + }); +}); diff --git a/packages/model/src/entities/inline-text/TextNode/TextNode.random.spec.ts b/packages/model/src/entities/inline-text/TextNode/TextNode.random.spec.ts new file mode 100644 index 00000000..0d77c84d --- /dev/null +++ b/packages/model/src/entities/inline-text/TextNode/TextNode.random.spec.ts @@ -0,0 +1,95 @@ +import type { TextOperation } from '../specs/randomOperations.testing.js'; +import { compareForLoading, createRandom, randomFragments, randomOperation, randomText, ReferenceText, shuffle } from '../specs/randomOperations.testing.js'; +import { TextNode } from './index.js'; + +const SEQUENCES = 200; +const OPERATIONS_PER_SEQUENCE = 30; + +/** + * Applies the operation to the TextNode + * @param node - TextNode under test + * @param operation - operation to apply + */ +function apply(node: TextNode, operation: TextOperation): void { + switch (operation.type) { + case 'insert': + node.insertText(operation.text, operation.index); + break; + case 'remove': + node.removeText(operation.start, operation.end); + break; + case 'format': + node.format(operation.tool, operation.start, operation.end, operation.data); + break; + case 'unformat': + node.unformat(operation.tool, operation.start, operation.end); + break; + } +} + +describe('TextNode random operation sequences', () => { + for (let seed = 1; seed <= SEQUENCES; seed++) { + it(`should match the per-character reference model (seed ${seed})`, () => { + const random = createRandom(seed); + const initialText = randomText(random); + const node = new TextNode({ value: initialText }); + const reference = new ReferenceText(initialText); + + for (let step = 0; step < OPERATIONS_PER_SEQUENCE; step++) { + const operation = randomOperation(random, reference.length); + + apply(node, operation); + reference.apply(operation); + + expect(node.getText()).toBe(reference.getText()); + expect(node.getFragments()).toEqual(reference.getFragments()); + } + + const { value, fragments } = node.serialized; + const reloaded = new TextNode({ + value, + fragments, + }); + const shuffled = new TextNode({ + value, + fragments: shuffle(random, fragments), + }); + + expect(reloaded.getFragments()).toEqual(fragments); + expect(shuffled.getFragments()).toEqual(fragments); + }); + } +}); + +describe('TextNode loading random fragments', () => { + for (let seed = 1; seed <= SEQUENCES; seed++) { + it(`should give the same result for any fragment order and match the reference model (seed ${seed})`, () => { + const random = createRandom(seed); + const value = randomText(random) || 'a'; + const fragments = randomFragments(random, value.length); + const reference = new ReferenceText(value); + + [...fragments].sort(compareForLoading).forEach((fragment) => { + reference.apply({ + type: 'format', + tool: fragment.tool, + start: fragment.range[0], + end: fragment.range[1], + data: fragment.data, + }); + }); + + const node = new TextNode({ + value, + fragments, + }); + const shuffled = new TextNode({ + value, + fragments: shuffle(random, fragments), + }); + + expect(node.getFragments()).toStrictEqual(reference.getFragments()); + expect(shuffled.getFragments()).toStrictEqual(node.getFragments()); + }); + } +}); diff --git a/packages/model/src/entities/inline-text/TextNode/TextNode.spec.ts b/packages/model/src/entities/inline-text/TextNode/TextNode.spec.ts new file mode 100644 index 00000000..a96b1cd9 --- /dev/null +++ b/packages/model/src/entities/inline-text/TextNode/TextNode.spec.ts @@ -0,0 +1,96 @@ +/* eslint-disable @typescript-eslint/no-magic-numbers */ +import { BlockChildType, createInlineToolData, createInlineToolName, NODE_TYPE_HIDDEN_PROP } from '@editorjs/model-types'; +import { TextNode } from './index.js'; + +describe('TextNode', () => { + afterEach(() => { + jest.restoreAllMocks(); + }); + + describe('constructor', () => { + it('should not insert text if initial value is not passed', () => { + const spy = jest.spyOn(TextNode.prototype, 'insertText'); + + new TextNode(); + + expect(spy).not.toHaveBeenCalled(); + }); + + it('should insert initial value', () => { + const value = 'Editor.js is a block-styled editor'; + const spy = jest.spyOn(TextNode.prototype, 'insertText'); + + const node = new TextNode({ value }); + + expect(spy).toHaveBeenCalledWith(value); + expect(node.getText()).toBe(value); + }); + + it('should not apply fragments if initial value is not passed', () => { + const spy = jest.spyOn(TextNode.prototype, 'format'); + + new TextNode({ + fragments: [ + { + tool: createInlineToolName('bold'), + range: [0, 5], + }, + ], + }); + + expect(spy).not.toHaveBeenCalled(); + }); + + it('should apply each initial fragment', () => { + const bold = createInlineToolName('bold'); + const link = createInlineToolName('link'); + const data = createInlineToolData({ href: 'https://editorjs.io' }); + const spy = jest.spyOn(TextNode.prototype, 'format'); + + new TextNode({ + value: 'Editor.js is a block-styled editor', + fragments: [ + { + tool: bold, + range: [0, 5], + }, + { + tool: link, + range: [10, 14], + data, + }, + ], + }); + + expect(spy).toHaveBeenCalledTimes(2); + expect(spy).toHaveBeenCalledWith(bold, 0, 5, undefined); + expect(spy).toHaveBeenCalledWith(link, 10, 14, data); + }); + }); + + describe('.length', () => { + it('should return 0 for empty text', () => { + expect(new TextNode().length).toBe(0); + }); + + it('should return the text length across formatting', () => { + const node = new TextNode({ value: 'abcdef' }); + + node.format(createInlineToolName('bold'), 1, 3); + + expect(node.length).toBe(6); + }); + }); + + describe('.serialized', () => { + it('should mark the output with BlockChildType.Text', () => { + const node = new TextNode({ value: 'hello' }); + + expect(node.serialized).toStrictEqual({ + [NODE_TYPE_HIDDEN_PROP]: BlockChildType.Text, + value: 'hello', + fragments: [], + }); + }); + }); +}); diff --git a/packages/model/src/entities/inline-fragments/TextNode/__mocks__/index.ts b/packages/model/src/entities/inline-text/TextNode/__mocks__/index.ts similarity index 100% rename from packages/model/src/entities/inline-fragments/TextNode/__mocks__/index.ts rename to packages/model/src/entities/inline-text/TextNode/__mocks__/index.ts diff --git a/packages/model/src/entities/inline-text/TextNode/index.ts b/packages/model/src/entities/inline-text/TextNode/index.ts new file mode 100644 index 00000000..4a9b5eeb --- /dev/null +++ b/packages/model/src/entities/inline-text/TextNode/index.ts @@ -0,0 +1,243 @@ +import type { InlineToolName, InlineToolData, InlineFragment, TextNodeSerialized } from '@editorjs/model-types'; +import { + BlockChildType, + EventBus, + NODE_TYPE_HIDDEN_PROP, + PartialIndex, + TextAddedEvent, + TextFormattedEvent, + TextRemovedEvent, + TextUnformattedEvent +} from '@editorjs/model-types'; +import { getContext } from '../../../utils/Context.js'; +import { cloneInlineData } from '../../../utils/index.js'; +import { TextMark } from '../TextMark/index.js'; +import { RunList } from '../RunList/index.js'; + +interface TextNodeConstructorOptions { + value?: string; + fragments?: InlineFragment[]; +} + +/** + * TextNode stores a text value with its inline formatting. + * + * The content is kept as a list of runs: pieces of text with the same set of marks (inline tools with their data). + * Runs are canonical, so the same formatting always gives the same runs and fragments, + * whatever order formatting operations were applied in. + */ +export class TextNode extends EventBus { + /** + * Text and formatting as canonical runs + */ + #runs = new RunList(); + + /** + * TextNode constructor + * @param options - TextNode constructor options + */ + // Stryker disable next-line BlockStatement -- Styker's bug, see https://github.com/stryker-mutator/stryker-js/issues/2474 + constructor(options: TextNodeConstructorOptions = {}) { + const { value = '', fragments = [] } = options; + + super(); + + this.#initialize(value, fragments); + } + + /** + * Returns text length + */ + public get length(): number { + return this.#runs.length; + } + + /** + * Returns serialized TextNode: text value and inline fragments + */ + public get serialized(): TextNodeSerialized { + return { + [NODE_TYPE_HIDDEN_PROP]: BlockChildType.Text as const, + value: this.getText(), + fragments: this.getFragments(), + }; + } + + /** + * Inserts text to the specified index, by default appends text to the end of the current value. + * Inserted text gets formatting of the previous character, or of the first character when inserted at the start + * @param text - text to insert + * @param [index] - char index where to insert text + */ + public insertText(text: string, index = this.length): void { + this.#validateIndex(index); + + this.#runs.insert(text, index); + + this.dispatchEvent(new TextAddedEvent(new PartialIndex({ textRange: [index, index] }), text, getContext()!)); + } + + /** + * Removes text form the specified range + * @param [start] - start char index of the range, by default 0 + * @param [end] - end char index of the range, by default length of the text value + * @returns removed text + */ + public removeText(start = 0, end = this.length): string { + this.#validateRange(start, end); + + const removedText = this.#runs.remove(start, end); + + this.dispatchEvent(new TextRemovedEvent(new PartialIndex({ textRange: [start, end] }), removedText, getContext()!)); + + return removedText; + } + + /** + * Returns text from the specified range + * @param [start] - start char index of the range, by default 0 + * @param [end] - end char index of the range, by default length of the text value + */ + public getText(start = 0, end = this.length): string { + this.#validateRange(start, end); + + return this.#runs.getText().slice(start, end); + } + + /** + * Returns maximal inline fragments sharing at least one character with the specified range. + * Fragments are returned whole and sorted by start, then by end descending, then by tool name + * @param [start] - start char index of the range, by default 0 + * @param [end] - end char index of the range, by default length of the text value + * @param [tool] - name of the Inline Tool to return fragments of + */ + public getFragments(start = 0, end = this.length, tool?: InlineToolName): InlineFragment[] { + this.#validateRange(start, end); + + return this.#runs.toFragments().filter(fragment => start < end + && fragment.range[0] < end + && fragment.range[1] > start + && (tool === undefined || fragment.tool === tool)); + } + + /** + * Applies formatting to the text with specified inline tool in the specified range. + * If some characters already have that tool, its data is replaced with the passed one + * @param tool - name of inline tool to apply + * @param start - char start index of the range + * @param end - char end index of the range + * @param [data] - inline tool data if applicable + */ + public format(tool: InlineToolName, start: number, end: number, data?: InlineToolData): void { + this.#validateRange(start, end); + + this.#runs.setMark(start, end, new TextMark(tool, data)); + + /** + * @todo When format replaces data of an existing mark (e.g. re-applying a link with a new href), the event carries only + * the new data. Undo inverts it into unformat, which removes the link instead of restoring the previous href. + * The event should carry the replaced fragments so undo can re-apply them + */ + this.dispatchEvent( + new TextFormattedEvent( + new PartialIndex({ textRange: [start, end] }), + { + tool, + /** + * A separate copy, so changes to the caller's object reach neither the event nor collaboration operations built from it + */ + data: data === undefined ? undefined : cloneInlineData(data), + }, + getContext()! + ) + ); + } + + /** + * Removes formatting from the text for a specified inline tool in the specified range + * @param tool - name of inline tool to remove + * @param start - char start index of the range + * @param end - char end index of the range + */ + public unformat(tool: InlineToolName, start: number, end: number): void { + this.#validateRange(start, end); + + this.#runs.removeMark(start, end, tool); + + this.dispatchEvent(new TextUnformattedEvent(new PartialIndex({ textRange: [start, end] }), { tool }, getContext()!)); + } + + /** + * Initializes the TextNode with passed initial data. + * Fragments are applied in a fixed order, so conflicting fragments of the same tool + * (overlapping, with different data) give the same result whatever order they are passed in + * @param value - initial text value to insert + * @param fragments - initial inline fragments to apply + */ + #initialize(value: string, fragments: InlineFragment[]): void { + if (!value) { + return; + } + + this.insertText(value); + + [...fragments] + .sort(TextNode.#compareForLoading) + .forEach((fragment) => { + this.format(fragment.tool, ...fragment.range, fragment.data); + }); + } + + /** + * Total order for applying initial fragments: by start, then by end descending, then by tool name, then by data. + * Fragments that sort later win where fragments of the same tool overlap + * @param a - first fragment + * @param b - second fragment + */ + static #compareForLoading(a: InlineFragment, b: InlineFragment): number { + return a.range[0] - b.range[0] + || b.range[1] - a.range[1] + || TextNode.#compareStrings(a.tool, b.tool) + || TextNode.#compareStrings(JSON.stringify(a.data ?? {}), JSON.stringify(b.data ?? {})); + } + + /** + * Compares strings by code units so the order is the same in every environment + * @param a - first string + * @param b - second string + */ + static #compareStrings(a: string, b: string): number { + if (a === b) { + return 0; + } + + return a < b ? -1 : 1; + } + + /** + * Validates if range has valid start and end points + * @param start - range start + * @param end - range end + * @throws Error if range is invalid + */ + #validateRange(start: number, end: number): void { + this.#validateIndex(start); + this.#validateIndex(end); + + if (end < start) { + throw new Error(`The end of range must be greater or equal than the start: [${start}, ${end}]`); + } + } + + /** + * Validates index + * @param index - char index to validate + * @throws Error if index is out of the text length + */ + #validateIndex(index: number): void { + if (index < 0 || index > this.length) { + // Stryker disable next-line StringLiteral + throw new Error(`Index ${index} is not in valid range [0, ${this.length}]`); + } + } +} diff --git a/packages/model/src/entities/inline-text/TextRun/index.ts b/packages/model/src/entities/inline-text/TextRun/index.ts new file mode 100644 index 00000000..0214af04 --- /dev/null +++ b/packages/model/src/entities/inline-text/TextRun/index.ts @@ -0,0 +1,27 @@ +import type { TextMark } from '../TextMark/index.js'; + +/** + * Piece of text with the same set of marks applied to every character. + * Immutable: edits replace runs with new instances. Invariants over a list of runs are kept by RunList + */ +export class TextRun { + /** + * Text of the run + */ + public readonly text: string; + + /** + * Marks applied to the whole run, at most one per tool, sorted by tool name + */ + public readonly marks: readonly TextMark[]; + + /** + * TextRun constructor + * @param text - text of the run + * @param [marks] - marks applied to the whole run, at most one per tool, sorted by tool name + */ + constructor(text: string, marks: readonly TextMark[] = []) { + this.text = text; + this.marks = marks; + } +} diff --git a/packages/model/src/entities/inline-text/index.ts b/packages/model/src/entities/inline-text/index.ts new file mode 100644 index 00000000..5294983d --- /dev/null +++ b/packages/model/src/entities/inline-text/index.ts @@ -0,0 +1 @@ +export { TextNode } from './TextNode/index.js'; diff --git a/packages/model/src/entities/inline-fragments/specs/InlineTree.integration.spec.ts b/packages/model/src/entities/inline-text/specs/InlineFormatting.integration.spec.ts similarity index 82% rename from packages/model/src/entities/inline-fragments/specs/InlineTree.integration.spec.ts rename to packages/model/src/entities/inline-text/specs/InlineFormatting.integration.spec.ts index 0fe30968..3e7e6f02 100644 --- a/packages/model/src/entities/inline-fragments/specs/InlineTree.integration.spec.ts +++ b/packages/model/src/entities/inline-text/specs/InlineFormatting.integration.spec.ts @@ -1,15 +1,12 @@ /* eslint-disable @typescript-eslint/no-magic-numbers */ import { createInlineToolData, createInlineToolName, BlockChildType } from '@editorjs/model-types'; import type { TextNodeSerialized } from '@editorjs/model-types'; -import { - TextInlineNode, - TextNode -} from '../index.js'; +import { TextNode } from '../index.js'; import { NODE_TYPE_HIDDEN_PROP } from '@editorjs/model-types'; -describe('Inline fragments tree integration', () => { +describe('Inline formatting integration', () => { describe('text insertion', () => { - it('should insert text into the empty tree', () => { + it('should insert text into empty text', () => { const tree = new TextNode(); const text = 'Editor.js is a block-styled editor'; @@ -19,11 +16,10 @@ describe('Inline fragments tree integration', () => { .toBe(text); }); - it('should insert text at the end of the non-empty tree', () => { + it('should insert text at the end of non-empty text', () => { const initialText = 'Editor.js is a block-styled editor.'; - const child = new TextInlineNode({ value: initialText }); - const tree = new TextNode({ children: [child] }); + const tree = new TextNode({ value: initialText }); const text = ' Editor outputs clean data in JSON'; tree.insertText(text); @@ -32,11 +28,10 @@ describe('Inline fragments tree integration', () => { .toBe(initialText + text); }); - it('should insert text at the beginning of the non-empty tree', () => { + it('should insert text at the beginning of non-empty text', () => { const initialText = 'Editor.js is a block-styled editor.'; - const child = new TextInlineNode({ value: initialText }); - const tree = new TextNode({ children: [child] }); + const tree = new TextNode({ value: initialText }); const text = 'Editor outputs clean data in JSON '; tree.insertText(text, 0); @@ -45,12 +40,11 @@ describe('Inline fragments tree integration', () => { .toBe(text + initialText); }); - it('should insert text at the middle of the non-empty tree', () => { + it('should insert text at the middle of non-empty text', () => { const initialText = 'Editor.js is a block-styled editor.'; const index = 10; - const child = new TextInlineNode({ value: initialText }); - const tree = new TextNode({ children: [child] }); + const tree = new TextNode({ value: initialText }); const text = ' Editor outputs clean data in JSON '; tree.insertText(text, index); @@ -63,8 +57,7 @@ describe('Inline fragments tree integration', () => { describe('text removal', () => { it('should return removed text', () => { const initialText = 'Editor.js is a block-styled editor.'; - const child = new TextInlineNode({ value: initialText }); - const tree = new TextNode({ children: [child] }); + const tree = new TextNode({ value: initialText }); const removedText = tree.removeText(); @@ -72,10 +65,9 @@ describe('Inline fragments tree integration', () => { .toBe(initialText); }); - it('should remove all text from the tree', () => { + it('should remove all text from the text', () => { const initialText = 'Editor.js is a block-styled editor.'; - const child = new TextInlineNode({ value: initialText }); - const tree = new TextNode({ children: [child] }); + const tree = new TextNode({ value: initialText }); tree.removeText(); @@ -83,10 +75,9 @@ describe('Inline fragments tree integration', () => { .toBe(0); }); - it('should remove text from the beginning of the tree', () => { + it('should remove text from the beginning of the text', () => { const initialText = 'Editor.js is a block-styled editor.'; - const child = new TextInlineNode({ value: initialText }); - const tree = new TextNode({ children: [child] }); + const tree = new TextNode({ value: initialText }); const index = 10; tree.removeText(0, index); @@ -95,10 +86,9 @@ describe('Inline fragments tree integration', () => { .toBe(initialText.slice(index)); }); - it('should remove text from the middle of the tree', () => { + it('should remove text from the middle of the text', () => { const initialText = 'Editor.js is a block-styled editor.'; - const child = new TextInlineNode({ value: initialText }); - const tree = new TextNode({ children: [child] }); + const tree = new TextNode({ value: initialText }); const index = 10; const length = 5; @@ -108,10 +98,9 @@ describe('Inline fragments tree integration', () => { .toBe(initialText.slice(0, index) + initialText.slice(index + length)); }); - it('should remove text from passed index to the end of the tree', () => { + it('should remove text from passed index to the end of the text', () => { const initialText = 'Editor.js is a block-styled editor.'; - const child = new TextInlineNode({ value: initialText }); - const tree = new TextNode({ children: [child] }); + const tree = new TextNode({ value: initialText }); const index = 10; tree.removeText(index); @@ -122,8 +111,7 @@ describe('Inline fragments tree integration', () => { it('should throw an error if index is out of range', () => { const initialText = 'Editor.js is a block-styled editor.'; - const child = new TextInlineNode({ value: initialText }); - const tree = new TextNode({ children: [child] }); + const tree = new TextNode({ value: initialText }); const index = 100; expect(() => tree.removeText(index)) @@ -136,8 +124,7 @@ describe('Inline fragments tree integration', () => { it('should format text', () => { const initialText = 'Editor.js is a block-styled editor.'; - const child = new TextInlineNode({ value: initialText }); - const tree = new TextNode({ children: [child] }); + const tree = new TextNode({ value: initialText }); const index = 0; tree.format(inlineTool, index, tree.length); @@ -156,8 +143,7 @@ describe('Inline fragments tree integration', () => { it('should save formatting data', () => { const initialText = 'Editor.js is a block-styled editor.'; - const child = new TextInlineNode({ value: initialText }); - const tree = new TextNode({ children: [child] }); + const tree = new TextNode({ value: initialText }); const index = 0; const data = createInlineToolData({ bold: true }); @@ -176,10 +162,9 @@ describe('Inline fragments tree integration', () => { ]); }); - it('should format text in the middle of the tree', () => { + it('should format text in the middle of the text', () => { const initialText = 'Editor.js is a block-styled editor.'; - const child = new TextInlineNode({ value: initialText }); - const tree = new TextNode({ children: [child] }); + const tree = new TextNode({ value: initialText }); const index = 10; const length = 5; @@ -198,10 +183,7 @@ describe('Inline fragments tree integration', () => { it('should support nested formatting for the same tool', () => { const initialText = 'Editor.js is a block-styled editor.'; - const child = new TextInlineNode({ value: initialText }); - const tree = new TextNode({ - children: [child], - }); + const tree = new TextNode({ value: initialText }); const index = 10; const length = 5; const offset = 1; @@ -222,10 +204,7 @@ describe('Inline fragments tree integration', () => { it('should support nested formatting for different tools', () => { const initialText = 'Editor.js is a block-styled editor.'; - const child = new TextInlineNode({ value: initialText }); - const tree = new TextNode({ - children: [child], - }); + const tree = new TextNode({ value: initialText }); const italicInlineTool = createInlineToolName('italic'); const index = 10; @@ -255,10 +234,7 @@ describe('Inline fragments tree integration', () => { it('should support overlapping formatting for the same tool', () => { const initialText = 'Editor.js is a block-styled editor.'; - const child = new TextInlineNode({ value: initialText }); - const tree = new TextNode({ - children: [child], - }); + const tree = new TextNode({ value: initialText }); const index = 10; const length = 5; @@ -283,7 +259,7 @@ describe('Inline fragments tree integration', () => { const initialText = 'Editor.js is a block-styled editor.'; it('should replace fragment data when re-applying the same tool with different data', () => { - const tree = new TextNode({ children: [new TextInlineNode({ value: initialText })] }); + const tree = new TextNode({ value: initialText }); tree.format(linkTool, 0, initialText.length, createInlineToolData({ href: 'https://a.com' })); tree.format(linkTool, 0, initialText.length, createInlineToolData({ href: 'https://b.com' })); @@ -298,7 +274,7 @@ describe('Inline fragments tree integration', () => { }); it('should leave the tree unchanged when re-applying the same tool with identical data', () => { - const tree = new TextNode({ children: [new TextInlineNode({ value: initialText })] }); + const tree = new TextNode({ value: initialText }); const data = createInlineToolData({ href: 'https://a.com' }); tree.format(linkTool, 0, initialText.length, data); @@ -314,7 +290,7 @@ describe('Inline fragments tree integration', () => { }); it('should split the fragment and replace data only within the re-applied range', () => { - const tree = new TextNode({ children: [new TextInlineNode({ value: initialText })] }); + const tree = new TextNode({ value: initialText }); const dataA = createInlineToolData({ href: 'https://a.com' }); const dataB = createInlineToolData({ href: 'https://b.com' }); const start = 5; @@ -343,7 +319,7 @@ describe('Inline fragments tree integration', () => { }); it('should replace data only within a re-applied prefix range', () => { - const tree = new TextNode({ children: [new TextInlineNode({ value: initialText })] }); + const tree = new TextNode({ value: initialText }); const dataA = createInlineToolData({ href: 'https://a.com' }); const dataB = createInlineToolData({ href: 'https://b.com' }); const end = 10; @@ -366,7 +342,7 @@ describe('Inline fragments tree integration', () => { }); it('should not merge adjacent same-tool fragments whose data differs', () => { - const tree = new TextNode({ children: [new TextInlineNode({ value: initialText })] }); + const tree = new TextNode({ value: initialText }); const dataA = createInlineToolData({ href: 'https://a.com' }); const dataB = createInlineToolData({ href: 'https://b.com' }); const boundary = 10; @@ -391,10 +367,7 @@ describe('Inline fragments tree integration', () => { it('should support overlapping formatting for different tools', () => { const initialText = 'Editor.js is a block-styled editor.'; - const child = new TextInlineNode({ value: initialText }); - const tree = new TextNode({ - children: [child], - }); + const tree = new TextNode({ value: initialText }); const italicInlineTool = createInlineToolName('italic'); const index = 10; @@ -506,7 +479,7 @@ describe('Inline fragments tree integration', () => { }); }); - it('should initialize tree with initial text and fragments', () => { + it('should initialize text with initial text and fragments', () => { const data = { [NODE_TYPE_HIDDEN_PROP]: BlockChildType.Text, value: 'Editor.js is a block-styled editor. It returns clean output in JSON. Designed to be extendable and pluggable with a simple API.', diff --git a/packages/model/src/entities/inline-text/specs/randomOperations.testing.ts b/packages/model/src/entities/inline-text/specs/randomOperations.testing.ts new file mode 100644 index 00000000..a9a1d1bc --- /dev/null +++ b/packages/model/src/entities/inline-text/specs/randomOperations.testing.ts @@ -0,0 +1,341 @@ +/* eslint-disable @typescript-eslint/no-magic-numbers */ +import type { InlineFragment, InlineToolData, InlineToolName } from '@editorjs/model-types'; +import { createInlineToolData, createInlineToolName } from '@editorjs/model-types'; +import { isSameInlineData } from '../../../utils/index.js'; + +const tools = [createInlineToolName('bold'), createInlineToolName('italic'), createInlineToolName('link')]; +const linkData = [createInlineToolData({ href: 'a' }), createInlineToolData({ href: 'b' })]; +const emptyData = createInlineToolData({}); + +/** + * Checks if inline tool data is missing or empty: the model stores both as no data + * @param data - inline tool data + */ +function isEmptyData(data?: InlineToolData): boolean { + return data === undefined || Object.keys(data).length === 0; +} + +/** + * Returns a random range within the text + * @param random - random generator + * @param length - text length + */ +function randomRange(random: Random, length: number): [number, number] { + const a = random(length + 1); + const b = random(length + 1); + + return [Math.min(a, b), Math.max(a, b)]; +} + +/** + * Returns a random integer in [0, max) + */ +export type Random = (max: number) => number; + +/** + * Text operation generated for both the implementation under test and the reference model + */ +export type TextOperation = InsertOperation | RemoveOperation | FormatOperation | UnformatOperation; + +/** + * Inserts text at the index + */ +interface InsertOperation { + type: 'insert'; + text: string; + index: number; +} + +/** + * Removes text in the range + */ +interface RemoveOperation { + type: 'remove'; + start: number; + end: number; +} + +/** + * Applies the tool with optional data to the range + */ +interface FormatOperation { + type: 'format'; + tool: InlineToolName; + start: number; + end: number; + data?: InlineToolData; +} + +/** + * Removes the tool from the range + */ +interface UnformatOperation { + type: 'unformat'; + tool: InlineToolName; + start: number; + end: number; +} + +/** + * Character of the reference model with the marks applied to it + */ +interface ReferenceChar { + char: string; + marks: Map; +} + +/** + * Straightforward model of formatted text that stores marks per character, used as the oracle + */ +export class ReferenceText { + /** + * Characters with their marks + */ + #chars: ReferenceChar[]; + + /** + * ReferenceText constructor + * @param text - initial text without formatting + */ + constructor(text: string) { + this.#chars = text.split('').map(char => ({ + char, + marks: new Map(), + })); + } + + /** + * Returns text length + */ + public get length(): number { + return this.#chars.length; + } + + /** + * Returns the text + */ + public getText(): string { + return this.#chars.map(char => char.char).join(''); + } + + /** + * Applies the operation. Inserted text gets marks of the previous character, or of the first one at index 0 + * @param operation - operation to apply + */ + public apply(operation: TextOperation): void { + switch (operation.type) { + case 'insert': { + const { index, text } = operation; + const source = this.#chars[index > 0 ? index - 1 : 0]; + + this.#chars.splice(index, 0, ...text.split('').map(char => ({ + char, + marks: new Map(source?.marks ?? []), + }))); + break; + } + case 'remove': + this.#chars.splice(operation.start, operation.end - operation.start); + break; + case 'format': { + const data = isEmptyData(operation.data) ? undefined : operation.data; + + this.#chars.slice(operation.start, operation.end).forEach(char => char.marks.set(operation.tool, data)); + break; + } + case 'unformat': + this.#chars.slice(operation.start, operation.end).forEach(char => char.marks.delete(operation.tool)); + break; + } + } + + /** + * Returns maximal fragments sorted by start, then by end descending, then by tool name + */ + public getFragments(): InlineFragment[] { + const fragments: InlineFragment[] = []; + + for (const tool of tools) { + let start = 0; + + while (start < this.#chars.length) { + if (!this.#chars[start].marks.has(tool)) { + start++; + + continue; + } + + const data = this.#chars[start].marks.get(tool); + let end = start + 1; + + while (end < this.#chars.length && this.#chars[end].marks.has(tool) && isSameInlineData(this.#chars[end].marks.get(tool), data)) { + end++; + } + + const fragment: InlineFragment = { + tool, + range: [start, end], + }; + + if (data !== undefined) { + fragment.data = data; + } + + fragments.push(fragment); + start = end; + } + } + + return fragments.sort((a, b) => a.range[0] - b.range[0] || b.range[1] - a.range[1] || (a.tool < b.tool ? -1 : 1)); + } +} + +/** + * Returns random data for the tool: one of two hrefs for links, missing or empty data for other tools + * @param random - random generator + * @param tool - inline tool + */ +function randomData(random: Random, tool: InlineToolName): InlineToolData | undefined { + if (tool === tools[2]) { + return linkData[random(linkData.length)]; + } + + return random(2) === 0 ? undefined : emptyData; +} + +/** + * Compares strings by code units + * @param a - first string + * @param b - second string + */ +function compareStrings(a: string, b: string): number { + if (a === b) { + return 0; + } + + return a < b ? -1 : 1; +} + +/** + * Order the model is expected to apply initial fragments in: by start, then by end descending, then by tool, then by data + * @param a - first fragment + * @param b - second fragment + */ +export function compareForLoading(a: InlineFragment, b: InlineFragment): number { + return a.range[0] - b.range[0] + || b.range[1] - a.range[1] + || compareStrings(a.tool, b.tool) + || compareStrings(JSON.stringify(a.data ?? {}), JSON.stringify(b.data ?? {})); +} + +/** + * Returns random fragments for text of the passed length; they may overlap and conflict + * @param random - random generator + * @param length - text length + */ +export function randomFragments(random: Random, length: number): InlineFragment[] { + return Array.from({ length: random(6) }, () => { + const tool = tools[random(tools.length)]; + const [start, end] = randomRange(random, length); + const data = randomData(random, tool); + const fragment: InlineFragment = { + tool, + range: [start, end], + }; + + if (data !== undefined) { + fragment.data = data; + } + + return fragment; + }); +} + +/** + * Seeded pseudo-random generator (mulberry32), so failures are reproducible + * @param seed - generator seed + */ +export function createRandom(seed: number): Random { + let state = seed; + + return (max: number): number => { + state = (state + 0x6D2B79F5) | 0; + + let t = Math.imul(state ^ (state >>> 15), 1 | state); + + t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t; + + return Math.floor((((t ^ (t >>> 14)) >>> 0) / 4294967296) * max); + }; +} + +/** + * Returns random initial text of up to 10 characters + * @param random - random generator + */ +export function randomText(random: Random): string { + return 'abcdefghij'.slice(0, random(11)); +} + +/** + * Returns a random valid operation for text of the passed length + * @param random - random generator + * @param length - current text length + */ +export function randomOperation(random: Random, length: number): TextOperation { + const kind = random(4); + + if (kind === 0) { + return { + type: 'insert', + text: 'xyz'.slice(0, random(3) + 1), + index: random(length + 1), + }; + } + + const [start, end] = randomRange(random, length); + + if (kind === 1) { + return { + type: 'remove', + start, + end, + }; + } + + const tool = tools[random(tools.length)]; + + if (kind === 2) { + return { + type: 'format', + tool, + start, + end, + data: randomData(random, tool), + }; + } + + return { + type: 'unformat', + tool, + start, + end, + }; +} + +/** + * Shuffles an array with the passed random generator + * @param random - random generator + * @param items - items to shuffle + */ +export function shuffle(random: Random, items: T[]): T[] { + const result = [...items]; + + for (let index = result.length - 1; index > 0; index--) { + const other = random(index + 1); + + [result[index], result[other]] = [result[other], result[index]]; + } + + return result; +} diff --git a/packages/model/src/utils/cloneInlineData.spec.ts b/packages/model/src/utils/cloneInlineData.spec.ts new file mode 100644 index 00000000..b7844f2a --- /dev/null +++ b/packages/model/src/utils/cloneInlineData.spec.ts @@ -0,0 +1,39 @@ +import { createInlineToolData } from '@editorjs/model-types'; +import { cloneInlineData } from './cloneInlineData.js'; + +describe('cloneInlineData', () => { + it('should return an equal object', () => { + const data = createInlineToolData({ + href: 'a', + attributes: { + target: '_blank', + rel: ['noopener', 'noreferrer'], + }, + }); + + expect(cloneInlineData(data)).toStrictEqual(data); + }); + + it('should not share nested objects and arrays with the original', () => { + const original = { + attributes: { + rel: ['noopener'], + }, + }; + const copy = cloneInlineData(createInlineToolData(original)) as unknown as typeof original; + + expect(copy).not.toBe(original); + expect(copy.attributes).not.toBe(original.attributes); + expect(copy.attributes.rel).not.toBe(original.attributes.rel); + }); + + it('should keep primitive values', () => { + const data = createInlineToolData({ + count: 1, + flag: false, + empty: null, + }); + + expect(cloneInlineData(data)).toStrictEqual(data); + }); +}); diff --git a/packages/model/src/utils/cloneInlineData.ts b/packages/model/src/utils/cloneInlineData.ts new file mode 100644 index 00000000..ac39c1bc --- /dev/null +++ b/packages/model/src/utils/cloneInlineData.ts @@ -0,0 +1,25 @@ +import type { InlineToolData } from '@editorjs/model-types'; + +/** + * Deep copy of a plain JSON-like value + * @param value - value to copy + */ +function deepClone(value: T): T { + if (Array.isArray(value)) { + return value.map(item => deepClone(item) as unknown) as T; + } + + if (typeof value === 'object' && value !== null) { + return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, deepClone(item as unknown)])) as T; + } + + return value; +} + +/** + * Returns a deep copy of inline tool data, so the copy can be stored or handed out without sharing nested objects + * @param data - inline tool data to copy + */ +export function cloneInlineData(data: InlineToolData): InlineToolData { + return deepClone(data); +} diff --git a/packages/model/src/utils/index.ts b/packages/model/src/utils/index.ts index a4bc214f..0078f59e 100644 --- a/packages/model/src/utils/index.ts +++ b/packages/model/src/utils/index.ts @@ -1,2 +1,3 @@ export * from './textUtils.js'; export * from './isSameInlineData.js'; +export * from './cloneInlineData.js'; diff --git a/packages/model/stryker.conf.mjs b/packages/model/stryker.conf.mjs index 9b1f4ca1..09b5aca2 100644 --- a/packages/model/stryker.conf.mjs +++ b/packages/model/stryker.conf.mjs @@ -25,7 +25,7 @@ const config = { tsconfigFile: "tsconfig.json", checkers: ["typescript"], timeoutMS: 10000, - mutate: ["./src/**/*.ts", "!./src/**/mocks/*.ts", "!./src/**/__mocks__/*.ts", "!./src/**/*.spec.ts"], + mutate: ["./src/**/*.ts", "!./src/**/mocks/*.ts", "!./src/**/__mocks__/*.ts", "!./src/**/*.spec.ts", "!./src/**/*.testing.ts"], /* * In some cases PRs might not have any unit-tests */ diff --git a/yarn.lock b/yarn.lock index 0ef9b761..1c0c7515 100644 --- a/yarn.lock +++ b/yarn.lock @@ -2399,6 +2399,7 @@ __metadata: eslint-plugin-import: "npm:^2.29.0" inversify: "npm:^8.1.0" jest: "npm:^29.7.0" + jest-environment-jsdom: "npm:^29.7.0" reflect-metadata: "npm:^0.2.2" stryker-cli: "npm:^1.0.2" ts-jest: "npm:^29.2.5" @@ -4408,6 +4409,13 @@ __metadata: languageName: node linkType: hard +"@tootallnate/once@npm:2": + version: 2.0.1 + resolution: "@tootallnate/once@npm:2.0.1" + checksum: 487b59b5adb8458dc13394a5aae997bf9705c51fa1e2396c50cd967019d06b273faba3c4d9e7895a996b9e9b055f1c55e53d822e54b3e9c298bcb4f6967cd0d5 + languageName: node + linkType: hard + "@tsconfig/node10@npm:^1.0.7": version: 1.0.11 resolution: "@tsconfig/node10@npm:1.0.11" @@ -4573,6 +4581,17 @@ __metadata: languageName: node linkType: hard +"@types/jsdom@npm:^20.0.0": + version: 20.0.1 + resolution: "@types/jsdom@npm:20.0.1" + dependencies: + "@types/node": "npm:*" + "@types/tough-cookie": "npm:*" + parse5: "npm:^7.0.0" + checksum: 15fbb9a0bfb4a5845cf6e795f2fd12400aacfca53b8c7e5bca4a3e5e8fa8629f676327964d64258aefb127d2d8a2be86dad46359efbfca0e8c9c2b790e7f8a88 + languageName: node + linkType: hard + "@types/json-schema@npm:*, @types/json-schema@npm:^7.0.15": version: 7.0.15 resolution: "@types/json-schema@npm:7.0.15" @@ -4622,6 +4641,13 @@ __metadata: languageName: node linkType: hard +"@types/tough-cookie@npm:*": + version: 4.0.5 + resolution: "@types/tough-cookie@npm:4.0.5" + checksum: 01fd82efc8202670865928629697b62fe9bf0c0dcbc5b1c115831caeb073a2c0abb871ff393d7df1ae94ea41e256cb87d2a5a91fd03cdb1b0b4384e08d4ee482 + languageName: node + linkType: hard + "@types/web-bluetooth@npm:^0.0.20": version: 0.0.20 resolution: "@types/web-bluetooth@npm:0.0.20" @@ -5019,6 +5045,13 @@ __metadata: languageName: node linkType: hard +"abab@npm:^2.0.6": + version: 2.0.6 + resolution: "abab@npm:2.0.6" + checksum: ebe95d7278999e605823fc515a3b05d689bc72e7f825536e73c95ebf621636874c6de1b749b3c4bf866b96ccd4b3a2802efa313d0e45ad51a413c8c73247db20 + languageName: node + linkType: hard + "abbrev@npm:^3.0.0": version: 3.0.0 resolution: "abbrev@npm:3.0.0" @@ -5026,6 +5059,16 @@ __metadata: languageName: node linkType: hard +"acorn-globals@npm:^7.0.0": + version: 7.0.1 + resolution: "acorn-globals@npm:7.0.1" + dependencies: + acorn: "npm:^8.1.0" + acorn-walk: "npm:^8.0.2" + checksum: 2a2998a547af6d0db5f0cdb90acaa7c3cbca6709010e02121fb8b8617c0fbd8bab0b869579903fde358ac78454356a14fadcc1a672ecb97b04b1c2ccba955ce8 + languageName: node + linkType: hard + "acorn-jsx@npm:^5.3.2": version: 5.3.2 resolution: "acorn-jsx@npm:5.3.2" @@ -5035,6 +5078,15 @@ __metadata: languageName: node linkType: hard +"acorn-walk@npm:^8.0.2": + version: 8.3.5 + resolution: "acorn-walk@npm:8.3.5" + dependencies: + acorn: "npm:^8.11.0" + checksum: f52a158a1c1f00c82702c7eb9b8ae8aad79748a7689241dcc2d797dce680f1dcb15c78f312f687eeacdfb3a4cac4b87d04af470f0201bd56c6661fca6f94b195 + languageName: node + linkType: hard + "acorn-walk@npm:^8.1.1": version: 8.3.4 resolution: "acorn-walk@npm:8.3.4" @@ -5044,6 +5096,15 @@ __metadata: languageName: node linkType: hard +"acorn@npm:^8.1.0, acorn@npm:^8.8.1": + version: 8.19.0 + resolution: "acorn@npm:8.19.0" + bin: + acorn: bin/acorn + checksum: 99307d577b38d6a441cd478456633b5b669d32bc722633ff84f1f3c88d361735d7cf01d04ecbf1113c70f1f39e5ceceb95cd5bf93b15bacaddc8fca1ea5e7496 + languageName: node + linkType: hard + "acorn@npm:^8.11.0, acorn@npm:^8.14.0, acorn@npm:^8.4.1, acorn@npm:^8.9.0": version: 8.14.1 resolution: "acorn@npm:8.14.1" @@ -5053,6 +5114,15 @@ __metadata: languageName: node linkType: hard +"agent-base@npm:6": + version: 6.0.2 + resolution: "agent-base@npm:6.0.2" + dependencies: + debug: "npm:4" + checksum: 21fb903e0917e5cb16591b4d0ef6a028a54b83ac30cd1fca58dece3d4e0990512a8723f9f83130d88a41e2af8b1f7be1386fda3ea2d181bb1a62155e75e95e23 + languageName: node + linkType: hard + "agent-base@npm:^7.1.0, agent-base@npm:^7.1.2": version: 7.1.3 resolution: "agent-base@npm:7.1.3" @@ -5315,6 +5385,13 @@ __metadata: languageName: node linkType: hard +"asynckit@npm:^0.4.0": + version: 0.4.0 + resolution: "asynckit@npm:0.4.0" + checksum: 3ce727cbc78f69d6a4722517a58ee926c8c21083633b1d3fdf66fd688f6c127a53a592141bd4866f9b63240a86e9d8e974b13919450bd17fa33c2d22c4558ad8 + languageName: node + linkType: hard + "autoprefixer@npm:^10.4.19": version: 10.4.21 resolution: "autoprefixer@npm:10.4.21" @@ -5966,6 +6043,15 @@ __metadata: languageName: node linkType: hard +"combined-stream@npm:^1.0.8": + version: 1.0.8 + resolution: "combined-stream@npm:1.0.8" + dependencies: + delayed-stream: "npm:~1.0.0" + checksum: 2e969e637d05d09fa50b02d74c83a1186f6914aae89e6653b62595cc75a221464f884f55f231b8f4df7a49537fba60bdc0427acd2bf324c09a1dbb84837e36e4 + languageName: node + linkType: hard + "commander@npm:^14.0.0": version: 14.0.3 resolution: "commander@npm:14.0.3" @@ -6253,6 +6339,29 @@ __metadata: languageName: node linkType: hard +"cssom@npm:^0.5.0": + version: 0.5.0 + resolution: "cssom@npm:0.5.0" + checksum: b502a315b1ce020a692036cc38cb36afa44157219b80deadfa040ab800aa9321fcfbecf02fd2e6ec87db169715e27978b4ab3701f916461e9cf7808899f23b54 + languageName: node + linkType: hard + +"cssom@npm:~0.3.6": + version: 0.3.8 + resolution: "cssom@npm:0.3.8" + checksum: 49eacc88077555e419646c0ea84ddc73c97e3a346ad7cb95e22f9413a9722d8964b91d781ce21d378bd5ae058af9a745402383fa4e35e9cdfd19654b63f892a9 + languageName: node + linkType: hard + +"cssstyle@npm:^2.3.0": + version: 2.3.0 + resolution: "cssstyle@npm:2.3.0" + dependencies: + cssom: "npm:~0.3.6" + checksum: 46f7f05a153446c4018b0454ee1464b50f606cb1803c90d203524834b7438eb52f3b173ba0891c618f380ced34ee12020675dc0052a7f1be755fe4ebc27ee977 + languageName: node + linkType: hard + "csstype@npm:^3.1.3": version: 3.1.3 resolution: "csstype@npm:3.1.3" @@ -6260,6 +6369,17 @@ __metadata: languageName: node linkType: hard +"data-urls@npm:^3.0.2": + version: 3.0.2 + resolution: "data-urls@npm:3.0.2" + dependencies: + abab: "npm:^2.0.6" + whatwg-mimetype: "npm:^3.0.0" + whatwg-url: "npm:^11.0.0" + checksum: 033fc3dd0fba6d24bc9a024ddcf9923691dd24f90a3d26f6545d6a2f71ec6956f93462f2cdf2183cc46f10dc01ed3bcb36731a8208456eb1a08147e571fe2a76 + languageName: node + linkType: hard + "data-view-buffer@npm:^1.0.2": version: 1.0.2 resolution: "data-view-buffer@npm:1.0.2" @@ -6356,6 +6476,13 @@ __metadata: languageName: node linkType: hard +"decimal.js@npm:^10.4.2": + version: 10.6.0 + resolution: "decimal.js@npm:10.6.0" + checksum: c0d45842d47c311d11b38ce7ccc911121953d4df3ebb1465d92b31970eb4f6738a065426a06094af59bee4b0d64e42e7c8984abd57b6767c64ea90cf90bb4a69 + languageName: node + linkType: hard + "dedent@npm:^1.0.0": version: 1.7.2 resolution: "dedent@npm:1.7.2" @@ -6413,6 +6540,13 @@ __metadata: languageName: node linkType: hard +"delayed-stream@npm:~1.0.0": + version: 1.0.0 + resolution: "delayed-stream@npm:1.0.0" + checksum: 46fe6e83e2cb1d85ba50bd52803c68be9bd953282fa7096f51fc29edd5d67ff84ff753c51966061e5ba7cb5e47ef6d36a91924eddb7f3f3483b1c560f77a0020 + languageName: node + linkType: hard + "detect-newline@npm:^3.0.0": version: 3.1.0 resolution: "detect-newline@npm:3.1.0" @@ -6477,6 +6611,15 @@ __metadata: languageName: node linkType: hard +"domexception@npm:^4.0.0": + version: 4.0.0 + resolution: "domexception@npm:4.0.0" + dependencies: + webidl-conversions: "npm:^7.0.0" + checksum: 4ed443227d2871d76c58d852b2e93c68e0443815b2741348f20881bedee8c1ad4f9bfc5d30c7dec433cd026b57da63407c010260b1682fef4c8847e7181ea43f + languageName: node + linkType: hard + "domhandler@npm:^4.2.0, domhandler@npm:^4.3.1": version: 4.3.1 resolution: "domhandler@npm:4.3.1" @@ -6629,6 +6772,13 @@ __metadata: languageName: node linkType: hard +"entities@npm:^6.0.0": + version: 6.0.1 + resolution: "entities@npm:6.0.1" + checksum: 62af1307202884349d2867f0aac5c60d8b57102ea0b0e768b16246099512c28e239254ad772d6834e7e14cb1b6f153fc3d0c031934e3183b086c86d3838d874a + languageName: node + linkType: hard + "env-paths@npm:^2.2.0": version: 2.2.1 resolution: "env-paths@npm:2.2.1" @@ -6958,6 +7108,24 @@ __metadata: languageName: node linkType: hard +"escodegen@npm:^2.0.0": + version: 2.1.0 + resolution: "escodegen@npm:2.1.0" + dependencies: + esprima: "npm:^4.0.1" + estraverse: "npm:^5.2.0" + esutils: "npm:^2.0.2" + source-map: "npm:~0.6.1" + dependenciesMeta: + source-map: + optional: true + bin: + escodegen: bin/escodegen.js + esgenerate: bin/esgenerate.js + checksum: 47719a65b2888b4586e3fa93769068b275961c13089e90d5d01a96a6e8e95871b1c3893576814c8fbf08a4a31a496f37e7b2c937cf231270f4d81de012832c7c + languageName: node + linkType: hard + "eslint-compat-utils@npm:^0.5.1": version: 0.5.1 resolution: "eslint-compat-utils@npm:0.5.1" @@ -7322,7 +7490,7 @@ __metadata: languageName: node linkType: hard -"esprima@npm:^4.0.0": +"esprima@npm:^4.0.0, esprima@npm:^4.0.1": version: 4.0.1 resolution: "esprima@npm:4.0.1" bin: @@ -7675,6 +7843,19 @@ __metadata: languageName: node linkType: hard +"form-data@npm:^4.0.0": + version: 4.0.6 + resolution: "form-data@npm:4.0.6" + dependencies: + asynckit: "npm:^0.4.0" + combined-stream: "npm:^1.0.8" + es-set-tostringtag: "npm:^2.1.0" + hasown: "npm:^2.0.4" + mime-types: "npm:^2.1.35" + checksum: de6614c8537c92fa5fa3ee7e827758f98f5a9c033f348b7de81855ef36e5cb867e75d9f405d9483ab8d724a4a20d4e79926a299fa8dbba38f530eb659f0884e4 + languageName: node + linkType: hard + "fraction.js@npm:^4.3.7": version: 4.3.7 resolution: "fraction.js@npm:4.3.7" @@ -8061,6 +8242,15 @@ __metadata: languageName: node linkType: hard +"hasown@npm:^2.0.4": + version: 2.0.4 + resolution: "hasown@npm:2.0.4" + dependencies: + function-bind: "npm:^1.1.2" + checksum: 13823863ae48161068b4c51606a3128451c66f14545a5169d667fe9fca168dcd38c27570c7a299e32ef844b8da3d55def7fe88602f8970d4311fb543ee88001a + languageName: node + linkType: hard + "he@npm:^1.2.0": version: 1.2.0 resolution: "he@npm:1.2.0" @@ -8070,6 +8260,15 @@ __metadata: languageName: node linkType: hard +"html-encoding-sniffer@npm:^3.0.0": + version: 3.0.0 + resolution: "html-encoding-sniffer@npm:3.0.0" + dependencies: + whatwg-encoding: "npm:^2.0.0" + checksum: 707a812ec2acaf8bb5614c8618dc81e2fb6b4399d03e95ff18b65679989a072f4e919b9bef472039301a1bbfba64063ba4c79ea6e851c653ac9db80dbefe8fe5 + languageName: node + linkType: hard + "html-escaper@npm:^2.0.0": version: 2.0.2 resolution: "html-escaper@npm:2.0.2" @@ -8084,6 +8283,17 @@ __metadata: languageName: node linkType: hard +"http-proxy-agent@npm:^5.0.0": + version: 5.0.0 + resolution: "http-proxy-agent@npm:5.0.0" + dependencies: + "@tootallnate/once": "npm:2" + agent-base: "npm:6" + debug: "npm:4" + checksum: 5ee19423bc3e0fd5f23ce991b0755699ad2a46a440ce9cec99e8126bb98448ad3479d2c0ea54be5519db5b19a4ffaa69616bac01540db18506dd4dac3dc418f0 + languageName: node + linkType: hard + "http-proxy-agent@npm:^7.0.0": version: 7.0.2 resolution: "http-proxy-agent@npm:7.0.2" @@ -8094,6 +8304,16 @@ __metadata: languageName: node linkType: hard +"https-proxy-agent@npm:^5.0.1": + version: 5.0.1 + resolution: "https-proxy-agent@npm:5.0.1" + dependencies: + agent-base: "npm:6" + debug: "npm:4" + checksum: f0dce7bdcac5e8eaa0be3c7368bb8836ed010fb5b6349ffb412b172a203efe8f807d9a6681319105ea1b6901e1972c7b5ea899672a7b9aad58309f766dcbe0df + languageName: node + linkType: hard + "https-proxy-agent@npm:^7.0.1": version: 7.0.6 resolution: "https-proxy-agent@npm:7.0.6" @@ -8127,6 +8347,15 @@ __metadata: languageName: node linkType: hard +"iconv-lite@npm:0.6.3, iconv-lite@npm:^0.6.2": + version: 0.6.3 + resolution: "iconv-lite@npm:0.6.3" + dependencies: + safer-buffer: "npm:>= 2.1.2 < 3.0.0" + checksum: 24e3292dd3dadaa81d065c6f8c41b274a47098150d444b96e5f53b4638a9a71482921ea6a91a1f59bb71d9796de25e04afd05919fa64c360347ba65d3766f10f + languageName: node + linkType: hard + "iconv-lite@npm:^0.4.24": version: 0.4.24 resolution: "iconv-lite@npm:0.4.24" @@ -8136,15 +8365,6 @@ __metadata: languageName: node linkType: hard -"iconv-lite@npm:^0.6.2": - version: 0.6.3 - resolution: "iconv-lite@npm:0.6.3" - dependencies: - safer-buffer: "npm:>= 2.1.2 < 3.0.0" - checksum: 24e3292dd3dadaa81d065c6f8c41b274a47098150d444b96e5f53b4638a9a71482921ea6a91a1f59bb71d9796de25e04afd05919fa64c360347ba65d3766f10f - languageName: node - linkType: hard - "iconv-lite@npm:^0.7.0": version: 0.7.3 resolution: "iconv-lite@npm:0.7.3" @@ -8530,6 +8750,13 @@ __metadata: languageName: node linkType: hard +"is-potential-custom-element-name@npm:^1.0.1": + version: 1.0.1 + resolution: "is-potential-custom-element-name@npm:1.0.1" + checksum: ced7bbbb6433a5b684af581872afe0e1767e2d1146b2207ca0068a648fb5cab9d898495d1ac0583524faaf24ca98176a7d9876363097c2d14fee6dd324f3a1ab + languageName: node + linkType: hard + "is-regex@npm:^1.2.1": version: 1.2.1 resolution: "is-regex@npm:1.2.1" @@ -8899,6 +9126,27 @@ __metadata: languageName: node linkType: hard +"jest-environment-jsdom@npm:^29.7.0": + version: 29.7.0 + resolution: "jest-environment-jsdom@npm:29.7.0" + dependencies: + "@jest/environment": "npm:^29.7.0" + "@jest/fake-timers": "npm:^29.7.0" + "@jest/types": "npm:^29.6.3" + "@types/jsdom": "npm:^20.0.0" + "@types/node": "npm:*" + jest-mock: "npm:^29.7.0" + jest-util: "npm:^29.7.0" + jsdom: "npm:^20.0.0" + peerDependencies: + canvas: ^2.5.0 + peerDependenciesMeta: + canvas: + optional: true + checksum: 23bbfc9bca914baef4b654f7983175a4d49b0f515a5094ebcb8f819f28ec186f53c0ba06af1855eac04bab1457f4ea79dae05f70052cf899863e8096daa6e0f5 + languageName: node + linkType: hard + "jest-environment-node@npm:^29.7.0": version: 29.7.0 resolution: "jest-environment-node@npm:29.7.0" @@ -9252,6 +9500,45 @@ __metadata: languageName: node linkType: hard +"jsdom@npm:^20.0.0": + version: 20.0.3 + resolution: "jsdom@npm:20.0.3" + dependencies: + abab: "npm:^2.0.6" + acorn: "npm:^8.8.1" + acorn-globals: "npm:^7.0.0" + cssom: "npm:^0.5.0" + cssstyle: "npm:^2.3.0" + data-urls: "npm:^3.0.2" + decimal.js: "npm:^10.4.2" + domexception: "npm:^4.0.0" + escodegen: "npm:^2.0.0" + form-data: "npm:^4.0.0" + html-encoding-sniffer: "npm:^3.0.0" + http-proxy-agent: "npm:^5.0.0" + https-proxy-agent: "npm:^5.0.1" + is-potential-custom-element-name: "npm:^1.0.1" + nwsapi: "npm:^2.2.2" + parse5: "npm:^7.1.1" + saxes: "npm:^6.0.0" + symbol-tree: "npm:^3.2.4" + tough-cookie: "npm:^4.1.2" + w3c-xmlserializer: "npm:^4.0.0" + webidl-conversions: "npm:^7.0.0" + whatwg-encoding: "npm:^2.0.0" + whatwg-mimetype: "npm:^3.0.0" + whatwg-url: "npm:^11.0.0" + ws: "npm:^8.11.0" + xml-name-validator: "npm:^4.0.0" + peerDependencies: + canvas: ^2.5.0 + peerDependenciesMeta: + canvas: + optional: true + checksum: a4cdcff5b07eed87da90b146b82936321533b5efe8124492acf7160ebd5b9cf2b3c2435683592bf1cffb479615245756efb6c173effc1906f845a86ed22af985 + languageName: node + linkType: hard + "jsesc@npm:^2.5.1": version: 2.5.2 resolution: "jsesc@npm:2.5.2" @@ -9645,6 +9932,22 @@ __metadata: languageName: node linkType: hard +"mime-db@npm:1.52.0": + version: 1.52.0 + resolution: "mime-db@npm:1.52.0" + checksum: 54bb60bf39e6f8689f6622784e668a3d7f8bed6b0d886f5c3c446cb3284be28b30bf707ed05d0fe44a036f8469976b2629bbea182684977b084de9da274694d7 + languageName: node + linkType: hard + +"mime-types@npm:^2.1.35": + version: 2.1.35 + resolution: "mime-types@npm:2.1.35" + dependencies: + mime-db: "npm:1.52.0" + checksum: 89aa9651b67644035de2784a6e665fc685d79aba61857e02b9c8758da874a754aed4a9aced9265f5ed1171fd934331e5516b84a7f0218031b6fa0270eca1e51a + languageName: node + linkType: hard + "mimic-fn@npm:^1.0.0": version: 1.2.0 resolution: "mimic-fn@npm:1.2.0" @@ -10007,6 +10310,13 @@ __metadata: languageName: node linkType: hard +"nwsapi@npm:^2.2.2": + version: 2.2.28 + resolution: "nwsapi@npm:2.2.28" + checksum: 2395c1d894d2a11c7299c92f62e51849b6a02256d48a9a40c64a40e32ca06b188145cd984256a3134a6930794623abf9d7df9ab9f31dd63f471d1f999efb4830 + languageName: node + linkType: hard + "object-inspect@npm:^1.13.3": version: 1.13.4 resolution: "object-inspect@npm:1.13.4" @@ -10304,6 +10614,15 @@ __metadata: languageName: node linkType: hard +"parse5@npm:^7.0.0, parse5@npm:^7.1.1": + version: 7.3.0 + resolution: "parse5@npm:7.3.0" + dependencies: + entities: "npm:^6.0.0" + checksum: b0e48be20b820c655b138b86fa6fb3a790de6c891aa2aba536524f8027b4dca4fe538f11a0e5cf2f6f847d120dbb9e4822dcaeb933ff1e10850a2ef0154d1d88 + languageName: node + linkType: hard + "path-browserify@npm:^1.0.1": version: 1.0.1 resolution: "path-browserify@npm:1.0.1" @@ -11336,7 +11655,16 @@ __metadata: languageName: node linkType: hard -"punycode@npm:^2.1.0": +"psl@npm:^1.1.33": + version: 1.15.0 + resolution: "psl@npm:1.15.0" + dependencies: + punycode: "npm:^2.3.1" + checksum: 5e7467eb5196eb7900d156783d12907d445c0122f76c73203ce96b148a6ccf8c5450cc805887ffada38ff92d634afcf33720c24053cb01d5b6598d1c913c5caf + languageName: node + linkType: hard + +"punycode@npm:^2.1.0, punycode@npm:^2.1.1, punycode@npm:^2.3.1": version: 2.3.1 resolution: "punycode@npm:2.3.1" checksum: febdc4362bead22f9e2608ff0171713230b57aff9dddc1c273aa2a651fbd366f94b7d6a71d78342a7c0819906750351ca7f2edd26ea41b626d87d6a13d1bd059 @@ -11359,6 +11687,13 @@ __metadata: languageName: node linkType: hard +"querystringify@npm:^2.1.1": + version: 2.2.0 + resolution: "querystringify@npm:2.2.0" + checksum: 46ab16f252fd892fc29d6af60966d338cdfeea68a231e9457631ffd22d67cec1e00141e0a5236a2eb16c0d7d74175d9ec1d6f963660c6f2b1c2fc85b194c5680 + languageName: node + linkType: hard + "queue-microtask@npm:^1.2.2": version: 1.2.3 resolution: "queue-microtask@npm:1.2.3" @@ -11506,6 +11841,13 @@ __metadata: languageName: node linkType: hard +"requires-port@npm:^1.0.0": + version: 1.0.0 + resolution: "requires-port@npm:1.0.0" + checksum: 878880ee78ccdce372784f62f52a272048e2d0827c29ae31e7f99da18b62a2b9463ea03a75f277352f4697c100183debb0532371ad515a2d49d4bfe596dd4c20 + languageName: node + linkType: hard + "resolve-cwd@npm:^3.0.0": version: 3.0.0 resolution: "resolve-cwd@npm:3.0.0" @@ -11903,6 +12245,15 @@ __metadata: languageName: node linkType: hard +"saxes@npm:^6.0.0": + version: 6.0.0 + resolution: "saxes@npm:6.0.0" + dependencies: + xmlchars: "npm:^2.2.0" + checksum: 97b50daf6ca3a153e89842efa18a862e446248296622b7473c169c84c823ee8a16e4a43bac2f73f11fc8cb9168c73fbb0d73340f26552bac17970e9052367aa9 + languageName: node + linkType: hard + "semver@npm:^6.3.0, semver@npm:^6.3.1": version: 6.3.1 resolution: "semver@npm:6.3.1" @@ -12524,6 +12875,13 @@ __metadata: languageName: node linkType: hard +"symbol-tree@npm:^3.2.4": + version: 3.2.4 + resolution: "symbol-tree@npm:3.2.4" + checksum: c09a00aadf279d47d0c5c46ca3b6b2fbaeb45f0a184976d599637d412d3a70bbdc043ff33effe1206dea0e36e0ad226cb957112e7ce9a4bf2daedf7fa4f85c53 + languageName: node + linkType: hard + "synckit@npm:^0.9.1": version: 0.9.2 resolution: "synckit@npm:0.9.2" @@ -12615,6 +12973,27 @@ __metadata: languageName: node linkType: hard +"tough-cookie@npm:^4.1.2": + version: 4.1.4 + resolution: "tough-cookie@npm:4.1.4" + dependencies: + psl: "npm:^1.1.33" + punycode: "npm:^2.1.1" + universalify: "npm:^0.2.0" + url-parse: "npm:^1.5.3" + checksum: 75663f4e2cd085f16af0b217e4218772adf0617fb3227171102618a54ce0187a164e505d61f773ed7d65988f8ff8a8f935d381f87da981752c1171b076b4afac + languageName: node + linkType: hard + +"tr46@npm:^3.0.0": + version: 3.0.0 + resolution: "tr46@npm:3.0.0" + dependencies: + punycode: "npm:^2.1.1" + checksum: b09a15886cbfaee419a3469081223489051ce9dca3374dd9500d2378adedbee84a3c73f83bfdd6bb13d53657753fc0d4e20a46bfcd3f1b9057ef528426ad7ce4 + languageName: node + linkType: hard + "tree-kill@npm:^1.2.2, tree-kill@npm:~1.2.2": version: 1.2.2 resolution: "tree-kill@npm:1.2.2" @@ -13000,6 +13379,13 @@ __metadata: languageName: node linkType: hard +"universalify@npm:^0.2.0": + version: 0.2.0 + resolution: "universalify@npm:0.2.0" + checksum: e86134cb12919d177c2353196a4cc09981524ee87abf621f7bc8d249dbbbebaec5e7d1314b96061497981350df786e4c5128dbf442eba104d6e765bc260678b5 + languageName: node + linkType: hard + "update-browserslist-db@npm:^1.1.1": version: 1.1.3 resolution: "update-browserslist-db@npm:1.1.3" @@ -13037,6 +13423,16 @@ __metadata: languageName: node linkType: hard +"url-parse@npm:^1.5.3": + version: 1.5.10 + resolution: "url-parse@npm:1.5.10" + dependencies: + querystringify: "npm:^2.1.1" + requires-port: "npm:^1.0.0" + checksum: c9e96bc8c5b34e9f05ddfeffc12f6aadecbb0d971b3cc26015b58d5b44676a99f50d5aeb1e5c9e61fa4d49961ae3ab1ae997369ed44da51b2f5ac010d188e6ad + languageName: node + linkType: hard + "util-deprecate@npm:^1.0.1, util-deprecate@npm:^1.0.2": version: 1.0.2 resolution: "util-deprecate@npm:1.0.2" @@ -13279,6 +13675,15 @@ __metadata: languageName: node linkType: hard +"w3c-xmlserializer@npm:^4.0.0": + version: 4.0.0 + resolution: "w3c-xmlserializer@npm:4.0.0" + dependencies: + xml-name-validator: "npm:^4.0.0" + checksum: 9a00c412b5496f4f040842c9520bc0aaec6e0c015d06412a91a723cd7d84ea605ab903965f546b4ecdb3eae267f5145ba08565222b1d6cb443ee488cda9a0aee + languageName: node + linkType: hard + "walker@npm:^1.0.8": version: 1.0.8 resolution: "walker@npm:1.0.8" @@ -13304,6 +13709,39 @@ __metadata: languageName: node linkType: hard +"webidl-conversions@npm:^7.0.0": + version: 7.0.0 + resolution: "webidl-conversions@npm:7.0.0" + checksum: 4c4f65472c010eddbe648c11b977d048dd96956a625f7f8b9d64e1b30c3c1f23ea1acfd654648426ce5c743c2108a5a757c0592f02902cf7367adb7d14e67721 + languageName: node + linkType: hard + +"whatwg-encoding@npm:^2.0.0": + version: 2.0.0 + resolution: "whatwg-encoding@npm:2.0.0" + dependencies: + iconv-lite: "npm:0.6.3" + checksum: 162d712d88fd134a4fe587e53302da812eb4215a1baa4c394dfd86eff31d0a079ff932c05233857997de07481093358d6e7587997358f49b8a580a777be22089 + languageName: node + linkType: hard + +"whatwg-mimetype@npm:^3.0.0": + version: 3.0.0 + resolution: "whatwg-mimetype@npm:3.0.0" + checksum: 96f9f628c663c2ae05412c185ca81b3df54bcb921ab52fe9ebc0081c1720f25d770665401eb2338ab7f48c71568133845638e18a81ed52ab5d4dcef7d22b40ef + languageName: node + linkType: hard + +"whatwg-url@npm:^11.0.0": + version: 11.0.0 + resolution: "whatwg-url@npm:11.0.0" + dependencies: + tr46: "npm:^3.0.0" + webidl-conversions: "npm:^7.0.0" + checksum: dfcd51c6f4bfb54685528fb10927f3fd3d7c809b5671beef4a8cdd7b1408a7abf3343a35bc71dab83a1424f1c1e92cc2700d7930d95d231df0fac361de0c7648 + languageName: node + linkType: hard + "which-boxed-primitive@npm:^1.1.0, which-boxed-primitive@npm:^1.1.1": version: 1.1.1 resolution: "which-boxed-primitive@npm:1.1.1" @@ -13462,6 +13900,21 @@ __metadata: languageName: node linkType: hard +"ws@npm:^8.11.0": + version: 8.22.1 + resolution: "ws@npm:8.22.1" + peerDependencies: + bufferutil: ^4.0.1 + utf-8-validate: ">=5.0.2" + peerDependenciesMeta: + bufferutil: + optional: true + utf-8-validate: + optional: true + checksum: e4f596344d279e391702c541f7ef09d3b4ad3ac10914024d9a21cc8710ee5ca7cff0b9d10cd0b215282c75d0b054d5b2c8fb4d9a4c73f0495b3a15fcbfad76bf + languageName: node + linkType: hard + "ws@npm:^8.18.1": version: 8.18.1 resolution: "ws@npm:8.18.1" @@ -13484,6 +13937,13 @@ __metadata: languageName: node linkType: hard +"xmlchars@npm:^2.2.0": + version: 2.2.0 + resolution: "xmlchars@npm:2.2.0" + checksum: 4ad5924974efd004a47cce6acf5c0269aee0e62f9a805a426db3337af7bcbd331099df174b024ace4fb18971b8a56de386d2e73a1c4b020e3abd63a4a9b917f1 + languageName: node + linkType: hard + "y18n@npm:^4.0.0": version: 4.0.3 resolution: "y18n@npm:4.0.3"