monaco-editor11 1.1.1 → 1.1.2

package/dist/workers/diffEditorItemTemplate.js

@@ -0,0 +1,272 @@
+import { h } from '../../../../base/browser/dom.js';
+import { Button } from '../../../../base/browser/ui/button/button.js';
+import { Codicon } from '../../../../base/common/codicons.js';
+import { Disposable, DisposableStore } from '../../../../base/common/lifecycle.js';
+import '../../../../base/common/observableInternal/index.js';
+import { createActionViewItem } from '../../../../platform/actions/browser/menuEntryActionViewItem.js';
+import { MenuWorkbenchToolBar } from '../../../../platform/actions/browser/toolbar.js';
+import { MenuId } from '../../../../platform/actions/common/actions.js';
+import { IContextKeyService } from '../../../../platform/contextkey/common/contextkey.js';
+import { IInstantiationService } from '../../../../platform/instantiation/common/instantiation.js';
+import { ServiceCollection } from '../../../../platform/instantiation/common/serviceCollection.js';
+import { observableCodeEditor } from '../../observableCodeEditor.js';
+import { DiffEditorWidget } from '../diffEditor/diffEditorWidget.js';
+import { ActionRunnerWithContext } from './utils.js';
+import { globalTransaction } from '../../../../base/common/observableInternal/transaction.js';
+import { observableValue } from '../../../../base/common/observableInternal/observables/observableValue.js';
+import { derived } from '../../../../base/common/observableInternal/observables/derived.js';
+import { autorun } from '../../../../base/common/observableInternal/reactions/autorun.js';
+
+var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (undefined && undefined.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+class TemplateData {
+    constructor(viewModel, deltaScrollVertical) {
+        this.viewModel = viewModel;
+        this.deltaScrollVertical = deltaScrollVertical;
+    }
+    getId() {
+        return this.viewModel;
+    }
+}
+let DiffEditorItemTemplate = class DiffEditorItemTemplate extends Disposable {
+    constructor(_container, _overflowWidgetsDomNode, _workbenchUIElementFactory, _instantiationService, _parentContextKeyService) {
+        super();
+        this._container = _container;
+        this._overflowWidgetsDomNode = _overflowWidgetsDomNode;
+        this._workbenchUIElementFactory = _workbenchUIElementFactory;
+        this._instantiationService = _instantiationService;
+        this._viewModel = observableValue(this, undefined);
+        this._collapsed = derived(this, reader => this._viewModel.read(reader)?.collapsed.read(reader));
+        this._editorContentHeight = observableValue(this, 500);
+        this.contentHeight = derived(this, reader => {
+            const h = this._collapsed.read(reader) ? 0 : this._editorContentHeight.read(reader);
+            return h + this._outerEditorHeight;
+        });
+        this._modifiedContentWidth = observableValue(this, 0);
+        this._modifiedWidth = observableValue(this, 0);
+        this._originalContentWidth = observableValue(this, 0);
+        this._originalWidth = observableValue(this, 0);
+        this.maxScroll = derived(this, reader => {
+            const scroll1 = this._modifiedContentWidth.read(reader) - this._modifiedWidth.read(reader);
+            const scroll2 = this._originalContentWidth.read(reader) - this._originalWidth.read(reader);
+            if (scroll1 > scroll2) {
+                return { maxScroll: scroll1, width: this._modifiedWidth.read(reader) };
+            }
+            else {
+                return { maxScroll: scroll2, width: this._originalWidth.read(reader) };
+            }
+        });
+        this._elements = h('div.multiDiffEntry', [
+            h('div.header@header', [
+                h('div.header-content', [
+                    h('div.collapse-button@collapseButton'),
+                    h('div.file-path', [
+                        // eslint-disable-next-line local/code-no-any-casts, @typescript-eslint/no-explicit-any
+                        h('div.title.modified.show-file-icons@primaryPath', []),
+                        h('div.status.deleted@status', ['R']),
+                        // eslint-disable-next-line local/code-no-any-casts, @typescript-eslint/no-explicit-any
+                        h('div.title.original.show-file-icons@secondaryPath', []),
+                    ]),
+                    h('div.actions@actions'),
+                ]),
+            ]),
+            h('div.editorParent', [
+                h('div.editorContainer@editor'),
+            ])
+        ]);
+        this.editor = this._register(this._instantiationService.createInstance(DiffEditorWidget, this._elements.editor, {
+            overflowWidgetsDomNode: this._overflowWidgetsDomNode,
+            fixedOverflowWidgets: true
+        }, {}));
+        this.isModifedFocused = observableCodeEditor(this.editor.getModifiedEditor()).isFocused;
+        this.isOriginalFocused = observableCodeEditor(this.editor.getOriginalEditor()).isFocused;
+        this.isFocused = derived(this, reader => this.isModifedFocused.read(reader) || this.isOriginalFocused.read(reader));
+        this._resourceLabel = this._workbenchUIElementFactory.createResourceLabel
+            ? this._register(this._workbenchUIElementFactory.createResourceLabel(this._elements.primaryPath))
+            : undefined;
+        this._resourceLabel2 = this._workbenchUIElementFactory.createResourceLabel
+            ? this._register(this._workbenchUIElementFactory.createResourceLabel(this._elements.secondaryPath))
+            : undefined;
+        this._dataStore = this._register(new DisposableStore());
+        this._headerHeight = 40;
+        this._lastScrollTop = -1;
+        this._isSettingScrollTop = false;
+        const btn = new Button(this._elements.collapseButton, {});
+        this._register(autorun(reader => {
+            btn.element.className = '';
+            btn.icon = this._collapsed.read(reader) ? Codicon.chevronRight : Codicon.chevronDown;
+        }));
+        this._register(btn.onDidClick(() => {
+            this._viewModel.get()?.collapsed.set(!this._collapsed.get(), undefined);
+        }));
+        this._register(autorun(reader => {
+            this._elements.editor.style.display = this._collapsed.read(reader) ? 'none' : 'block';
+        }));
+        this._register(this.editor.getModifiedEditor().onDidLayoutChange(e => {
+            const width = this.editor.getModifiedEditor().getLayoutInfo().contentWidth;
+            this._modifiedWidth.set(width, undefined);
+        }));
+        this._register(this.editor.getOriginalEditor().onDidLayoutChange(e => {
+            const width = this.editor.getOriginalEditor().getLayoutInfo().contentWidth;
+            this._originalWidth.set(width, undefined);
+        }));
+        this._register(this.editor.onDidContentSizeChange(e => {
+            globalTransaction(tx => {
+                this._editorContentHeight.set(e.contentHeight, tx);
+                this._modifiedContentWidth.set(this.editor.getModifiedEditor().getContentWidth(), tx);
+                this._originalContentWidth.set(this.editor.getOriginalEditor().getContentWidth(), tx);
+            });
+        }));
+        this._register(this.editor.getOriginalEditor().onDidScrollChange(e => {
+            if (this._isSettingScrollTop) {
+                return;
+            }
+            if (!e.scrollTopChanged || !this._data) {
+                return;
+            }
+            const delta = e.scrollTop - this._lastScrollTop;
+            this._data.deltaScrollVertical(delta);
+        }));
+        this._register(autorun(reader => {
+            const isActive = this._viewModel.read(reader)?.isActive.read(reader);
+            this._elements.root.classList.toggle('active', isActive);
+        }));
+        this._container.appendChild(this._elements.root);
+        this._outerEditorHeight = this._headerHeight;
+        this._contextKeyService = this._register(_parentContextKeyService.createScoped(this._elements.actions));
+        const instantiationService = this._register(this._instantiationService.createChild(new ServiceCollection([IContextKeyService, this._contextKeyService])));
+        this._register(instantiationService.createInstance(MenuWorkbenchToolBar, this._elements.actions, MenuId.MultiDiffEditorFileToolbar, {
+            actionRunner: this._register(new ActionRunnerWithContext(() => (this._viewModel.get()?.modifiedUri ?? this._viewModel.get()?.originalUri))),
+            menuOptions: {
+                shouldForwardArgs: true,
+            },
+            toolbarOptions: { primaryGroup: g => g.startsWith('navigation') },
+            actionViewItemProvider: (action, options) => createActionViewItem(instantiationService, action, options),
+        }));
+    }
+    setScrollLeft(left) {
+        if (this._modifiedContentWidth.get() - this._modifiedWidth.get() > this._originalContentWidth.get() - this._originalWidth.get()) {
+            this.editor.getModifiedEditor().setScrollLeft(left);
+        }
+        else {
+            this.editor.getOriginalEditor().setScrollLeft(left);
+        }
+    }
+    setData(data) {
+        this._data = data;
+        function updateOptions(options) {
+            return {
+                ...options,
+                scrollBeyondLastLine: false,
+                hideUnchangedRegions: {
+                    enabled: true,
+                },
+                scrollbar: {
+                    vertical: 'hidden',
+                    horizontal: 'hidden',
+                    handleMouseWheel: false,
+                    useShadows: false,
+                },
+                renderOverviewRuler: false,
+                fixedOverflowWidgets: true,
+                overviewRulerBorder: false,
+            };
+        }
+        if (!data) {
+            globalTransaction(tx => {
+                this._viewModel.set(undefined, tx);
+                this.editor.setDiffModel(null, tx);
+                this._dataStore.clear();
+            });
+            return;
+        }
+        const value = data.viewModel.documentDiffItem;
+        globalTransaction(tx => {
+            this._resourceLabel?.setUri(data.viewModel.modifiedUri ?? data.viewModel.originalUri, { strikethrough: data.viewModel.modifiedUri === undefined });
+            let isRenamed = false;
+            let isDeleted = false;
+            let isAdded = false;
+            let flag = '';
+            if (data.viewModel.modifiedUri && data.viewModel.originalUri && data.viewModel.modifiedUri.path !== data.viewModel.originalUri.path) {
+                flag = 'R';
+                isRenamed = true;
+            }
+            else if (!data.viewModel.modifiedUri) {
+                flag = 'D';
+                isDeleted = true;
+            }
+            else if (!data.viewModel.originalUri) {
+                flag = 'A';
+                isAdded = true;
+            }
+            this._elements.status.classList.toggle('renamed', isRenamed);
+            this._elements.status.classList.toggle('deleted', isDeleted);
+            this._elements.status.classList.toggle('added', isAdded);
+            this._elements.status.innerText = flag;
+            this._resourceLabel2?.setUri(isRenamed ? data.viewModel.originalUri : undefined, { strikethrough: true });
+            this._dataStore.clear();
+            this._viewModel.set(data.viewModel, tx);
+            this.editor.setDiffModel(data.viewModel.diffEditorViewModelRef, tx);
+            this.editor.updateOptions(updateOptions(value.options ?? {}));
+        });
+        if (value.onOptionsDidChange) {
+            this._dataStore.add(value.onOptionsDidChange(() => {
+                this.editor.updateOptions(updateOptions(value.options ?? {}));
+            }));
+        }
+        data.viewModel.isAlive.recomputeInitiallyAndOnChange(this._dataStore, value => {
+            if (!value) {
+                this.setData(undefined);
+            }
+        });
+        if (data.viewModel.documentDiffItem.contextKeys) {
+            for (const [key, value] of Object.entries(data.viewModel.documentDiffItem.contextKeys)) {
+                this._contextKeyService.createKey(key, value);
+            }
+        }
+    }
+    render(verticalRange, width, editorScroll, viewPort) {
+        this._elements.root.style.visibility = 'visible';
+        this._elements.root.style.top = `${verticalRange.start}px`;
+        this._elements.root.style.height = `${verticalRange.length}px`;
+        this._elements.root.style.width = `${width}px`;
+        this._elements.root.style.position = 'absolute';
+        // For sticky scroll
+        const maxDelta = verticalRange.length - this._headerHeight;
+        const delta = Math.max(0, Math.min(viewPort.start - verticalRange.start, maxDelta));
+        this._elements.header.style.transform = `translateY(${delta}px)`;
+        globalTransaction(tx => {
+            this.editor.layout({
+                width: width - 2 * 8 - 2 * 1,
+                height: verticalRange.length - this._outerEditorHeight,
+            });
+        });
+        try {
+            this._isSettingScrollTop = true;
+            this._lastScrollTop = editorScroll;
+            this.editor.getOriginalEditor().setScrollTop(editorScroll);
+        }
+        finally {
+            this._isSettingScrollTop = false;
+        }
+        this._elements.header.classList.toggle('shadow', delta > 0 || editorScroll > 0);
+        this._elements.header.classList.toggle('collapsed', delta === maxDelta);
+    }
+    hide() {
+        this._elements.root.style.top = `-100000px`;
+        this._elements.root.style.visibility = 'hidden'; // Some editor parts are still visible
+    }
+};
+DiffEditorItemTemplate = __decorate([
+    __param(3, IInstantiationService),
+    __param(4, IContextKeyService)
+], DiffEditorItemTemplate);
+
+export { DiffEditorItemTemplate, TemplateData };

package/dist/workers/diffEditorOptions.js

@@ -0,0 +1,152 @@
+import '../../../../base/common/observableInternal/index.js';
+import { IAccessibilityService } from '../../../../platform/accessibility/common/accessibility.js';
+import { diffEditorDefaultOptions } from '../../../common/config/diffEditor.js';
+import { boolean, clampedInt, stringSet, clampedFloat } from '../../../common/config/editorOptions.js';
+import { allowsTrueInlineDiffRendering } from './components/diffEditorViewZones/diffEditorViewZones.js';
+import { derivedConstOnceDefined } from '../../../../base/common/observableInternal/experimental/utils.js';
+import { observableValue } from '../../../../base/common/observableInternal/observables/observableValue.js';
+import { observableFromEvent } from '../../../../base/common/observableInternal/observables/observableFromEvent.js';
+import { derived } from '../../../../base/common/observableInternal/observables/derived.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+var __decorate = (undefined && undefined.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __param = (undefined && undefined.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+let DiffEditorOptions = class DiffEditorOptions {
+    get editorOptions() { return this._options; }
+    constructor(options, _accessibilityService) {
+        this._accessibilityService = _accessibilityService;
+        this._diffEditorWidth = observableValue(this, 0);
+        this._screenReaderMode = observableFromEvent(this, this._accessibilityService.onDidChangeScreenReaderOptimized, () => this._accessibilityService.isScreenReaderOptimized());
+        this.couldShowInlineViewBecauseOfSize = derived(this, reader => this._options.read(reader).renderSideBySide && this._diffEditorWidth.read(reader) <= this._options.read(reader).renderSideBySideInlineBreakpoint);
+        this.renderOverviewRuler = derived(this, reader => this._options.read(reader).renderOverviewRuler);
+        this.renderSideBySide = derived(this, reader => {
+            if (this.compactMode.read(reader)) {
+                if (this.shouldRenderInlineViewInSmartMode.read(reader)) {
+                    return false;
+                }
+            }
+            return this._options.read(reader).renderSideBySide
+                && !(this._options.read(reader).useInlineViewWhenSpaceIsLimited && this.couldShowInlineViewBecauseOfSize.read(reader) && !this._screenReaderMode.read(reader));
+        });
+        this.readOnly = derived(this, reader => this._options.read(reader).readOnly);
+        this.shouldRenderOldRevertArrows = derived(this, reader => {
+            if (!this._options.read(reader).renderMarginRevertIcon) {
+                return false;
+            }
+            if (!this.renderSideBySide.read(reader)) {
+                return false;
+            }
+            if (this.readOnly.read(reader)) {
+                return false;
+            }
+            if (this.shouldRenderGutterMenu.read(reader)) {
+                return false;
+            }
+            return true;
+        });
+        this.shouldRenderGutterMenu = derived(this, reader => this._options.read(reader).renderGutterMenu);
+        this.renderIndicators = derived(this, reader => this._options.read(reader).renderIndicators);
+        this.enableSplitViewResizing = derived(this, reader => this._options.read(reader).enableSplitViewResizing);
+        this.splitViewDefaultRatio = derived(this, reader => this._options.read(reader).splitViewDefaultRatio);
+        this.ignoreTrimWhitespace = derived(this, reader => this._options.read(reader).ignoreTrimWhitespace);
+        this.maxComputationTimeMs = derived(this, reader => this._options.read(reader).maxComputationTime);
+        this.showMoves = derived(this, reader => this._options.read(reader).experimental.showMoves && this.renderSideBySide.read(reader));
+        this.isInEmbeddedEditor = derived(this, reader => this._options.read(reader).isInEmbeddedEditor);
+        this.diffWordWrap = derived(this, reader => this._options.read(reader).diffWordWrap);
+        this.originalEditable = derived(this, reader => this._options.read(reader).originalEditable);
+        this.diffCodeLens = derived(this, reader => this._options.read(reader).diffCodeLens);
+        this.accessibilityVerbose = derived(this, reader => this._options.read(reader).accessibilityVerbose);
+        this.diffAlgorithm = derived(this, reader => this._options.read(reader).diffAlgorithm);
+        this.showEmptyDecorations = derived(this, reader => this._options.read(reader).experimental.showEmptyDecorations);
+        this.onlyShowAccessibleDiffViewer = derived(this, reader => this._options.read(reader).onlyShowAccessibleDiffViewer);
+        this.compactMode = derived(this, reader => this._options.read(reader).compactMode);
+        this.trueInlineDiffRenderingEnabled = derived(this, reader => this._options.read(reader).experimental.useTrueInlineView);
+        this.useTrueInlineDiffRendering = derived(this, reader => !this.renderSideBySide.read(reader) && this.trueInlineDiffRenderingEnabled.read(reader));
+        this.hideUnchangedRegions = derived(this, reader => this._options.read(reader).hideUnchangedRegions.enabled);
+        this.hideUnchangedRegionsRevealLineCount = derived(this, reader => this._options.read(reader).hideUnchangedRegions.revealLineCount);
+        this.hideUnchangedRegionsContextLineCount = derived(this, reader => this._options.read(reader).hideUnchangedRegions.contextLineCount);
+        this.hideUnchangedRegionsMinimumLineCount = derived(this, reader => this._options.read(reader).hideUnchangedRegions.minimumLineCount);
+        this._model = observableValue(this, undefined);
+        this.shouldRenderInlineViewInSmartMode = this._model
+            .map(this, model => derivedConstOnceDefined(this, reader => {
+            const diffs = model?.diff.read(reader);
+            return diffs ? isSimpleDiff(diffs, this.trueInlineDiffRenderingEnabled.read(reader)) : undefined;
+        }))
+            .flatten()
+            .map(this, v => !!v);
+        this.inlineViewHideOriginalLineNumbers = this.compactMode;
+        const optionsCopy = { ...options, ...validateDiffEditorOptions(options, diffEditorDefaultOptions) };
+        this._options = observableValue(this, optionsCopy);
+    }
+    updateOptions(changedOptions) {
+        const newDiffEditorOptions = validateDiffEditorOptions(changedOptions, this._options.get());
+        const newOptions = { ...this._options.get(), ...changedOptions, ...newDiffEditorOptions };
+        this._options.set(newOptions, undefined, { changedOptions: changedOptions });
+    }
+    setWidth(width) {
+        this._diffEditorWidth.set(width, undefined);
+    }
+    setModel(model) {
+        this._model.set(model, undefined);
+    }
+};
+DiffEditorOptions = __decorate([
+    __param(1, IAccessibilityService)
+], DiffEditorOptions);
+function isSimpleDiff(diff, supportsTrueDiffRendering) {
+    return diff.mappings.every(m => isInsertion(m.lineRangeMapping) || isDeletion(m.lineRangeMapping) || (supportsTrueDiffRendering && allowsTrueInlineDiffRendering(m.lineRangeMapping)));
+}
+function isInsertion(mapping) {
+    return mapping.original.length === 0;
+}
+function isDeletion(mapping) {
+    return mapping.modified.length === 0;
+}
+function validateDiffEditorOptions(options, defaults) {
+    return {
+        enableSplitViewResizing: boolean(options.enableSplitViewResizing, defaults.enableSplitViewResizing),
+        splitViewDefaultRatio: clampedFloat(options.splitViewDefaultRatio, 0.5, 0.1, 0.9),
+        renderSideBySide: boolean(options.renderSideBySide, defaults.renderSideBySide),
+        renderMarginRevertIcon: boolean(options.renderMarginRevertIcon, defaults.renderMarginRevertIcon),
+        maxComputationTime: clampedInt(options.maxComputationTime, defaults.maxComputationTime, 0, 1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */),
+        maxFileSize: clampedInt(options.maxFileSize, defaults.maxFileSize, 0, 1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */),
+        ignoreTrimWhitespace: boolean(options.ignoreTrimWhitespace, defaults.ignoreTrimWhitespace),
+        renderIndicators: boolean(options.renderIndicators, defaults.renderIndicators),
+        originalEditable: boolean(options.originalEditable, defaults.originalEditable),
+        diffCodeLens: boolean(options.diffCodeLens, defaults.diffCodeLens),
+        renderOverviewRuler: boolean(options.renderOverviewRuler, defaults.renderOverviewRuler),
+        diffWordWrap: stringSet(options.diffWordWrap, defaults.diffWordWrap, ['off', 'on', 'inherit']),
+        diffAlgorithm: stringSet(options.diffAlgorithm, defaults.diffAlgorithm, ['legacy', 'advanced'], { 'smart': 'legacy', 'experimental': 'advanced' }),
+        accessibilityVerbose: boolean(options.accessibilityVerbose, defaults.accessibilityVerbose),
+        experimental: {
+            showMoves: boolean(options.experimental?.showMoves, defaults.experimental.showMoves),
+            showEmptyDecorations: boolean(options.experimental?.showEmptyDecorations, defaults.experimental.showEmptyDecorations),
+            useTrueInlineView: boolean(options.experimental?.useTrueInlineView, defaults.experimental.useTrueInlineView),
+        },
+        hideUnchangedRegions: {
+            // eslint-disable-next-line local/code-no-any-casts, @typescript-eslint/no-explicit-any
+            enabled: boolean(options.hideUnchangedRegions?.enabled ?? options.experimental?.collapseUnchangedRegions, defaults.hideUnchangedRegions.enabled),
+            contextLineCount: clampedInt(options.hideUnchangedRegions?.contextLineCount, defaults.hideUnchangedRegions.contextLineCount, 0, 1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */),
+            minimumLineCount: clampedInt(options.hideUnchangedRegions?.minimumLineCount, defaults.hideUnchangedRegions.minimumLineCount, 0, 1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */),
+            revealLineCount: clampedInt(options.hideUnchangedRegions?.revealLineCount, defaults.hideUnchangedRegions.revealLineCount, 0, 1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */),
+        },
+        isInEmbeddedEditor: boolean(options.isInEmbeddedEditor, defaults.isInEmbeddedEditor),
+        onlyShowAccessibleDiffViewer: boolean(options.onlyShowAccessibleDiffViewer, defaults.onlyShowAccessibleDiffViewer),
+        renderSideBySideInlineBreakpoint: clampedInt(options.renderSideBySideInlineBreakpoint, defaults.renderSideBySideInlineBreakpoint, 0, 1073741824 /* Constants.MAX_SAFE_SMALL_INTEGER */),
+        useInlineViewWhenSpaceIsLimited: boolean(options.useInlineViewWhenSpaceIsLimited, defaults.useInlineViewWhenSpaceIsLimited),
+        renderGutterMenu: boolean(options.renderGutterMenu, defaults.renderGutterMenu),
+        compactMode: boolean(options.compactMode, defaults.compactMode),
+    };
+}
+
+export { DiffEditorOptions };

