bookish-press 0.4.47 → 0.4.49

package/models/chapter/FormatNode.test.d.ts

@@ -0,0 +1 @@
+export {};

package/models/chapter/FormatNode.test.js

@@ -0,0 +1,96 @@
+import { test, expect } from 'vitest';
+import FormatNode from './FormatNode';
+import TextNode from './TextNode';
+test('Bold first two characters', () => {
+    const text = new TextNode('Hello');
+    const format = new FormatNode('', [text]);
+    expect(format
+        .withFormat({
+        start: { node: text, index: 0 },
+        end: { node: text, index: 2 },
+    }, '*')
+        ?.toBookdown()).toBe('*He*llo');
+});
+test('Unbold word', () => {
+    const text = new TextNode('Hello');
+    const format = new FormatNode('', [new FormatNode('*', [text])]);
+    expect(format
+        .withFormat({
+        start: { node: text, index: 0 },
+        end: { node: text, index: 5 },
+    }, '')
+        ?.toBookdown()).toBe('Hello');
+});
+test('Bold single caret position', () => {
+    const text = new TextNode('Hello');
+    const format = new FormatNode('', [text]);
+    expect(format
+        .withFormat({
+        start: { node: text, index: 2 },
+        end: { node: text, index: 2 },
+    }, '*')
+        ?.toBookdown()).toBe('He**llo');
+});
+test('Delete first two characters', () => {
+    const text = new TextNode('Hello');
+    const format = new FormatNode('', [text]);
+    expect(format
+        .withoutRange({
+        start: { node: text, index: 0 },
+        end: { node: text, index: 2 },
+    })
+        ?.toBookdown()).toBe('llo');
+});
+test('Delete characters crossing format boundary', () => {
+    const text = new TextNode('He');
+    const bolded = new TextNode('ll');
+    const format = new FormatNode('', [
+        text,
+        new FormatNode('*', [bolded]),
+        new TextNode('o'),
+    ]);
+    expect(format
+        .withoutRange({
+        start: { node: text, index: 1 },
+        end: { node: bolded, index: 1 },
+    })
+        ?.toBookdown()).toBe('H*l*o');
+});
+test('Split', () => {
+    const text = new TextNode('This is my paragraph. It is two sentences.');
+    const indexAfterPeriod = text.getText().indexOf('.') + 1;
+    const caret = { node: text, index: indexAfterPeriod };
+    const format = new FormatNode('', [text]);
+    expect(format
+        .split(caret)
+        ?.map((t) => t.toBookdown())
+        .join('THEN')).toBe('This is my paragraph.THEN It is two sentences.');
+});
+test('Backspace/delete', () => {
+    const first = new TextNode('Hello, my name is ');
+    const second = new TextNode('Amy');
+    const third = new TextNode('.');
+    const format = new FormatNode('', [
+        first,
+        new FormatNode('*', [second]),
+        third,
+    ]);
+    expect(format
+        .withoutCharacter({ node: first, index: 5 }, false)
+        ?.root.toBookdown()).toBe('Hell, my name is *Amy*.');
+    expect(format
+        .withoutCharacter({ node: first, index: 5 }, true)
+        ?.root.toBookdown()).toBe('Hello my name is *Amy*.');
+    expect(format
+        .withoutCharacter({ node: second, index: 0 }, false)
+        ?.root.toBookdown()).toBe('Hello, my name is*Amy*.');
+    expect(format
+        .withoutCharacter({ node: second, index: 0 }, true)
+        ?.root.toBookdown()).toBe('Hello, my name is *my*.');
+    expect(format
+        .withoutCharacter({ node: first, index: 0 }, false)
+        ?.root.toBookdown()).toBeUndefined();
+    expect(format
+        .withoutCharacter({ node: third, index: 1 }, true)
+        ?.root.toBookdown()).toBeUndefined();
+});

package/models/chapter/InlineCodeNode.d.ts

@@ -0,0 +1,12 @@
+import MetadataNode from './MetadataNode';
+import TextNode from './TextNode';
+export default class InlineCodeNode extends MetadataNode<string> {
+    constructor(code?: TextNode, language?: string);
+    getType(): string;
+    toText(): string;
+    toHTML(): string;
+    toBookdown(): string;
+    copy(): this;
+    withMeta(meta: string): MetadataNode<string>;
+    withText(text: TextNode): MetadataNode<string>;
+}

