@adecore/editor 0.39.0 → 0.40.0

package/src/pointer.ts

@@ -82,6 +82,7 @@ function overshoot(value: number, low: number, high: number): number {
     if (value < low) {
         return value - low;
     }
+
     return value > high ? value - high : 0;
 }
 
@@ -107,6 +108,7 @@ export class PointerSelection {
         const head = this.host.offsetAt(event.clientX, event.clientY);
         const selections = model.getSelections();
         const base = event.altKey && area === 'text' ? selections : [];
+
         this.drag = {
             id: event.pointerId,
             anchor: event.shiftKey && !event.altKey ? model.getPrimary().anchor : head,
@@ -120,17 +122,23 @@ export class PointerSelection {
             x: event.clientX,
             y: event.clientY
         };
+
         this.host.focus();
         viewport.setPointerCapture?.(event.pointerId);
+
         // Alt on a caret that is there takes it away; there is no selection to drag after that.
         if (area === 'text' && event.altKey && count === 1 && selections.length > 1 && selections.some((selection) => selection.head === head)) {
             model.setSelections(selections.filter((selection) => selection.head !== head));
             this.drag = undefined;
+
             return;
         }
+
         const selected = count === 1 && area === 'text' && !event.shiftKey && !event.altKey ? this.host.selectionAt(event.clientX, event.clientY) : null;
+
         if (selected !== null) {
             this.drag.unit = 'drop';
+
             this.drag.carry = {
                 from: Math.min(selected.anchor, selected.head),
                 to: Math.max(selected.anchor, selected.head),
@@ -146,6 +154,7 @@ export class PointerSelection {
             this.selectUnit('line', this.host.lineAt(head), base);
         } else if (count === 2) {
             const word = model.wordSelectionAt(head, this.host.camelHumps());
+
             if (word === null) {
                 this.update();
             } else {
@@ -154,6 +163,7 @@ export class PointerSelection {
         } else {
             this.update();
         }
+
         if (this.drag && this.frame === undefined) {
             this.frame = viewport.ownerDocument.defaultView?.requestAnimationFrame?.(() => this.autoScroll());
         }
@@ -163,11 +173,14 @@ export class PointerSelection {
     private pressLineNumber(event: PointerEvent, offset: number): void {
         const { model } = this.host;
         const primary = model.getPrimary();
+
         if (event.shiftKey && primary.anchor !== primary.head) {
             model.setSelections([this.tweakedByLines(primary, offset)]);
             this.drag = undefined;
+
             return;
         }
+
         this.selectUnit('line', this.host.lineAt(offset), []);
     }
 
@@ -175,6 +188,7 @@ export class PointerSelection {
         if (this.drag === undefined) {
             return;
         }
+
         this.drag.unit = unit;
         this.drag.saved = saved;
         this.drag.selections = base;
@@ -189,33 +203,43 @@ export class PointerSelection {
         const first = host.visualLine(from);
         const last = host.visualLine(to - 1);
         const clicked = host.visualLine(offset);
+
         if (clicked.y < first.y) {
             return { anchor: to, head: clicked.start };
         }
+
         if (clicked.y > last.y) {
             return { anchor: from, head: clicked.end };
         }
+
         if (first.y === last.y) {
             return { anchor: selection.head, head: selection.head };
         }
+
         if (selection.anchor === to) {
             const line = clicked.y === first.y ? host.visualLine(first.next) : clicked;
+
             return { anchor: to, head: line.start };
         }
+
         const line = clicked.y === last.y ? host.visualLine(last.start - 1) : clicked;
+
         return { anchor: from, head: line.end };
     }
 
     /* Pointer events carry no click count, so the presses are counted here. */
     private countClick(event: PointerEvent): number {
         const last = this.lastPress;
+
         const repeated =
             last !== undefined &&
             event.timeStamp - last.time <= MULTI_CLICK_MS &&
             Math.abs(event.clientX - last.x) <= MULTI_CLICK_DISTANCE &&
             Math.abs(event.clientY - last.y) <= MULTI_CLICK_DISTANCE;
+
         const count = repeated ? Math.min(3, last.count + 1) : 1;
         this.lastPress = { time: event.timeStamp, x: event.clientX, y: event.clientY, count };
+
         return count;
     }
 
@@ -223,6 +247,7 @@ export class PointerSelection {
         if (!this.drag || event.pointerId !== this.drag.id) {
             return;
         }
+
         this.drag.x = event.clientX;
         this.drag.y = event.clientY;
         this.update();
@@ -232,18 +257,24 @@ export class PointerSelection {
     end(event?: PointerEvent): void {
         const { viewport } = this.host;
         const carry = this.drag?.carry;
+
         if (this.drag) {
             viewport.releasePointerCapture?.(this.drag.id);
         }
+
         this.drag = undefined;
         this.cancelFrame();
+
         if (carry === undefined) {
             return;
         }
+
         this.host.setDropCaret(null);
+
         if (event?.type === 'pointercancel') {
             return;
         }
+
         if (!carry.active) {
             this.host.model.setSelections([{ anchor: carry.pressOffset, head: carry.pressOffset }]);
         } else if (carry.target !== null && event !== undefined) {
@@ -257,8 +288,10 @@ export class PointerSelection {
             if (Math.abs(drag.x - carry.startX) < CARRY_THRESHOLD && Math.abs(drag.y - carry.startY) < CARRY_THRESHOLD) {
                 return;
             }
+
             carry.active = true;
         }
+
         const offset = this.host.offsetAt(drag.x, drag.y);
         carry.target = offset >= carry.from && offset <= carry.to ? null : offset;
         this.host.setDropCaret(carry.target);
@@ -273,6 +306,7 @@ export class PointerSelection {
         if (this.frame !== undefined) {
             this.host.viewport.ownerDocument.defaultView?.cancelAnimationFrame?.(this.frame);
         }
+
         this.frame = undefined;
     }
 
@@ -280,17 +314,23 @@ export class PointerSelection {
         if (!this.drag) {
             return;
         }
+
         if (this.drag.carry !== undefined) {
             this.updateCarry(this.drag, this.drag.carry);
+
             return;
         }
+
         if (this.drag.box && this.drag.unit === 'character') {
             const box = this.host.columnSelections(this.drag.anchorPoint, this.host.contentPoint(this.drag.x, this.drag.y));
+
             if (box) {
                 this.host.model.setSelections(this.drag.keep ? [...this.drag.selections, ...box] : box);
+
                 return;
             }
         }
+
         const head = this.host.offsetAt(this.drag.x, this.drag.y);
         const { anchor, target } = this.reach(this.drag, head);
         this.host.model.setSelections([...(this.drag.add ? this.drag.selections : []), { anchor, head: target }]);
@@ -300,35 +340,45 @@ export class PointerSelection {
     private reach(drag: Drag, head: number): { anchor: number; target: number } {
         const { model } = this.host;
         const backwards = head < drag.saved.from;
+
         if (drag.unit === 'word') {
             const camel = this.host.camelHumps();
+
             return backwards
                 ? { anchor: drag.saved.to, target: model.wordStartBefore(head, camel) }
                 : { anchor: drag.saved.from, target: model.wordEndAfter(head, camel) };
         }
+
         if (drag.unit === 'line') {
             const line = this.host.visualLine(head);
+
             return backwards ? { anchor: drag.saved.to, target: line.start } : { anchor: drag.saved.from, target: line.next };
         }
+
         return { anchor: drag.anchor, target: head };
     }
 
     /* Holding the pointer past an edge of the view keeps scrolling that way. */
     private autoScroll(): void {
         const { viewport } = this.host;
+
         if (!this.drag) {
             this.frame = undefined;
+
             return;
         }
+
         const rect = viewport.getBoundingClientRect();
         const dy = overshoot(this.drag.y, rect.top, rect.bottom);
         const dx = overshoot(this.drag.x, rect.left, rect.right);
+
         if (dy || dx) {
             viewport.scrollTop += Math.max(-SCROLL_STEP, Math.min(SCROLL_STEP, dy));
             viewport.scrollLeft += Math.max(-SCROLL_STEP, Math.min(SCROLL_STEP, dx));
             this.host.scrolled();
             this.update();
         }
+
         this.frame = viewport.ownerDocument.defaultView?.requestAnimationFrame?.(() => this.autoScroll());
     }
 }

package/src/scroll-animation.ts

@@ -13,6 +13,7 @@ const FULL_LINES = 11;
 export function scrollDuration(distance: number, lineHeight: number): number {
     const lines = distance / lineHeight;
     const part = Math.min(1, Math.max(0, (lines - FREE_LINES) / (FULL_LINES - FREE_LINES)));
+
     return Math.round(part * SCROLL_DURATION_MS);
 }
 
@@ -21,28 +22,37 @@ export function easeOut(fraction: number): number {
     if (fraction <= 0) {
         return 0;
     }
+
     if (fraction >= 1) {
         return 1;
     }
+
     const x1 = 0;
     const y1 = 0;
     const x2 = 0.58;
     const y2 = 1;
+
     const bezier = (t: number, a: number, b: number): number => 3 * (1 - t) * (1 - t) * t * a + 3 * (1 - t) * t * t * b + t * t * t;
+
     let low = 0;
     let high = 1;
     let t = fraction;
+
     for (let step = 0; step < 24; step++) {
         const x = bezier(t, x1, x2);
+
         if (Math.abs(x - fraction) < 1e-5) {
             break;
         }
+
         if (x < fraction) {
             low = t;
         } else {
             high = t;
         }
+
         t = (low + high) / 2;
     }
+
     return bezier(t, y1, y2);
 }

package/src/scroll.ts

@@ -43,6 +43,7 @@ function clamp(value: number, maximum: number): number {
 function centerOf(request: ScrollRequest): number {
     const { target, view, lineHeight, topBound } = request;
     const third = target.y - Math.trunc(view.height / 3);
+
     return third < topBound ? third : target.y - Math.trunc(Math.max(0, view.height - lineHeight) / 2);
 }
 
@@ -53,6 +54,7 @@ function verticalPosition(request: ScrollRequest, kind: ScrollKind): number {
     const above = view.y > topBound;
     const below = view.y + height < bottomBound;
     let position = view.y;
+
     if (kind === 'center') {
         position = center;
     } else if (kind === 'centerUp') {
@@ -70,7 +72,9 @@ function verticalPosition(request: ScrollRequest, kind: ScrollKind): number {
         const highest = target.y - height < 0 ? 0 : bottomBound - height;
         position = Math.min(topBound, Math.max(highest, view.y));
     }
+
     const inset = request.inset ?? 0;
+
     return Math.min(Math.max(inset, position), Math.max(inset, content.height - height));
 }
 
@@ -80,6 +84,7 @@ function horizontalPosition(request: ScrollRequest, kind: ScrollKind): number {
     const left = target.x - SIDE_MARGIN * charWidth;
     const right = target.x + SIDE_MARGIN * charWidth;
     let position = view.x;
+
     if (right - left > width) {
         position = target.x - Math.trunc(width / 2);
     } else if (left < view.x) {
@@ -87,6 +92,7 @@ function horizontalPosition(request: ScrollRequest, kind: ScrollKind): number {
     } else if (right > view.x + width) {
         position = right - width;
     }
+
     return clamp(position, content.width - width);
 }
 
@@ -95,6 +101,7 @@ export function scrollPosition(request: ScrollRequest, kind: ScrollKind): { x: n
     const { target, view } = request;
     const inView = target.x >= view.x && target.x < view.x + view.width && target.y >= view.y && target.y < view.y + view.height;
     const effective: ScrollKind = request.refrain && inView && (kind === 'center' || kind === 'centerDown' || kind === 'centerUp') ? 'relative' : kind;
+
     return {
         x: request.horizontal ? horizontalPosition(request, effective) : view.x,
         y: verticalPosition(request, effective) - (request.inset ?? 0)

package/src/search-client.ts

@@ -62,6 +62,7 @@ function validateSearch(snapshot: EditorSearchSnapshot, query: EditorFindQuery,
     const from = options.from ?? 0;
     const to = options.to ?? snapshot.text.length;
     const maximum = options.maxResults ?? SEARCH_LIMIT;
+
     if (
         !Number.isSafeInteger(snapshot.revision) ||
         snapshot.revision < 0 ||
@@ -73,12 +74,15 @@ function validateSearch(snapshot: EditorSearchSnapshot, query: EditorFindQuery,
     ) {
         throw new EditorSearchError('range', 'Search bounds and revision must identify the current document.');
     }
+
     if (!Number.isInteger(maximum) || maximum < 0 || maximum > SEARCH_LIMIT) {
         throw new EditorSearchError('range', `Search results must be limited to ${SEARCH_LIMIT} matches or fewer.`);
     }
+
     if (options.deadline !== undefined && (!Number.isFinite(options.deadline) || options.deadline <= 0 || options.deadline > 2147483647)) {
         throw new EditorSearchError('range', 'A request deadline must fit a positive browser timer.');
     }
+
     if (query.regex) {
         try {
             // Compilation reports syntax errors without executing the expression on the page.
@@ -92,11 +96,13 @@ function validateSearch(snapshot: EditorSearchSnapshot, query: EditorFindQuery,
 function splitsSurrogate(text: string, offset: number): boolean {
     const previous = text.charCodeAt(offset - 1),
         current = text.charCodeAt(offset);
+
     return previous >= 0xd800 && previous <= 0xdbff && current >= 0xdc00 && current <= 0xdfff;
 }
 
 export function createSearchClient(options: EditorSearchClientOptions): EditorSearchClient {
     let revision: number | undefined;
+
     const transport = createWorkerRequestClient<EditorSearchInput, Exclude<EditorSearchOutput, { type: 'ready' }>>({
         ...options,
         accepts: (reply, input) => reply.revision === input.revision,
@@ -108,12 +114,14 @@ export function createSearchClient(options: EditorSearchClientOptions): EditorSe
             const { text, ...rest } = input;
             const message = { ...rest, ...(revision !== input.revision ? { text } : {}) };
             revision = input.revision;
+
             return message;
         },
         stopped: () => {
             revision = undefined;
         }
     });
+
     const run = <Result>(
         snapshot: EditorSearchSnapshot,
         query: EditorFindQuery,
@@ -131,6 +139,7 @@ export function createSearchClient(options: EditorSearchClientOptions): EditorSe
                 if (reply.type === 'error') {
                     throw new EditorSearchError(reply.kind, reply.message);
                 }
+
                 return read(reply);
             })
             .catch((error) => {
@@ -141,6 +150,7 @@ export function createSearchClient(options: EditorSearchClientOptions): EditorSe
                       : new EditorSearchError('error', error instanceof Error ? error.message : String(error));
             });
     };
+
     return {
         search(snapshot, query, bounds = {}) {
             return run(
@@ -160,6 +170,7 @@ export function createSearchClient(options: EditorSearchClientOptions): EditorSe
                     if (reply.type !== 'matches') {
                         throw new EditorSearchError('error', 'The worker returned an unexpected search response.');
                     }
+
                     return { revision: reply.revision, ranges: reply.ranges, limited: reply.limited };
                 }
             );
@@ -167,7 +178,9 @@ export function createSearchClient(options: EditorSearchClientOptions): EditorSe
         match(snapshot, query, range) {
             const from = range.from,
                 to = range.to;
+
             const text = snapshot.text;
+
             return run(
                 snapshot,
                 query,
@@ -177,12 +190,15 @@ export function createSearchClient(options: EditorSearchClientOptions): EditorSe
                     if (reply.type !== 'match') {
                         throw new EditorSearchError('error', 'The worker returned an unexpected match response.');
                     }
+
                     if (reply.match === null) {
                         return null;
                     }
+
                     if (reply.match.from !== from || reply.match.to !== to) {
                         throw new EditorSearchError('error', 'The worker returned a different match range.');
                     }
+
                     return { ...reply.match, text: text.slice(from, to), revision: reply.revision };
                 }
             );
@@ -197,7 +213,9 @@ export function createSearchClient(options: EditorSearchClientOptions): EditorSe
                     if (reply.type !== 'next') {
                         throw new EditorSearchError('error', 'The worker returned an unexpected cursor response.');
                     }
+
                     const range = reply.range;
+
                     if (
                         range !== null &&
                         (!Number.isInteger(range.from) ||
@@ -210,6 +228,7 @@ export function createSearchClient(options: EditorSearchClientOptions): EditorSe
                     ) {
                         throw new EditorSearchError('error', 'The worker returned invalid cursor bounds.');
                     }
+
                     return range;
                 }
             );
@@ -218,6 +237,7 @@ export function createSearchClient(options: EditorSearchClientOptions): EditorSe
             const { from, to, preserveCase } = options;
             const maxEdits = options.maxEdits ?? 1000;
             const maxCharacters = options.maxCharacters ?? MAX_REPLACEMENT_CHARACTERS;
+
             return run(
                 snapshot,
                 query,
@@ -239,15 +259,19 @@ export function createSearchClient(options: EditorSearchClientOptions): EditorSe
                     if (reply.type !== 'replacements') {
                         throw new EditorSearchError('error', 'The worker returned an unexpected replacement response.');
                     }
+
                     if (reply.ranges.length % 3 !== 0 || reply.ranges.length / 3 > maxEdits || reply.text.length > maxCharacters) {
                         throw new EditorSearchError('error', 'The worker returned an invalid replacement page.');
                     }
+
                     let characters = 0;
                     let previous = from ?? 0;
                     let previousEmpty = false;
+
                     for (let index = 0; index < reply.ranges.length; index += 3) {
                         const start = reply.ranges[index]!,
                             end = reply.ranges[index + 1]!;
+
                         if (
                             start < previous ||
                             (previousEmpty && start === previous) ||
@@ -258,25 +282,33 @@ export function createSearchClient(options: EditorSearchClientOptions): EditorSe
                         ) {
                             throw new EditorSearchError('error', 'The worker returned invalid replacement bounds.');
                         }
+
                         previous = end;
                         previousEmpty = start === end;
                         characters += reply.ranges[index + 2]!;
                     }
+
                     if (characters !== reply.text.length) {
                         throw new EditorSearchError('error', 'The worker returned inconsistent replacement lengths.');
                     }
+
                     if (reply.next !== null) {
                         const index = reply.ranges.length - 3;
+
                         if (index < 0) {
                             throw new EditorSearchError('error', 'The worker returned an empty replacement continuation.');
                         }
+
                         const start = reply.ranges[index],
                             end = reply.ranges[index + 1];
+
                         const resume = end! + (start === end ? ((snapshot.text.codePointAt(end!) ?? 0) > 0xffff ? 2 : 1) : 0);
+
                         if (reply.next !== resume || reply.next > (to ?? snapshot.text.length)) {
                             throw new EditorSearchError('error', 'The worker returned an invalid replacement continuation.');
                         }
                     }
+
                     return { revision: reply.revision, ranges: reply.ranges, text: reply.text, next: reply.next };
                 },
                 () => {

package/src/search-worker.ts

@@ -9,6 +9,7 @@ import {
 } from './search-protocol.ts';
 
 export { createSearchClient, EditorSearchError, type EditorSearchClient, type EditorSearchClientOptions, type EditorSearchErrorKind } from './search-client.ts';
+
 export type {
     EditorSearchInput,
     EditorSearchOptions,
@@ -36,15 +37,19 @@ function findOptions(request: EditorSearchInput): FindOptions {
 
 function captureMatch(found: FindMatch) {
     let characters = 0;
+
     for (const value of found.captures) {
         characters += value?.length ?? 0;
     }
+
     for (const value of Object.values(found.groups ?? {})) {
         characters += value?.length ?? 0;
     }
+
     if (characters > MAX_CAPTURE_CHARACTERS) {
         throw new RangeError('Search captures exceed the response size limit.');
     }
+
     return { from: found.from, to: found.to, captures: found.captures, groups: found.groups, regex: found.regex };
 }
 
@@ -52,28 +57,37 @@ function searchReply(request: EditorSearchInput, snapshot: EditorSearchSnapshot)
     const { text } = snapshot;
     const options = findOptions(request);
     const header = { id: request.id, revision: request.revision };
+
     if (request.type === 'next') {
         let found: FindMatch | null = null;
+
         if (request.backwards) {
             let last: FindMatch | null = null;
+
             for (const match of iterateMatches(text, request.query.text, request.revision, options)) {
                 last = match;
+
                 if (match.from < request.offset) {
                     found = match;
                 } else if (found !== null || request.wrap === false) {
                     break;
                 }
             }
+
             found ??= request.wrap === false ? null : last;
         } else {
             found = findMatchFrom(text, request.query.text, request.revision, request.offset, { ...options, wrap: request.wrap });
         }
+
         return { type: 'next', ...header, range: found === null ? null : { from: found.from, to: found.to } };
     }
+
     if (request.type === 'match') {
         const found = iterateMatches(text, request.query.text, request.revision, { ...options, maxResults: 1 }).next().value;
+
         return { type: 'match', ...header, match: found && found.from === request.from && found.to === request.to ? captureMatch(found) : null };
     }
+
     if (request.type === 'replacements') {
         if (
             !Number.isInteger(request.maxEdits) ||
@@ -85,58 +99,77 @@ function searchReply(request: EditorSearchInput, snapshot: EditorSearchSnapshot)
         ) {
             throw new RangeError('Replacement pages need a positive edit limit and a bounded character limit.');
         }
+
         const ranges: number[] = [],
             pieces: string[] = [];
+
         let characters = 0;
         let resume = request.from ?? 0;
         let next: number | null = null;
+
         for (const match of iterateMatches(text, request.query.text, request.revision, { ...options, maxResults: request.maxEdits + 1 })) {
             if (pieces.length === request.maxEdits) {
                 next = resume;
+
                 break;
             }
+
             const replacement = replacementText(text, match, request.replacement, false, request.preserveCase, request.maxCharacters);
+
             if (characters + replacement.length > request.maxCharacters) {
                 if (pieces.length === 0) {
                     throw new RangeError('One replacement exceeds the response size limit.');
                 }
+
                 next = resume;
+
                 break;
             }
+
             characters += replacement.length;
             ranges.push(match.from, match.to, replacement.length);
             pieces.push(replacement);
             // Resuming after an empty match must skip the same full code point as the matcher.
             resume = match.to + (match.from === match.to ? ((text.codePointAt(match.to) ?? 0) > 0xffff ? 2 : 1) : 0);
         }
+
         return { type: 'replacements', ...header, ranges: Uint32Array.from(ranges), text: pieces.join(''), next };
     }
+
     if (!Number.isInteger(request.maxResults) || request.maxResults < 0 || request.maxResults > SEARCH_LIMIT) {
         throw new RangeError(`Search results must be limited to ${SEARCH_LIMIT} matches or fewer.`);
     }
+
     const offsets: number[] = [];
     let limited = false;
+
     for (const match of iterateMatches(text, request.query.text, request.revision, { ...options, maxResults: request.maxResults + 1 })) {
         if (offsets.length === request.maxResults * 2) {
             limited = true;
+
             break;
         }
+
         offsets.push(match.from, match.to);
     }
+
     return { type: 'matches', ...header, ranges: Uint32Array.from(offsets), limited };
 }
 
 /* A running RegExp can only be interrupted by terminating its worker. */
 export function serveEditorSearch(endpoint: EditorSearchWorkerEndpoint): () => void {
     let snapshot: EditorSearchSnapshot | undefined;
+
     const listener = ({ data: request }: MessageEvent<EditorSearchInput>): void => {
         try {
             if (!Number.isSafeInteger(request.revision) || request.revision < 0) {
                 throw new RangeError('The search revision must be a nonnegative safe integer.');
             }
+
             if (request.text !== undefined) {
                 snapshot = { revision: request.revision, text: request.text };
             }
+
             if (snapshot === undefined || snapshot.revision !== request.revision) {
                 endpoint.postMessage({
                     type: 'error',
@@ -145,9 +178,12 @@ export function serveEditorSearch(endpoint: EditorSearchWorkerEndpoint): () => v
                     kind: 'snapshot',
                     message: 'The search worker needs the text of this revision.'
                 });
+
                 return;
             }
+
             const response = searchReply(request, snapshot);
+
             endpoint.postMessage(
                 response,
                 response.type === 'matches' || response.type === 'replacements' ? { transfer: [response.ranges.buffer] } : undefined
@@ -162,8 +198,10 @@ export function serveEditorSearch(endpoint: EditorSearchWorkerEndpoint): () => v
             });
         }
     };
+
     endpoint.addEventListener('message', listener);
     endpoint.postMessage({ type: 'ready' });
+
     return () => {
         endpoint.removeEventListener('message', listener);
         snapshot = undefined;