package/dist/workers/diffEditorSash.js

@@ -0,0 +1,86 @@
+import { Sash } from '../../../../../base/browser/ui/sash/sash.js';
+import { Disposable } from '../../../../../base/common/lifecycle.js';
+import '../../../../../base/common/observableInternal/index.js';
+import { derivedWithSetter } from '../../../../../base/common/observableInternal/observables/derived.js';
+import { observableValue } from '../../../../../base/common/observableInternal/observables/observableValue.js';
+import { autorun } from '../../../../../base/common/observableInternal/reactions/autorun.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+class SashLayout {
+    resetSash() {
+        this._sashRatio.set(undefined, undefined);
+    }
+    constructor(_options, dimensions) {
+        this._options = _options;
+        this.dimensions = dimensions;
+        this.sashLeft = derivedWithSetter(this, reader => {
+            const ratio = this._sashRatio.read(reader) ?? this._options.splitViewDefaultRatio.read(reader);
+            return this._computeSashLeft(ratio, reader);
+        }, (value, tx) => {
+            const contentWidth = this.dimensions.width.get();
+            this._sashRatio.set(value / contentWidth, tx);
+        });
+        this._sashRatio = observableValue(this, undefined);
+    }
+    /** @pure */
+    _computeSashLeft(desiredRatio, reader) {
+        const contentWidth = this.dimensions.width.read(reader);
+        const midPoint = Math.floor(this._options.splitViewDefaultRatio.read(reader) * contentWidth);
+        const sashLeft = this._options.enableSplitViewResizing.read(reader) ? Math.floor(desiredRatio * contentWidth) : midPoint;
+        const MINIMUM_EDITOR_WIDTH = 100;
+        if (contentWidth <= MINIMUM_EDITOR_WIDTH * 2) {
+            return midPoint;
+        }
+        if (sashLeft < MINIMUM_EDITOR_WIDTH) {
+            return MINIMUM_EDITOR_WIDTH;
+        }
+        if (sashLeft > contentWidth - MINIMUM_EDITOR_WIDTH) {
+            return contentWidth - MINIMUM_EDITOR_WIDTH;
+        }
+        return sashLeft;
+    }
+}
+class DiffEditorSash extends Disposable {
+    constructor(_domNode, _dimensions, _enabled, _boundarySashes, sashLeft, _resetSash) {
+        super();
+        this._domNode = _domNode;
+        this._dimensions = _dimensions;
+        this._enabled = _enabled;
+        this._boundarySashes = _boundarySashes;
+        this.sashLeft = sashLeft;
+        this._resetSash = _resetSash;
+        this._sash = this._register(new Sash(this._domNode, {
+            getVerticalSashTop: (_sash) => 0,
+            getVerticalSashLeft: (_sash) => this.sashLeft.get(),
+            getVerticalSashHeight: (_sash) => this._dimensions.height.get(),
+        }, { orientation: 0 /* Orientation.VERTICAL */ }));
+        this._startSashPosition = undefined;
+        this._register(this._sash.onDidStart(() => {
+            this._startSashPosition = this.sashLeft.get();
+        }));
+        this._register(this._sash.onDidChange((e) => {
+            this.sashLeft.set(this._startSashPosition + (e.currentX - e.startX), undefined);
+        }));
+        this._register(this._sash.onDidEnd(() => this._sash.layout()));
+        this._register(this._sash.onDidReset(() => this._resetSash()));
+        this._register(autorun(reader => {
+            const sashes = this._boundarySashes.read(reader);
+            if (sashes) {
+                this._sash.orthogonalEndSash = sashes.bottom;
+            }
+        }));
+        this._register(autorun(reader => {
+            /** @description DiffEditorSash.layoutSash */
+            const enabled = this._enabled.read(reader);
+            this._sash.state = enabled ? 3 /* SashState.Enabled */ : 0 /* SashState.Disabled */;
+            this.sashLeft.read(reader);
+            this._dimensions.height.read(reader);
+            this._sash.layout();
+        }));
+    }
+}
+
+export { DiffEditorSash, SashLayout };