scroll/src/common/document.ts

212 lines
4.7 KiB
JavaScript
Raw Normal View History

2023-11-21 15:14:08 -05:00
import Row from './row.ts';
import { arrayInsert, strlen } from './fns.ts';
import { HighlightType } from './highlight.ts';
import Option, { None, Some } from './option.ts';
import { getRuntime } from './runtime.ts';
2024-02-29 15:48:11 -05:00
import { Position } from './types.ts';
import { Search } from './search.ts';
2023-11-13 14:46:04 -05:00
export class Document {
#rows: Row[];
2024-02-28 15:44:57 -05:00
#search: Search;
2023-11-30 16:14:52 -05:00
/**
* Has the document been modified?
*/
public dirty: boolean;
2023-11-13 14:46:04 -05:00
private constructor() {
this.#rows = [];
2024-02-28 15:44:57 -05:00
this.#search = new Search();
2023-11-21 15:14:08 -05:00
this.dirty = false;
2023-11-13 14:46:04 -05:00
}
get numRows(): number {
2023-11-13 14:46:04 -05:00
return this.#rows.length;
}
public static default(): Document {
2024-02-29 15:48:11 -05:00
const self = new Document();
self.#search.parent = Some(self);
2024-02-29 15:48:11 -05:00
return self;
2023-11-13 14:46:04 -05:00
}
public isEmpty(): boolean {
return this.#rows.length === 0;
}
2024-02-29 14:24:22 -05:00
/**
* Open a file for editing
*/
public async open(filename: string): Promise<Document> {
const { file } = await getRuntime();
// Clear any existing rows
if (!this.isEmpty()) {
this.#rows = [];
}
2023-11-13 14:46:04 -05:00
const rawFile = await file.openFile(filename);
rawFile.split(/\r?\n/)
2023-11-22 17:09:41 -05:00
.forEach((row) => this.insertRow(this.numRows, row));
2023-11-13 14:46:04 -05:00
2023-11-21 15:14:08 -05:00
this.dirty = false;
return this;
2023-11-13 14:46:04 -05:00
}
2024-02-29 14:24:22 -05:00
/**
* Save the current document
*/
2024-07-02 16:27:18 -04:00
public async save(filename: string): Promise<void> {
2023-11-21 15:14:08 -05:00
const { file } = await getRuntime();
await file.saveFile(filename, this.rowsToString());
2023-11-21 15:14:08 -05:00
this.dirty = false;
}
2024-07-02 16:27:18 -04:00
public resetFind(): void {
2024-02-28 15:44:57 -05:00
this.#search = new Search();
this.#search.parent = Some(this);
2024-02-28 15:44:57 -05:00
}
2023-11-30 16:14:52 -05:00
public find(
q: string,
2024-02-28 15:44:57 -05:00
key: string,
): Option<Position> {
const possible = this.#search.search(q, key);
if (possible.isSome()) {
const potential = possible.unwrap();
// Update highlight of search match
const row = this.#rows[potential.y];
// Okay, we have to take the Javascript string index (potential.x), convert
// it to the Row 'character' index, and then convert that to the Row render index
// so that the highlighted color starts in the right place.
const start = row.cxToRx(row.byteIndexToCharIndex(potential.x));
// Just to be safe with unicode searches, take the number of 'characters'
// as the search query length, not the JS string length.
const end = start + strlen(q);
for (let i = start; i < end; i++) {
row.hl[i] = HighlightType.Match;
}
}
return possible;
2023-11-30 16:14:52 -05:00
}
2023-11-21 15:14:08 -05:00
public insert(at: Position, c: string): void {
if (at.y === this.numRows) {
2023-11-22 17:09:41 -05:00
this.insertRow(this.numRows, c);
2023-11-21 15:14:08 -05:00
} else {
this.#rows[at.y].insertChar(at.x, c);
this.#rows[at.y].update(None);
2023-11-21 15:14:08 -05:00
}
this.dirty = true;
}
2024-07-02 16:27:18 -04:00
/**
* Insert a new line, splitting and/or creating a new row as needed
*/
2023-11-22 17:09:41 -05:00
public insertNewline(at: Position): void {
if (at.y > this.numRows) {
return;
}
2024-07-02 16:27:18 -04:00
// Just add a simple blank line
2023-11-22 17:09:41 -05:00
if (at.y === this.numRows) {
this.#rows.push(Row.default());
2024-07-02 16:27:18 -04:00
this.dirty = true;
2023-11-22 17:09:41 -05:00
return;
}
2024-07-02 16:27:18 -04:00
// Split the current row, and insert a new
// row with the leftovers
2023-11-22 17:09:41 -05:00
const newRow = this.#rows[at.y].split(at.x);
newRow.update(None);
2023-11-22 17:09:41 -05:00
this.#rows = arrayInsert(this.#rows, at.y + 1, newRow);
this.dirty = true;
}
2024-02-29 14:24:22 -05:00
/**
* Remove a character from the document, merging
* adjacent lines if necessary
*/
2023-11-22 11:07:33 -05:00
public delete(at: Position): void {
const len = this.numRows;
if (at.y >= len) {
2023-11-22 11:07:33 -05:00
return;
}
const row = this.row(at.y)!;
2023-11-30 11:15:37 -05:00
const mergeNextRow = at.x === row.size && at.y + 1 < len;
const mergeIntoPrevRow = at.x === 0 && at.y > 0;
// If we are at the end of a line, and press delete,
// add the contents of the next row, and delete
// the merged row object
if (mergeNextRow) {
// At the end of a line, pressing delete will merge
// the next line into the current on
const rowToAppend = this.#rows.at(at.y + 1)!.toString();
row.append(rowToAppend);
this.deleteRow(at.y + 1);
} else if (mergeIntoPrevRow) {
// At the beginning of a line, merge the current line
// into the previous Row
const rowToAppend = row.toString();
this.#rows[at.y - 1].append(rowToAppend);
this.deleteRow(at.y);
} else {
row.delete(at.x);
}
row.update(None);
this.dirty = true;
2023-11-22 11:07:33 -05:00
}
public row(i: number): Row | null {
2023-11-20 14:21:42 -05:00
return this.#rows[i] ?? null;
2023-11-13 14:46:04 -05:00
}
2023-11-22 17:09:41 -05:00
public insertRow(at: number = this.numRows, s: string = ''): void {
this.#rows = arrayInsert(this.#rows, at, Row.from(s));
this.#rows[at].update(None);
2023-11-21 15:14:08 -05:00
this.dirty = true;
}
public highlight(searchMatch: Option<string>): void {
this.#rows.forEach((row) => {
row.update(searchMatch);
});
}
/**
* Delete the specified row
* @param at - the index of the row to delete
* @private
*/
private deleteRow(at: number): void {
this.#rows.splice(at, 1);
}
2023-11-22 17:09:41 -05:00
/**
* Convert the array of row objects into one string
* @private
*/
2023-11-21 15:14:08 -05:00
private rowsToString(): string {
return this.#rows.map((r) => r.toString()).join('\n');
}
2023-11-13 14:46:04 -05:00
}
export default Document;