@knodes/typedoc-pluginutils/src/current-page-memo.ts

A set of utilities for TypeDoc plugins

import assert from 'assert';

import { isNil } from 'lodash';
import { Application, PageEvent, Reflection } from 'typedoc';

import { ApplicationAccessor, getApplication } from './base-plugin';

export class CurrentPageMemo {
	private static readonly _applications = new WeakMap<Application, CurrentPageMemo>();
	private _currentPage?: PageEvent<Reflection>;
	private _initialized = false;
	public get initialized(){
		return this._initialized;
	}

	/**
	 * Get the instance for the given plugin.
	 *
	 * @param applicationAccessor - The application accessor to get memo for.
	 * @returns the plugin page memo
	 */
	public static for( applicationAccessor: ApplicationAccessor ){
		const application = getApplication( applicationAccessor );
		const e = this._applications.get( application ) ?? new CurrentPageMemo( application );
		this._applications.set( application, e );
		return e;
	}

	private constructor( public readonly application: Application ){}

	/**
	 * Start watching for pages event.
	 */
	public initialize(){
		if( this._initialized ){
			return;
		}
		this._initialized = true;
		this.application.renderer.on( PageEvent.BEGIN, ( e: PageEvent<Reflection> ) => this._currentPage = e );
		this.application.renderer.on( PageEvent.END, () => this._currentPage = undefined );
	}

	/**
	 * Set the current page as being the {@link pageOrModel} while running the {@link callback}. The current page is restored afterwards no matter what.
	 *
	 * @param pageOrModel - The page to set.
	 * @param callback - The function to execute.
	 * @returns the {@link callback} return value.
	 */
	public fakeWrapPage<T, Model extends Reflection>( pageOrModel: PageEvent<Model> | Model, callback: () => T ): T {
		let newPage: PageEvent<Reflection>;
		if( pageOrModel instanceof PageEvent ){
			newPage = pageOrModel as any;
		} else {
			newPage = new PageEvent( PageEvent.BEGIN );
			newPage.model = pageOrModel;
		}
		const bck = this._currentPage;
		this._currentPage = newPage;
		try {
			return callback();
		} finally {
			this._currentPage = bck;
		}
	}

	public get currentPage(): PageEvent<Reflection> {
		assert( this._currentPage );
		assert( this._currentPage.model instanceof Reflection );
		return this._currentPage;
	}

	public get currentReflection(): Reflection {
		return this.currentPage.model;
	}

	public get hasCurrent(): boolean {
		return !isNil( this._currentPage );
	}
}