monaco-editor11 1.1.1 → 1.1.2

package/dist/workers/toolbar.js

@@ -0,0 +1,244 @@
+import { ActionBar } from '../actionbar/actionbar.js';
+import { DropdownMenuActionViewItem } from '../dropdown/dropdownActionViewItem.js';
+import { Action, SubmenuAction, Separator } from '../../../common/actions.js';
+import { Codicon } from '../../../common/codicons.js';
+import { ThemeIcon } from '../../../common/themables.js';
+import { EventMultiplexer } from '../../../common/event.js';
+import { Disposable, DisposableStore, toDisposable } from '../../../common/lifecycle.js';
+import './toolbar.css';
+import { localize } from '../../../../nls.js';
+import { createInstantHoverDelegate } from '../hover/hoverDelegateFactory.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+const ACTION_MIN_WIDTH = 24; /* 20px codicon + 4px left padding*/
+/**
+ * A widget that combines an action bar for primary actions and a dropdown for secondary actions.
+ */
+class ToolBar extends Disposable {
+    get onDidChangeDropdownVisibility() { return this._onDidChangeDropdownVisibility.event; }
+    constructor(container, contextMenuProvider, options = { orientation: 0 /* ActionsOrientation.HORIZONTAL */ }) {
+        super();
+        this.submenuActionViewItems = [];
+        this.hasSecondaryActions = false;
+        this._onDidChangeDropdownVisibility = this._register(new EventMultiplexer());
+        this.originalPrimaryActions = [];
+        this.originalSecondaryActions = [];
+        this.hiddenActions = [];
+        this.disposables = this._register(new DisposableStore());
+        options.hoverDelegate = options.hoverDelegate ?? this._register(createInstantHoverDelegate());
+        this.options = options;
+        this.toggleMenuAction = this._register(new ToggleMenuAction(() => this.toggleMenuActionViewItem?.show(), options.toggleMenuTitle));
+        this.element = document.createElement('div');
+        this.element.className = 'monaco-toolbar';
+        container.appendChild(this.element);
+        this.actionBar = this._register(new ActionBar(this.element, {
+            orientation: options.orientation,
+            ariaLabel: options.ariaLabel,
+            actionRunner: options.actionRunner,
+            allowContextMenu: options.allowContextMenu,
+            highlightToggledItems: options.highlightToggledItems,
+            hoverDelegate: options.hoverDelegate,
+            actionViewItemProvider: (action, viewItemOptions) => {
+                if (action.id === ToggleMenuAction.ID) {
+                    this.toggleMenuActionViewItem = new DropdownMenuActionViewItem(action, { getActions: () => this.toggleMenuAction.menuActions }, contextMenuProvider, {
+                        actionViewItemProvider: this.options.actionViewItemProvider,
+                        actionRunner: this.actionRunner,
+                        keybindingProvider: this.options.getKeyBinding,
+                        classNames: ThemeIcon.asClassNameArray(options.moreIcon ?? Codicon.toolBarMore),
+                        anchorAlignmentProvider: this.options.anchorAlignmentProvider,
+                        menuAsChild: !!this.options.renderDropdownAsChildElement,
+                        skipTelemetry: this.options.skipTelemetry,
+                        isMenu: true,
+                        hoverDelegate: this.options.hoverDelegate
+                    });
+                    this.toggleMenuActionViewItem.setActionContext(this.actionBar.context);
+                    this.disposables.add(this._onDidChangeDropdownVisibility.add(this.toggleMenuActionViewItem.onDidChangeVisibility));
+                    return this.toggleMenuActionViewItem;
+                }
+                if (options.actionViewItemProvider) {
+                    const result = options.actionViewItemProvider(action, viewItemOptions);
+                    if (result) {
+                        return result;
+                    }
+                }
+                if (action instanceof SubmenuAction) {
+                    const result = new DropdownMenuActionViewItem(action, action.actions, contextMenuProvider, {
+                        actionViewItemProvider: this.options.actionViewItemProvider,
+                        actionRunner: this.actionRunner,
+                        keybindingProvider: this.options.getKeyBinding,
+                        classNames: action.class,
+                        anchorAlignmentProvider: this.options.anchorAlignmentProvider,
+                        menuAsChild: !!this.options.renderDropdownAsChildElement,
+                        skipTelemetry: this.options.skipTelemetry,
+                        hoverDelegate: this.options.hoverDelegate
+                    });
+                    result.setActionContext(this.actionBar.context);
+                    this.submenuActionViewItems.push(result);
+                    this.disposables.add(this._onDidChangeDropdownVisibility.add(result.onDidChangeVisibility));
+                    return result;
+                }
+                return undefined;
+            }
+        }));
+        // Responsive support
+        if (this.options.responsive) {
+            this.element.classList.add('responsive');
+            const observer = new ResizeObserver(() => {
+                this.setToolbarMaxWidth(this.element.getBoundingClientRect().width);
+            });
+            observer.observe(this.element);
+            this._store.add(toDisposable(() => observer.disconnect()));
+        }
+    }
+    set actionRunner(actionRunner) {
+        this.actionBar.actionRunner = actionRunner;
+    }
+    get actionRunner() {
+        return this.actionBar.actionRunner;
+    }
+    set context(context) {
+        this.actionBar.context = context;
+        this.toggleMenuActionViewItem?.setActionContext(context);
+        for (const actionViewItem of this.submenuActionViewItems) {
+            actionViewItem.setActionContext(context);
+        }
+    }
+    getElement() {
+        return this.element;
+    }
+    getItemAction(indexOrElement) {
+        return this.actionBar.getAction(indexOrElement);
+    }
+    getItemWidth(index) {
+        return this.actionBar.getWidth(index);
+    }
+    setActions(primaryActions, secondaryActions) {
+        this.clear();
+        // Store primary and secondary actions as rendered initially
+        this.originalPrimaryActions = primaryActions ? primaryActions.slice(0) : [];
+        this.originalSecondaryActions = secondaryActions ? secondaryActions.slice(0) : [];
+        const primaryActionsToSet = primaryActions ? primaryActions.slice(0) : [];
+        // Inject additional action to open secondary actions if present
+        this.hasSecondaryActions = !!(secondaryActions && secondaryActions.length > 0);
+        if (this.hasSecondaryActions && secondaryActions) {
+            this.toggleMenuAction.menuActions = secondaryActions.slice(0);
+            primaryActionsToSet.push(this.toggleMenuAction);
+        }
+        if (primaryActionsToSet.length > 0 && this.options.trailingSeparator) {
+            primaryActionsToSet.push(new Separator());
+        }
+        primaryActionsToSet.forEach(action => {
+            this.actionBar.push(action, { icon: this.options.icon ?? true, label: this.options.label ?? false, keybinding: this.getKeybindingLabel(action) });
+        });
+        if (this.options.responsive) {
+            // Reset hidden actions
+            this.hiddenActions.length = 0;
+            // Update toolbar to fit with container width
+            this.setToolbarMaxWidth(this.element.getBoundingClientRect().width);
+        }
+    }
+    getKeybindingLabel(action) {
+        const key = this.options.getKeyBinding?.(action);
+        return key?.getLabel() ?? undefined;
+    }
+    getItemsWidthResponsive() {
+        // Each action is assumed to have a minimum width so that actions with a label
+        // can shrink to the action's minimum width. We do this so that action visibility
+        // takes precedence over the action label.
+        return this.actionBar.length() * ACTION_MIN_WIDTH;
+    }
+    setToolbarMaxWidth(maxWidth) {
+        if (this.actionBar.isEmpty() ||
+            (this.getItemsWidthResponsive() <= maxWidth && this.hiddenActions.length === 0)) {
+            return;
+        }
+        if (this.getItemsWidthResponsive() > maxWidth) {
+            // Hide actions from the right
+            while (this.getItemsWidthResponsive() > maxWidth && this.actionBar.length() > 0) {
+                const index = this.originalPrimaryActions.length - this.hiddenActions.length - 1;
+                if (index < 0) {
+                    break;
+                }
+                // Store the action and its size
+                const size = Math.min(ACTION_MIN_WIDTH, this.getItemWidth(index));
+                const action = this.originalPrimaryActions[index];
+                this.hiddenActions.unshift({ action, size });
+                // Remove the action
+                this.actionBar.pull(index);
+                // There are no secondary actions, but we have actions that we need to hide so we
+                // create the overflow menu. This will ensure that another primary action will be
+                // removed making space for the overflow menu.
+                if (this.originalSecondaryActions.length === 0 && this.hiddenActions.length === 1) {
+                    this.actionBar.push(this.toggleMenuAction, {
+                        icon: this.options.icon ?? true,
+                        label: this.options.label ?? false,
+                        keybinding: this.getKeybindingLabel(this.toggleMenuAction),
+                    });
+                }
+            }
+        }
+        else {
+            // Show actions from the top of the toggle menu
+            while (this.hiddenActions.length > 0) {
+                const entry = this.hiddenActions.shift();
+                if (this.getItemsWidthResponsive() + entry.size > maxWidth) {
+                    // Not enough space to show the action
+                    this.hiddenActions.unshift(entry);
+                    break;
+                }
+                // Add the action
+                this.actionBar.push(entry.action, {
+                    icon: this.options.icon ?? true,
+                    label: this.options.label ?? false,
+                    keybinding: this.getKeybindingLabel(entry.action),
+                    index: this.originalPrimaryActions.length - this.hiddenActions.length - 1
+                });
+                // There are no secondary actions, and there is only one hidden item left so we
+                // remove the overflow menu making space for the last hidden action to be shown.
+                if (this.originalSecondaryActions.length === 0 && this.hiddenActions.length === 1) {
+                    this.toggleMenuAction.menuActions = [];
+                    this.actionBar.pull(this.actionBar.length() - 1);
+                }
+            }
+        }
+        // Update overflow menu
+        const hiddenActions = this.hiddenActions.map(entry => entry.action);
+        if (this.originalSecondaryActions.length > 0 || hiddenActions.length > 0) {
+            const secondaryActions = this.originalSecondaryActions.slice(0);
+            this.toggleMenuAction.menuActions = Separator.join(hiddenActions, secondaryActions);
+        }
+    }
+    clear() {
+        this.submenuActionViewItems = [];
+        this.disposables.clear();
+        this.actionBar.clear();
+    }
+    dispose() {
+        this.clear();
+        this.disposables.dispose();
+        super.dispose();
+    }
+}
+class ToggleMenuAction extends Action {
+    static { this.ID = 'toolbar.toggle.more'; }
+    constructor(toggleDropdownMenu, title) {
+        title = title || localize(17, "More Actions...");
+        super(ToggleMenuAction.ID, title, undefined, true);
+        this._menuActions = [];
+        this.toggleDropdownMenu = toggleDropdownMenu;
+    }
+    async run() {
+        this.toggleDropdownMenu();
+    }
+    get menuActions() {
+        return this._menuActions;
+    }
+    set menuActions(actions) {
+        this._menuActions = actions;
+    }
+}
+
+export { ToggleMenuAction, ToolBar };

