all changes

2025-12-23 16:49:58 +01:00 · 2024-08-29 08:41:45 +10:00
parent 33a95bc1a9
commit 4205db0147
19 changed files with 1438 additions and 129 deletions
--- a/src/insert-footnote-command.ts
+++ b/src/insert-footnote-command.ts
@@ -0,0 +1,102 @@
+import { Command, type Element, type RootElement, type Writer } from 'ckeditor5';
+
+import { ATTRIBUTES, ELEMENTS } from './constants.js';
+import { modelQueryElement } from './utils.js';
+
+export default class InsertFootnoteCommand extends Command {
+	/**
+   * Creates a footnote reference with the given index, and creates a matching
+   * footnote if one doesn't already exist. Also creates the footnote section
+   * if it doesn't exist. If `footnoteIndex` is 0 (or not provided), the added
+   * footnote is given the next unused index--e.g. 7, if 6 footnotes exist so far.
+   */
+	public override execute( { footnoteIndex }: { footnoteIndex?: number } = { footnoteIndex: 0 } ): void {
+		this.editor.model.enqueueChange( modelWriter => {
+			const doc = this.editor.model.document;
+			const rootElement = doc.getRoot();
+			if ( !rootElement ) {
+				return;
+			}
+			const footnoteSection = this._getFootnoteSection( modelWriter, rootElement );
+			let index: string | undefined = undefined;
+			let id: string | undefined = undefined;
+			if ( footnoteIndex === 0 ) {
+				index = `${ footnoteSection.maxOffset + 1 }`;
+				id = Math.random().toString( 36 ).slice( 2 );
+			} else {
+				index = `${ footnoteIndex }`;
+				const matchingFootnote = modelQueryElement(
+					this.editor,
+					footnoteSection,
+					element =>
+						element.is( 'element', ELEMENTS.footnoteItem ) && element.getAttribute( ATTRIBUTES.footnoteIndex ) === index
+				);
+				if ( matchingFootnote ) {
+					id = matchingFootnote.getAttribute( ATTRIBUTES.footnoteId ) as string;
+				}
+			}
+			if ( !id || !index ) {
+				return;
+			}
+			modelWriter.setSelection( doc.selection.getLastPosition() );
+			const footnoteReference = modelWriter.createElement( ELEMENTS.footnoteReference, {
+				[ ATTRIBUTES.footnoteId ]: id,
+				[ ATTRIBUTES.footnoteIndex ]: index
+			} );
+			this.editor.model.insertContent( footnoteReference );
+			modelWriter.setSelection( footnoteReference, 'after' );
+			// if referencing an existing footnote
+			if ( footnoteIndex !== 0 ) {
+				console.log( 'erroneous footnoteIndex' );
+				return;
+			}
+
+			console.log( 'we made it here' );
+			const footnoteContent = modelWriter.createElement( ELEMENTS.footnoteContent );
+			const footnoteItem = modelWriter.createElement( ELEMENTS.footnoteItem, {
+				[ ATTRIBUTES.footnoteId ]: id,
+				[ ATTRIBUTES.footnoteIndex ]: index
+			} );
+			const footnoteBackLink = modelWriter.createElement( ELEMENTS.footnoteBackLink, { [ ATTRIBUTES.footnoteId ]: id } );
+			const p = modelWriter.createElement( 'paragraph' );
+			modelWriter.append( p, footnoteContent );
+			modelWriter.append( footnoteContent, footnoteItem );
+			modelWriter.insert( footnoteBackLink, footnoteItem, 0 );
+			console.log( 'we made it here 1' );
+
+			this.editor.model.insertContent(
+				footnoteItem,
+				modelWriter.createPositionAt( footnoteSection, footnoteSection.maxOffset )
+			);
+			console.log( 'we made it here 2' );
+		} );
+	}
+
+	/**
+   * Called automatically when changes are applied to the document. Sets `isEnabled`
+   * to determine whether footnote creation is allowed at the current location.
+   */
+	public override refresh(): void {
+		const model = this.editor.model;
+		console.log( 'over here' );
+		const lastPosition = model.document.selection.getLastPosition();
+		const allowedIn = lastPosition && model.schema.findAllowedParent( lastPosition, ELEMENTS.footnoteSection );
+		this.isEnabled = allowedIn !== null;
+		console.log( 'now here' );
+	}
+
+	/**
+   * Returns the footnote section if it exists, or creates on if it doesn't.
+   */
+	private _getFootnoteSection( writer: Writer, rootElement: RootElement ): Element {
+		const footnoteSection = modelQueryElement( this.editor, rootElement, element =>
+			element.is( 'element', ELEMENTS.footnoteSection )
+		);
+		if ( footnoteSection ) {
+			return footnoteSection;
+		}
+		const newFootnoteSection = writer.createElement( ELEMENTS.footnoteSection );
+		this.editor.model.insertContent( newFootnoteSection, writer.createPositionAt( rootElement, rootElement.maxOffset ) );
+		return newFootnoteSection;
+	}
+}