package/{src/lib/models/chapter/InlineCodeNode.ts → models/chapter/InlineCodeNode.js}

@@ -1,39 +1,31 @@
 import MetadataNode from './MetadataNode';
 import TextNode from './TextNode';
-
-export default class InlineCodeNode extends MetadataNode<string> {
-    constructor(code?: TextNode, language: string = 'plaintext') {
+export default class InlineCodeNode extends MetadataNode {
+    constructor(code, language = 'plaintext') {
         super(code === undefined ? new TextNode() : code, language);
     }
-
     getType() {
         return 'inline-code';
     }
-
-    toText(): string {
+    toText() {
         return this.getText().getText();
     }
     toHTML() {
         return `<code>${this.getMeta()}</code>`;
     }
-
-    toBookdown(): string {
-        return (
-            '`' +
+    toBookdown() {
+        return ('`' +
             this.getText().toBookdown().replace(/`/g, '\\`') +
             '`' +
-            (this.getMeta() === 'plaintext' ? '' : this.getMeta())
-        );
+            (this.getMeta() === 'plaintext' ? '' : this.getMeta()));
     }
-
     copy() {
-        return new InlineCodeNode(this.getText(), this.getMeta()) as this;
+        return new InlineCodeNode(this.getText(), this.getMeta());
     }
-
-    withMeta(meta: string): MetadataNode<string> {
+    withMeta(meta) {
         return new InlineCodeNode(this.getText(), meta);
     }
-    withText(text: TextNode): MetadataNode<string> {
+    withText(text) {
         return new InlineCodeNode(text, this.getMeta());
     }
 }

package/models/chapter/LabelNode.d.ts

@@ -0,0 +1,17 @@
+import AtomNode from './AtomNode';
+import type Caret from './Caret';
+import type FormatNode from './FormatNode';
+import type Node from './Node';
+export default class LabelNode extends AtomNode<string> {
+    constructor(newID: string);
+    getType(): string;
+    getDefaultCaret(): Caret;
+    toText(): string;
+    toHTML(): string;
+    toBookdown(format?: FormatNode): string;
+    getParentOf(): Node | undefined;
+    copy(): this;
+    withMeta(newID: string): LabelNode;
+    withChildReplaced(): undefined;
+    withContentInRange(): this | undefined;
+}

package/{src/lib/models/chapter/LabelNode.ts → models/chapter/LabelNode.js}

@@ -1,56 +1,40 @@
 import AtomNode from './AtomNode';
-import type Caret from './Caret';
-import type FormatNode from './FormatNode';
-import type Node from './Node';
-
 const ERROR_PLACEHOLDER = 'LABELNOIDERROR';
-
-export default class LabelNode extends AtomNode<string> {
-    constructor(newID: string) {
+export default class LabelNode extends AtomNode {
+    constructor(newID) {
         super(newID === ERROR_PLACEHOLDER ? '' : newID);
     }
-
     getType() {
         return 'label';
     }
-
-    getDefaultCaret(): Caret {
+    getDefaultCaret() {
         return { node: this, index: 0 };
     }
-
-    toText(): string {
+    toText() {
         return '';
     }
     toHTML() {
         return '';
     }
-
-    toBookdown(format?: FormatNode): string {
+    toBookdown(format) {
         const id = this.getMeta();
         const nextText = format?.getNextTextOrAtom(this)?.toBookdown();
-
         // The trailing space after enables parsing. The error placeholder handles invalid empty label IDs.
-        return `:${id === '' ? ERROR_PLACEHOLDER : id}${
-            nextText?.startsWith(' ') ? '' : ' '
-        }`;
+        return `:${id === '' ? ERROR_PLACEHOLDER : id}${nextText?.startsWith(' ') ? '' : ' '}`;
     }
-
-    getParentOf(): Node | undefined {
+    getParentOf() {
         return undefined;
     }
-
     copy() {
-        return new LabelNode(this.getMeta()) as this;
+        return new LabelNode(this.getMeta());
     }
-
-    withMeta(newID: string) {
+    withMeta(newID) {
         return new LabelNode(newID);
     }
     withChildReplaced() {
         return undefined;
     }
-
-    withContentInRange(): this | undefined {
+    withContentInRange() {
         return this.copy();
     }
 }

package/models/chapter/LinkNode.d.ts

@@ -0,0 +1,12 @@
+import MetadataNode from './MetadataNode';
+import TextNode from './TextNode';
+export default class LinkNode extends MetadataNode<string> {
+    constructor(text?: TextNode, url?: string);
+    getType(): string;
+    toText(): string;
+    toHTML(): string;
+    toBookdown(): string;
+    copy(): this;
+    withMeta(meta: string): MetadataNode<string>;
+    withText(text: TextNode): MetadataNode<string>;
+}

package/{src/lib/models/chapter/LinkNode.ts → models/chapter/LinkNode.js}

@@ -1,33 +1,28 @@
 import MetadataNode from './MetadataNode';
 import TextNode from './TextNode';
-
-export default class LinkNode extends MetadataNode<string> {
-    constructor(text?: TextNode, url: string = '') {
+export default class LinkNode extends MetadataNode {
+    constructor(text, url = '') {
         super(text === undefined ? new TextNode() : text, url);
     }
-
     getType() {
         return 'link';
     }
-
-    toText(): string {
+    toText() {
         return this.getText().toText();
     }
     toHTML() {
         return `<a href="${this.getMeta()}">${this.getText().toHTML()}</a>`;
     }
-    toBookdown(): string {
+    toBookdown() {
         return `[${this.getText().toBookdown()}|${this.getMeta()}]`;
     }
-
     copy() {
-        return new LinkNode(this.getText(), this.getMeta()) as this;
+        return new LinkNode(this.getText(), this.getMeta());
     }
-
-    withMeta(meta: string): MetadataNode<string> {
+    withMeta(meta) {
         return new LinkNode(this.getText(), meta);
     }
-    withText(text: TextNode): MetadataNode<string> {
+    withText(text) {
         return new LinkNode(text, this.getMeta());
     }
 }

package/models/chapter/ListNode.d.ts

@@ -0,0 +1,51 @@
+import type Node from './Node';
+import FormatNode from './FormatNode';
+import type { Format } from './FormatNode';
+import type Caret from './Caret';
+import { type CaretRange } from './Caret';
+import BlockNode from './BlockNode';
+import type Edit from './Edit';
+export type ListNodeType = FormatNode | ListNode;
+export default class ListNode extends BlockNode {
+    #private;
+    constructor(items: Array<FormatNode | ListNode>, numbered: boolean);
+    getType(): string;
+    isNumbered(): boolean;
+    isEmpty(): boolean;
+    getItems(): ListNodeType[];
+    getChildren(): ListNodeType[];
+    getListItems(): ListNode[];
+    getLength(): number;
+    getLastItem(): FormatNode | undefined;
+    getFirstItem(): FormatNode | undefined;
+    getFormats(): FormatNode[];
+    getFirstLastItem(first: boolean): FormatNode | undefined;
+    getLevel(root: Node): number;
+    toText(): string;
+    toBookdown(level?: number): string;
+    toHTML(): string;
+    getParentOf(node: Node): Node | undefined;
+    atBeginningOfItem(root: Node, caret: Caret): boolean;
+    getItemContaining(caret: Caret): number | undefined;
+    getItem(index: number): ListNodeType | undefined;
+    getFirstCaret(): Caret | undefined;
+    copy(): this;
+    withStyle(numbered: boolean): ListNode;
+    withItemAppended(item: ListNodeType): ListNode;
+    withItemPrepended(item: ListNodeType): ListNode;
+    withItemAt(item: ListNodeType, index: number): ListNode | undefined;
+    withItemAfter(item: ListNodeType, anchor: ListNodeType): ListNode | undefined;
+    withItemBefore(item: ListNodeType, anchor: ListNodeType): ListNode | undefined;
+    withItemReplaced(index: number, item: ListNodeType): ListNode | undefined;
+    withoutItemAt(index: number): ListNode | undefined;
+    withoutItem(item: FormatNode): ListNode | undefined;
+    withListAppended(list: ListNode): ListNode;
+    withItemMergedBackwards(index: number): [ListNode, Caret] | undefined;
+    withItemSplit(caret: Caret): ListNode | undefined;
+    withItemIndented(format: FormatNode): ListNode | undefined;
+    withItemUnindented(format: FormatNode): ListNode | undefined;
+    withChildReplaced(node: ListNodeType, replacement: ListNodeType | undefined): this | undefined;
+    withContentInRange(range: CaretRange): this | undefined;
+    withNodeInserted(caret: Caret, node: Node): Edit;
+    withRangeFormatted(range: CaretRange, format: Format | undefined): Edit;
+}