package/dist/workers/touch.js

@@ -0,0 +1,270 @@
+import { onDidRegisterWindow, addDisposableListener, scheduleAtNextAnimationFrame } from './dom.js';
+import { mainWindow } from './window.js';
+import { memoize } from '../common/decorators.js';
+import { Event } from '../common/event.js';
+import { Disposable, markAsSingleton, toDisposable } from '../common/lifecycle.js';
+import { LinkedList } from '../common/linkedList.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 EventType;
+(function (EventType) {
+    EventType.Tap = '-monaco-gesturetap';
+    EventType.Change = '-monaco-gesturechange';
+    EventType.Start = '-monaco-gesturestart';
+    EventType.End = '-monaco-gesturesend';
+    EventType.Contextmenu = '-monaco-gesturecontextmenu';
+})(EventType || (EventType = {}));
+class Gesture extends Disposable {
+    static { this.SCROLL_FRICTION = -5e-3; }
+    static { this.HOLD_DELAY = 700; }
+    static { this.CLEAR_TAP_COUNT_TIME = 400; } // ms
+    constructor() {
+        super();
+        this.dispatched = false;
+        this.targets = new LinkedList();
+        this.ignoreTargets = new LinkedList();
+        this.activeTouches = {};
+        this.handle = null;
+        this._lastSetTapCountTime = 0;
+        this._register(Event.runAndSubscribe(onDidRegisterWindow, ({ window, disposables }) => {
+            disposables.add(addDisposableListener(window.document, 'touchstart', (e) => this.onTouchStart(e), { passive: false }));
+            disposables.add(addDisposableListener(window.document, 'touchend', (e) => this.onTouchEnd(window, e)));
+            disposables.add(addDisposableListener(window.document, 'touchmove', (e) => this.onTouchMove(e), { passive: false }));
+        }, { window: mainWindow, disposables: this._store }));
+    }
+    static addTarget(element) {
+        if (!Gesture.isTouchDevice()) {
+            return Disposable.None;
+        }
+        if (!Gesture.INSTANCE) {
+            Gesture.INSTANCE = markAsSingleton(new Gesture());
+        }
+        const remove = Gesture.INSTANCE.targets.push(element);
+        return toDisposable(remove);
+    }
+    static ignoreTarget(element) {
+        if (!Gesture.isTouchDevice()) {
+            return Disposable.None;
+        }
+        if (!Gesture.INSTANCE) {
+            Gesture.INSTANCE = markAsSingleton(new Gesture());
+        }
+        const remove = Gesture.INSTANCE.ignoreTargets.push(element);
+        return toDisposable(remove);
+    }
+    static isTouchDevice() {
+        // `'ontouchstart' in window` always evaluates to true with typescript's modern typings. This causes `window` to be
+        // `never` later in `window.navigator`. That's why we need the explicit `window as Window` cast
+        return 'ontouchstart' in mainWindow || navigator.maxTouchPoints > 0;
+    }
+    dispose() {
+        if (this.handle) {
+            this.handle.dispose();
+            this.handle = null;
+        }
+        super.dispose();
+    }
+    onTouchStart(e) {
+        const timestamp = Date.now(); // use Date.now() because on FF e.timeStamp is not epoch based.
+        if (this.handle) {
+            this.handle.dispose();
+            this.handle = null;
+        }
+        for (let i = 0, len = e.targetTouches.length; i < len; i++) {
+            const touch = e.targetTouches.item(i);
+            this.activeTouches[touch.identifier] = {
+                id: touch.identifier,
+                initialTarget: touch.target,
+                initialTimeStamp: timestamp,
+                initialPageX: touch.pageX,
+                initialPageY: touch.pageY,
+                rollingTimestamps: [timestamp],
+                rollingPageX: [touch.pageX],
+                rollingPageY: [touch.pageY]
+            };
+            const evt = this.newGestureEvent(EventType.Start, touch.target);
+            evt.pageX = touch.pageX;
+            evt.pageY = touch.pageY;
+            this.dispatchEvent(evt);
+        }
+        if (this.dispatched) {
+            e.preventDefault();
+            e.stopPropagation();
+            this.dispatched = false;
+        }
+    }
+    onTouchEnd(targetWindow, e) {
+        const timestamp = Date.now(); // use Date.now() because on FF e.timeStamp is not epoch based.
+        const activeTouchCount = Object.keys(this.activeTouches).length;
+        for (let i = 0, len = e.changedTouches.length; i < len; i++) {
+            const touch = e.changedTouches.item(i);
+            if (!this.activeTouches.hasOwnProperty(String(touch.identifier))) {
+                console.warn('move of an UNKNOWN touch', touch);
+                continue;
+            }
+            const data = this.activeTouches[touch.identifier], holdTime = Date.now() - data.initialTimeStamp;
+            if (holdTime < Gesture.HOLD_DELAY
+                && Math.abs(data.initialPageX - data.rollingPageX.at(-1)) < 30
+                && Math.abs(data.initialPageY - data.rollingPageY.at(-1)) < 30) {
+                const evt = this.newGestureEvent(EventType.Tap, data.initialTarget);
+                evt.pageX = data.rollingPageX.at(-1);
+                evt.pageY = data.rollingPageY.at(-1);
+                this.dispatchEvent(evt);
+            }
+            else if (holdTime >= Gesture.HOLD_DELAY
+                && Math.abs(data.initialPageX - data.rollingPageX.at(-1)) < 30
+                && Math.abs(data.initialPageY - data.rollingPageY.at(-1)) < 30) {
+                const evt = this.newGestureEvent(EventType.Contextmenu, data.initialTarget);
+                evt.pageX = data.rollingPageX.at(-1);
+                evt.pageY = data.rollingPageY.at(-1);
+                this.dispatchEvent(evt);
+            }
+            else if (activeTouchCount === 1) {
+                const finalX = data.rollingPageX.at(-1);
+                const finalY = data.rollingPageY.at(-1);
+                const deltaT = data.rollingTimestamps.at(-1) - data.rollingTimestamps[0];
+                const deltaX = finalX - data.rollingPageX[0];
+                const deltaY = finalY - data.rollingPageY[0];
+                // We need to get all the dispatch targets on the start of the inertia event
+                const dispatchTo = [...this.targets].filter(t => data.initialTarget instanceof Node && t.contains(data.initialTarget));
+                this.inertia(targetWindow, dispatchTo, timestamp, // time now
+                Math.abs(deltaX) / deltaT, // speed
+                deltaX > 0 ? 1 : -1, // x direction
+                finalX, // x now
+                Math.abs(deltaY) / deltaT, // y speed
+                deltaY > 0 ? 1 : -1, // y direction
+                finalY // y now
+                );
+            }
+            this.dispatchEvent(this.newGestureEvent(EventType.End, data.initialTarget));
+            // forget about this touch
+            delete this.activeTouches[touch.identifier];
+        }
+        if (this.dispatched) {
+            e.preventDefault();
+            e.stopPropagation();
+            this.dispatched = false;
+        }
+    }
+    newGestureEvent(type, initialTarget) {
+        const event = document.createEvent('CustomEvent');
+        event.initEvent(type, false, true);
+        event.initialTarget = initialTarget;
+        event.tapCount = 0;
+        return event;
+    }
+    dispatchEvent(event) {
+        if (event.type === EventType.Tap) {
+            const currentTime = (new Date()).getTime();
+            let setTapCount = 0;
+            if (currentTime - this._lastSetTapCountTime > Gesture.CLEAR_TAP_COUNT_TIME) {
+                setTapCount = 1;
+            }
+            else {
+                setTapCount = 2;
+            }
+            this._lastSetTapCountTime = currentTime;
+            event.tapCount = setTapCount;
+        }
+        else if (event.type === EventType.Change || event.type === EventType.Contextmenu) {
+            // tap is canceled by scrolling or context menu
+            this._lastSetTapCountTime = 0;
+        }
+        if (event.initialTarget instanceof Node) {
+            for (const ignoreTarget of this.ignoreTargets) {
+                if (ignoreTarget.contains(event.initialTarget)) {
+                    return;
+                }
+            }
+            const targets = [];
+            for (const target of this.targets) {
+                if (target.contains(event.initialTarget)) {
+                    let depth = 0;
+                    let now = event.initialTarget;
+                    while (now && now !== target) {
+                        depth++;
+                        now = now.parentElement;
+                    }
+                    targets.push([depth, target]);
+                }
+            }
+            targets.sort((a, b) => a[0] - b[0]);
+            for (const [_, target] of targets) {
+                target.dispatchEvent(event);
+                this.dispatched = true;
+            }
+        }
+    }
+    inertia(targetWindow, dispatchTo, t1, vX, dirX, x, vY, dirY, y) {
+        this.handle = scheduleAtNextAnimationFrame(targetWindow, () => {
+            const now = Date.now();
+            // velocity: old speed + accel_over_time
+            const deltaT = now - t1;
+            let delta_pos_x = 0, delta_pos_y = 0;
+            let stopped = true;
+            vX += Gesture.SCROLL_FRICTION * deltaT;
+            vY += Gesture.SCROLL_FRICTION * deltaT;
+            if (vX > 0) {
+                stopped = false;
+                delta_pos_x = dirX * vX * deltaT;
+            }
+            if (vY > 0) {
+                stopped = false;
+                delta_pos_y = dirY * vY * deltaT;
+            }
+            // dispatch translation event
+            const evt = this.newGestureEvent(EventType.Change);
+            evt.translationX = delta_pos_x;
+            evt.translationY = delta_pos_y;
+            dispatchTo.forEach(d => d.dispatchEvent(evt));
+            if (!stopped) {
+                this.inertia(targetWindow, dispatchTo, now, vX, dirX, x + delta_pos_x, vY, dirY, y + delta_pos_y);
+            }
+        });
+    }
+    onTouchMove(e) {
+        const timestamp = Date.now(); // use Date.now() because on FF e.timeStamp is not epoch based.
+        for (let i = 0, len = e.changedTouches.length; i < len; i++) {
+            const touch = e.changedTouches.item(i);
+            if (!this.activeTouches.hasOwnProperty(String(touch.identifier))) {
+                console.warn('end of an UNKNOWN touch', touch);
+                continue;
+            }
+            const data = this.activeTouches[touch.identifier];
+            const evt = this.newGestureEvent(EventType.Change, data.initialTarget);
+            evt.translationX = touch.pageX - data.rollingPageX.at(-1);
+            evt.translationY = touch.pageY - data.rollingPageY.at(-1);
+            evt.pageX = touch.pageX;
+            evt.pageY = touch.pageY;
+            this.dispatchEvent(evt);
+            // only keep a few data points, to average the final speed
+            if (data.rollingPageX.length > 3) {
+                data.rollingPageX.shift();
+                data.rollingPageY.shift();
+                data.rollingTimestamps.shift();
+            }
+            data.rollingPageX.push(touch.pageX);
+            data.rollingPageY.push(touch.pageY);
+            data.rollingTimestamps.push(timestamp);
+        }
+        if (this.dispatched) {
+            e.preventDefault();
+            e.stopPropagation();
+            this.dispatched = false;
+        }
+    }
+}
+__decorate([
+    memoize
+], Gesture, "isTouchDevice", null);
+
+export { EventType, Gesture };

