Skip to content

Modern Docker Management, Designed for Everyone

3.7 KB
Raw Blame
import { MergeView } from '@codemirror/merge';
import { Compartment, EditorState, type Extension } from '@codemirror/state';
import { EditorView } from '@codemirror/view';
import { untrack } from 'svelte';
import type { Attachment } from 'svelte/attachments';

import type { CodeLanguage } from './analysis/types';

export type MergeAttachmentParams = {
	diffActive: boolean;
	language: CodeLanguage;
	value: string;
	baseline: string;
};

type CreateMergeHostAttachmentOptions = {
	getTheme: () => Extension;
	getLanguageExtension: (lang: CodeLanguage, options?: { lightweight?: boolean }) => Extension[];
	getReadonlyLanguageExtension: (lang: CodeLanguage) => Extension[];
	onValueChange: (nextValue: string) => void;
	onPrimaryViewReady: (view: EditorView) => void;
};

export function createMergeHostAttachment(
	options: CreateMergeHostAttachmentOptions,
	getParams: () => MergeAttachmentParams
): Attachment<HTMLDivElement> {
	const { getTheme, getLanguageExtension, getReadonlyLanguageExtension, onValueChange, onPrimaryViewReady } = options;

	return (node) => {
		let currentParams = untrack(getParams);
		let currentMergeView: MergeView | null = null;
		const themeCompartmentA = new Compartment();
		const themeCompartmentB = new Compartment();

		const destroyCurrentMergeView = () => {
			if (!currentMergeView) return;
			currentMergeView.destroy();
			currentMergeView = null;
		};

		const createCurrentMergeView = () => {
			if (!currentParams.diffActive || currentMergeView) return;

			const theme = untrack(getTheme);
			const readonlyExtension = [EditorState.readOnly.of(true), EditorView.editable.of(false), themeCompartmentB.of(theme)];

			currentMergeView = new MergeView({
				parent: node,
				a: {
					doc: currentParams.value,
					extensions: [
						...getLanguageExtension(currentParams.language, { lightweight: true }),
						themeCompartmentA.of(theme),
						EditorView.updateListener.of((update) => {
							if (update.docChanged) {
								onValueChange(update.state.doc.toString());
							}
						})
					]
				},
				b: {
					doc: currentParams.baseline,
					extensions: [...getReadonlyLanguageExtension(currentParams.language), ...readonlyExtension]
				}
			});

			onPrimaryViewReady(currentMergeView.a);
		};

		const syncCurrentMergeView = () => {
			if (!currentMergeView || !currentParams.diffActive) return;

			const currentLeft = currentMergeView.a.state.doc.toString();
			if (currentLeft !== currentParams.value) {
				currentMergeView.a.dispatch({
					changes: {
						from: 0,
						to: currentMergeView.a.state.doc.length,
						insert: currentParams.value
					}
				});
			}

			const currentRight = currentMergeView.b.state.doc.toString();
			if (currentRight !== currentParams.baseline) {
				currentMergeView.b.dispatch({
					changes: {
						from: 0,
						to: currentMergeView.b.state.doc.length,
						insert: currentParams.baseline
					}
				});
			}
		};

		const applyParams = (nextParams: MergeAttachmentParams) => {
			const mustRecreate = Boolean(currentMergeView && nextParams.language !== currentParams.language);
			currentParams = nextParams;

			if (!currentParams.diffActive) {
				destroyCurrentMergeView();
				return;
			}

			if (mustRecreate) {
				destroyCurrentMergeView();
			}

			createCurrentMergeView();
			syncCurrentMergeView();
		};

		untrack(() => applyParams(currentParams));

		$effect(() => {
			const nextParams = getParams();
			untrack(() => applyParams(nextParams));
		});

		$effect(() => {
			const theme = getTheme();
			untrack(() => {
				if (!currentMergeView) return;
				currentMergeView.a.dispatch({ effects: themeCompartmentA.reconfigure(theme) });
				currentMergeView.b.dispatch({ effects: themeCompartmentB.reconfigure(theme) });
			});
		});

		return destroyCurrentMergeView;
	};
}