package/dist/workers/transaction.js

@@ -0,0 +1,109 @@
+import { handleBugIndicatingErrorRecovery } from './base.js';
+import { getFunctionName } from './debugName.js';
+import { getLogger } from './logging/logging.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * Starts a transaction in which many observables can be changed at once.
+ * {@link fn} should start with a JS Doc using `@description` to give the transaction a debug name.
+ * Reaction run on demand or when the transaction ends.
+ */
+function transaction(fn, getDebugName) {
+    const tx = new TransactionImpl(fn, getDebugName);
+    try {
+        fn(tx);
+    }
+    finally {
+        tx.finish();
+    }
+}
+let _globalTransaction = undefined;
+function globalTransaction(fn) {
+    if (_globalTransaction) {
+        fn(_globalTransaction);
+    }
+    else {
+        const tx = new TransactionImpl(fn, undefined);
+        _globalTransaction = tx;
+        try {
+            fn(tx);
+        }
+        finally {
+            tx.finish(); // During finish, more actions might be added to the transaction.
+            // Which is why we only clear the global transaction after finish.
+            _globalTransaction = undefined;
+        }
+    }
+}
+/** @deprecated */
+async function asyncTransaction(fn, getDebugName) {
+    const tx = new TransactionImpl(fn, getDebugName);
+    try {
+        await fn(tx);
+    }
+    finally {
+        tx.finish();
+    }
+}
+/**
+ * Allows to chain transactions.
+ */
+function subtransaction(tx, fn, getDebugName) {
+    if (!tx) {
+        transaction(fn, getDebugName);
+    }
+    else {
+        fn(tx);
+    }
+}
+class TransactionImpl {
+    constructor(_fn, _getDebugName) {
+        this._fn = _fn;
+        this._getDebugName = _getDebugName;
+        this._updatingObservers = [];
+        getLogger()?.handleBeginTransaction(this);
+    }
+    getDebugName() {
+        if (this._getDebugName) {
+            return this._getDebugName();
+        }
+        return getFunctionName(this._fn);
+    }
+    updateObserver(observer, observable) {
+        if (!this._updatingObservers) {
+            // This happens when a transaction is used in a callback or async function.
+            // If an async transaction is used, make sure the promise awaits all users of the transaction (e.g. no race).
+            handleBugIndicatingErrorRecovery('Transaction already finished!');
+            // Error recovery
+            transaction(tx => {
+                tx.updateObserver(observer, observable);
+            });
+            return;
+        }
+        // When this gets called while finish is active, they will still get considered
+        this._updatingObservers.push({ observer, observable });
+        observer.beginUpdate(observable);
+    }
+    finish() {
+        const updatingObservers = this._updatingObservers;
+        if (!updatingObservers) {
+            handleBugIndicatingErrorRecovery('transaction.finish() has already been called!');
+            return;
+        }
+        for (let i = 0; i < updatingObservers.length; i++) {
+            const { observer, observable } = updatingObservers[i];
+            observer.endUpdate(observable);
+        }
+        // Prevent anyone from updating observers from now on.
+        this._updatingObservers = null;
+        getLogger()?.handleEndTransaction(this);
+    }
+    debugGetUpdatingObservers() {
+        return this._updatingObservers;
+    }
+}
+
+export { TransactionImpl, asyncTransaction, globalTransaction, subtransaction, transaction };