@codingame/monaco-vscode-api 4.1.2 → 4.2.0

package/README.md

@@ -238,6 +238,8 @@ Additionally, several packages that include the VSCode version of some services
   - Update detection, release notes...
 - **Localization**
   - Register callbacks to update the display language from the VSCode UI (either from the `Set Display Language` command or from the extension gallery extension packs)
+- **Secret Storage**
+  - Storage of secrets for extensions, will store by default in-memory. You can pass a custom implementation as part of the workbench construction options when initializing monaco services (under `secretStorageProvider`).
 
 Usage:
 

package/extensions.js

@@ -10,8 +10,9 @@ import { parse } from './vscode/src/vs/base/common/json.js';
 import { IFileService } from './vscode/src/vs/platform/files/common/files.js';
 import { IInstantiationService } from './vscode/src/vs/platform/instantiation/common/instantiation.js';
 import { IWorkbenchExtensionEnablementService } from './vscode/src/vs/workbench/services/extensionManagement/common/extensionManagement.js';
+import { StandaloneServices } from './vscode/src/vs/editor/standalone/browser/standaloneServices.js';
 import { CustomSchemas, registerExtensionFile } from '@codingame/monaco-vscode-files-service-override';
-import { getService } from './services.js';
+import { waitServicesReady } from './lifecycle.js';
 import { ExtensionManifestTranslator } from './tools/l10n.js';
 import { throttle, memoized } from './tools.js';
 import { setDefaultApi } from './api.js';
@@ -38,12 +39,14 @@ function registerExtensionFileUrl(extensionLocation, filePath, url, mimeType) {
     return fileDisposable;
 }
 const deltaExtensions = throttle(async ({ toAdd, toRemove }) => {
-    const extensionService = await getService(IExtensionService);
+    await waitServicesReady();
+    const extensionService = StandaloneServices.get(IExtensionService);
     await extensionService.deltaExtensions(toAdd, toRemove);
 }, (a, b) => ({ toAdd: [...a.toAdd, ...b.toAdd], toRemove: [...a.toRemove, ...b.toRemove] }), 0);
 async function registerRemoteExtension(directory) {
-    const fileService = await getService(IFileService);
-    const remoteAuthority = (await getService(IWorkbenchEnvironmentService)).remoteAuthority;
+    await waitServicesReady();
+    const fileService = StandaloneServices.get(IFileService);
+    const remoteAuthority = StandaloneServices.get(IWorkbenchEnvironmentService).remoteAuthority;
     const content = await fileService.readFile(joinPath(( URI.from(
         { scheme: Schemas.vscodeRemote, authority: remoteAuthority, path: directory }
     )), 'package.json'));
@@ -62,12 +65,13 @@ function registerExtension(manifest, extHostKind, { path = '/', system = false,
     const id = getExtensionId(manifest.publisher, manifest.name);
     const location = ( URI.from({ scheme: CustomSchemas.extensionFile, authority: id, path }));
     const addExtensionPromise = (async () => {
-        const remoteAuthority = (await getService(IWorkbenchEnvironmentService)).remoteAuthority;
+        await waitServicesReady();
+        const remoteAuthority = StandaloneServices.get(IWorkbenchEnvironmentService).remoteAuthority;
         let realLocation = location;
         if (extHostKind === 3 ) {
             realLocation = ( URI.from({ scheme: Schemas.vscodeRemote, authority: remoteAuthority, path }));
         }
-        const instantiationService = await getService(IInstantiationService);
+        const instantiationService = StandaloneServices.get(IInstantiationService);
         const translator = instantiationService.createInstance(ExtensionManifestTranslator);
         const localizedManifest = await translator.translateManifest(realLocation, manifest);
         const extension = {
@@ -89,7 +93,7 @@ function registerExtension(manifest, extHostKind, { path = '/', system = false,
         if (extHostKind !== 3 ) {
             extensions.push(extension);
         }
-        const extensionEnablementService = await getService(IWorkbenchExtensionEnablementService);
+        const extensionEnablementService = StandaloneServices.get(IWorkbenchExtensionEnablementService);
         if (extensionEnablementService.isEnabled(extension)) {
             await deltaExtensions({ toAdd: [extension], toRemove: [] });
         }
@@ -101,7 +105,8 @@ function registerExtension(manifest, extHostKind, { path = '/', system = false,
             await addExtensionPromise;
         },
         async isEnabled() {
-            const extensionEnablementService = await getService(IWorkbenchExtensionEnablementService);
+            await waitServicesReady();
+            const extensionEnablementService = StandaloneServices.get(IWorkbenchExtensionEnablementService);
             const extension = await addExtensionPromise;
             return extensionEnablementService.isEnabled(extension);
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codingame/monaco-vscode-api",
-  "version": "4.1.2",
+  "version": "4.2.0",
   "description": "VSCode public API plugged on the monaco editor",
   "keywords": [],
   "author": {
@@ -94,12 +94,12 @@
     }
   },
   "dependencies": {
-    "@codingame/monaco-vscode-quickaccess-service-override": "4.1.2",
-    "@codingame/monaco-vscode-files-service-override": "4.1.2",
-    "@codingame/monaco-vscode-extensions-service-override": "4.1.2",
-    "@codingame/monaco-vscode-environment-service-override": "4.1.2",
-    "@codingame/monaco-vscode-layout-service-override": "4.1.2",
-    "@codingame/monaco-vscode-host-service-override": "4.1.2",
-    "@codingame/monaco-vscode-base-service-override": "4.1.2"
+    "@codingame/monaco-vscode-extensions-service-override": "4.2.0",
+    "@codingame/monaco-vscode-files-service-override": "4.2.0",
+    "@codingame/monaco-vscode-quickaccess-service-override": "4.2.0",
+    "@codingame/monaco-vscode-environment-service-override": "4.2.0",
+    "@codingame/monaco-vscode-layout-service-override": "4.2.0",
+    "@codingame/monaco-vscode-host-service-override": "4.2.0",
+    "@codingame/monaco-vscode-base-service-override": "4.2.0"
   }
 }

package/services.d.ts

@@ -81,6 +81,8 @@ export { IExplorerService } from './vscode/src/vs/workbench/contrib/files/browse
 export { IStatusbarService } from './vscode/src/vs/workbench/services/statusbar/browser/statusbar.js';
 export { ITitleService } from './vscode/src/vs/workbench/services/title/browser/titleService.js';
 export { IBannerService } from './vscode/src/vs/workbench/services/banner/browser/bannerService.js';
+export { ISecretStorageProvider, ISecretStorageService } from './vscode/src/vs/platform/secrets/common/secrets.js';
+export { IProductConfiguration } from './vscode/src/vs/base/common/product.js';
 
 declare function initialize(overrides: IEditorOverrideServices, container?: HTMLElement, configuration?: IWorkbenchConstructionOptions, env?: EnvironmentOverride): Promise<void>;
 declare function getService<T>(identifier: ServiceIdentifier<T>): Promise<T>;

package/services.js

@@ -146,6 +146,7 @@ export { ITitleService } from './vscode/src/vs/workbench/services/title/browser/
 export { IBannerService } from './vscode/src/vs/workbench/services/banner/browser/bannerService.js';
 export { IWorkspaceTrustEnablementService, IWorkspaceTrustManagementService, IWorkspaceTrustRequestService } from './vscode/src/vs/platform/workspace/common/workspaceTrust.js';
 export { IKeybindingService } from './vscode/src/vs/platform/keybinding/common/keybinding.js';
+export { ISecretStorageService } from './vscode/src/vs/platform/secrets/common/secrets.js';
 export { IDialogService, IFileDialogService } from './vscode/src/vs/platform/dialogs/common/dialogs.js';
 async function initialize(overrides, container = document.body, configuration = {}, env) {
     checkServicesNotInitialized();

package/vscode/src/vs/base/browser/dom.js

@@ -101,7 +101,7 @@ class DomListener {
     }
 }
 function addDisposableListener(node, type, handler, useCaptureOrOptions) {
-    return ( new DomListener(node, type, handler, useCaptureOrOptions));
+    return new DomListener(node, type, handler, useCaptureOrOptions);
 }
 function _wrapAsStandardMouseEvent(targetWindow, handler) {
     return function (e) {
@@ -134,6 +134,9 @@ const addStandardDisposableGenericMouseUpListener = function addStandardDisposab
 function addDisposableGenericMouseDownListener(node, handler, useCapture) {
     return addDisposableListener(node, isIOS && BrowserFeatures.pointerEvents ? EventType.POINTER_DOWN : EventType.MOUSE_DOWN, handler, useCapture);
 }
+function addDisposableGenericMouseMoveListener(node, handler, useCapture) {
+    return addDisposableListener(node, isIOS && BrowserFeatures.pointerEvents ? EventType.POINTER_MOVE : EventType.MOUSE_MOVE, handler, useCapture);
+}
 function addDisposableGenericMouseUpListener(node, handler, useCapture) {
     return addDisposableListener(node, isIOS && BrowserFeatures.pointerEvents ? EventType.POINTER_UP : EventType.MOUSE_UP, handler, useCapture);
 }
@@ -1537,4 +1540,4 @@ function trackAttributes(from, to, filter) {
     }));
     return disposables;
 }
-export { $, DetectedFullscreenMode, Dimension, DragAndDropObserver, EventHelper, EventType, ModifierKeyEmitter, Namespace, WindowIdleValue, WindowIntervalTimer, addDisposableGenericMouseDownListener, addDisposableGenericMouseUpListener, addDisposableListener, addDisposableThrottledListener, addStandardDisposableGenericMouseDownListener, addStandardDisposableGenericMouseUpListener, addStandardDisposableListener, after, animate, append, asCSSPropertyValue, asCSSUrl, asCssValueWithDefault, basicMarkupHtmlTags, clearNode, cloneGlobalStylesheets, computeScreenAwareSize, copyAttributes, createCSSRule, createLinkElement, createMetaElement, createStyleSheet, createStyleSheet2, detectFullscreen, disposableWindowInterval, finalHandler, findParentWithClass, getActiveDocument, getActiveElement, getActiveWindow, getClientArea, getComputedStyle, getContentHeight, getContentWidth, getDocument, getDomNodePagePosition, getDomNodeZoomLevel, getLargestChildWidth, getShadowRoot, getTopLeftOffset, getTotalHeight, getTotalScrollWidth, getTotalWidth, getWindow, getWindowById, getWindowId, getWindows, getWindowsCount, h, hasParentWithClass, hasWindow, hide, hookDomPurifyHrefAndSrcSanitizer, isActiveDocument, isActiveElement, isAncestor, isAncestorOfActiveElement, isAncestorUsingFlowTo, isDragEvent, isEventLike, isGlobalStylesheet, isInShadowDOM, isKeyboardEvent, isMouseEvent, isPointerEvent, isShadowRoot, measure, modify, multibyteAwareBtoa, onDidRegisterWindow, onDidUnregisterWindow, onWillUnregisterWindow, position, prepend, registerWindow, removeCSSRulesContainingSelector, reset, restoreParentsScrollTop, runAtThisOrScheduleAtNextAnimationFrame, runWhenWindowIdle, safeInnerHtml, saveParentsScrollTop, scheduleAtNextAnimationFrame, setParentFlowTo, setVisibility, sharedMutationObserver, show, size, trackAttributes, trackFocus, triggerDownload, triggerUpload, windowOpenNoOpener, windowOpenPopup, windowOpenWithSuccess };
+export { $, DetectedFullscreenMode, Dimension, DragAndDropObserver, EventHelper, EventType, ModifierKeyEmitter, Namespace, WindowIdleValue, WindowIntervalTimer, addDisposableGenericMouseDownListener, addDisposableGenericMouseMoveListener, addDisposableGenericMouseUpListener, addDisposableListener, addDisposableThrottledListener, addStandardDisposableGenericMouseDownListener, addStandardDisposableGenericMouseUpListener, addStandardDisposableListener, after, animate, append, asCSSPropertyValue, asCSSUrl, asCssValueWithDefault, basicMarkupHtmlTags, clearNode, cloneGlobalStylesheets, computeScreenAwareSize, copyAttributes, createCSSRule, createLinkElement, createMetaElement, createStyleSheet, createStyleSheet2, detectFullscreen, disposableWindowInterval, finalHandler, findParentWithClass, getActiveDocument, getActiveElement, getActiveWindow, getClientArea, getComputedStyle, getContentHeight, getContentWidth, getDocument, getDomNodePagePosition, getDomNodeZoomLevel, getLargestChildWidth, getShadowRoot, getTopLeftOffset, getTotalHeight, getTotalScrollWidth, getTotalWidth, getWindow, getWindowById, getWindowId, getWindows, getWindowsCount, h, hasParentWithClass, hasWindow, hide, hookDomPurifyHrefAndSrcSanitizer, isActiveDocument, isActiveElement, isAncestor, isAncestorOfActiveElement, isAncestorUsingFlowTo, isDragEvent, isEventLike, isGlobalStylesheet, isInShadowDOM, isKeyboardEvent, isMouseEvent, isPointerEvent, isShadowRoot, measure, modify, multibyteAwareBtoa, onDidRegisterWindow, onDidUnregisterWindow, onWillUnregisterWindow, position, prepend, registerWindow, removeCSSRulesContainingSelector, reset, restoreParentsScrollTop, runAtThisOrScheduleAtNextAnimationFrame, runWhenWindowIdle, safeInnerHtml, saveParentsScrollTop, scheduleAtNextAnimationFrame, setParentFlowTo, setVisibility, sharedMutationObserver, show, size, trackAttributes, trackFocus, triggerDownload, triggerUpload, windowOpenNoOpener, windowOpenPopup, windowOpenWithSuccess };

package/vscode/src/vs/base/browser/ui/splitview/splitview.js

@@ -5,7 +5,7 @@ import { SmoothScrollableElement } from '../scrollbar/scrollableElement.js';
 import { range, pushToStart, pushToEnd } from '../../../common/arrays.js';
 import { Color } from '../../../common/color.js';
 import { Emitter, Event } from '../../../common/event.js';
-import { Disposable, dispose, combinedDisposable, toDisposable } from '../../../common/lifecycle.js';
+import { Disposable, combinedDisposable, dispose, toDisposable } from '../../../common/lifecycle.js';
 import { clamp } from '../../../common/numbers.js';
 import { Scrollable } from '../../../common/scrollable.js';
 import { isUndefined } from '../../../common/types.js';

package/vscode/src/vs/editor/browser/widget/diffEditor/features/hideUnchangedRegionsFeature.js

@@ -274,6 +274,7 @@ class CollapsedCodeOverlayWidget extends ViewZoneOverlayWidget {
                 }
             }
         }));
+        const editor = this._editor;
         this._register(addDisposableListener(this._nodes.top, 'mousedown', e => {
             if (e.button !== 0) {
                 return;
@@ -281,9 +282,29 @@ class CollapsedCodeOverlayWidget extends ViewZoneOverlayWidget {
             this._nodes.top.classList.toggle('dragging', true);
             this._nodes.root.classList.toggle('dragging', true);
             e.preventDefault();
-            this._unchangedRegion.visibleLineCountTop.get();
+            const startTop = e.clientY;
+            let didMove = false;
+            const cur = this._unchangedRegion.visibleLineCountTop.get();
             this._unchangedRegion.isDragged.set('top', undefined);
-            getWindow(this._nodes.top);
+            const window = getWindow(this._nodes.top);
+            const mouseMoveListener = addDisposableListener(window, 'mousemove', e => {
+                const currentTop = e.clientY;
+                const delta = currentTop - startTop;
+                didMove = didMove || Math.abs(delta) > 2;
+                const lineDelta = Math.round(delta / editor.getOption(67 ));
+                const newVal = Math.max(0, Math.min(cur + lineDelta, this._unchangedRegion.getMaxVisibleLineCountTop()));
+                this._unchangedRegion.visibleLineCountTop.set(newVal, undefined);
+            });
+            const mouseUpListener = addDisposableListener(window, 'mouseup', e => {
+                if (!didMove) {
+                    this._unchangedRegion.showMoreAbove(this._options.hideUnchangedRegionsRevealLineCount.get(), undefined);
+                }
+                this._nodes.top.classList.toggle('dragging', false);
+                this._nodes.root.classList.toggle('dragging', false);
+                this._unchangedRegion.isDragged.set(undefined, undefined);
+                mouseMoveListener.dispose();
+                mouseUpListener.dispose();
+            });
         }));
         this._register(addDisposableListener(this._nodes.bottom, 'mousedown', e => {
             if (e.button !== 0) {
@@ -292,9 +313,39 @@ class CollapsedCodeOverlayWidget extends ViewZoneOverlayWidget {
             this._nodes.bottom.classList.toggle('dragging', true);
             this._nodes.root.classList.toggle('dragging', true);
             e.preventDefault();
-            this._unchangedRegion.visibleLineCountBottom.get();
+            const startTop = e.clientY;
+            let didMove = false;
+            const cur = this._unchangedRegion.visibleLineCountBottom.get();
             this._unchangedRegion.isDragged.set('bottom', undefined);
-            getWindow(this._nodes.bottom);
+            const window = getWindow(this._nodes.bottom);
+            const mouseMoveListener = addDisposableListener(window, 'mousemove', e => {
+                const currentTop = e.clientY;
+                const delta = currentTop - startTop;
+                didMove = didMove || Math.abs(delta) > 2;
+                const lineDelta = Math.round(delta / editor.getOption(67 ));
+                const newVal = Math.max(0, Math.min(cur - lineDelta, this._unchangedRegion.getMaxVisibleLineCountBottom()));
+                const top = this._unchangedRegionRange.endLineNumberExclusive > editor.getModel().getLineCount()
+                    ? editor.getContentHeight()
+                    : editor.getTopForLineNumber(this._unchangedRegionRange.endLineNumberExclusive);
+                this._unchangedRegion.visibleLineCountBottom.set(newVal, undefined);
+                const top2 = this._unchangedRegionRange.endLineNumberExclusive > editor.getModel().getLineCount()
+                    ? editor.getContentHeight()
+                    : editor.getTopForLineNumber(this._unchangedRegionRange.endLineNumberExclusive);
+                editor.setScrollTop(editor.getScrollTop() + (top2 - top));
+            });
+            const mouseUpListener = addDisposableListener(window, 'mouseup', e => {
+                this._unchangedRegion.isDragged.set(undefined, undefined);
+                if (!didMove) {
+                    const top = editor.getTopForLineNumber(this._unchangedRegionRange.endLineNumberExclusive);
+                    this._unchangedRegion.showMoreBelow(this._options.hideUnchangedRegionsRevealLineCount.get(), undefined);
+                    const top2 = editor.getTopForLineNumber(this._unchangedRegionRange.endLineNumberExclusive);
+                    editor.setScrollTop(editor.getScrollTop() + (top2 - top));
+                }
+                this._nodes.bottom.classList.toggle('dragging', false);
+                this._nodes.root.classList.toggle('dragging', false);
+                mouseMoveListener.dispose();
+                mouseUpListener.dispose();
+            });
         }));
         this._register(autorun(reader => {
             const children = [];

package/vscode/src/vs/editor/contrib/colorPicker/browser/colorPickerWidget.js

@@ -203,6 +203,14 @@ class SaturationBox extends Disposable {
             this.onDidChangePosition(e.offsetX, e.offsetY);
         }
         this.monitor.startMonitoring(e.target, e.pointerId, e.buttons, event => this.onDidChangePosition(event.pageX - origin.left, event.pageY - origin.top), () => null);
+        const pointerUpListener = addDisposableListener(e.target.ownerDocument, EventType.POINTER_UP, () => {
+            this._onColorFlushed.fire();
+            pointerUpListener.dispose();
+            if (this.monitor) {
+                this.monitor.stopMonitoring(true);
+                this.monitor = null;
+            }
+        }, true);
     }
     onDidChangePosition(left, top) {
         const s = Math.max(0, Math.min(1, left / this.width));
@@ -293,6 +301,12 @@ class Strip extends Disposable {
             this.onDidChangeTop(e.offsetY);
         }
         monitor.startMonitoring(e.target, e.pointerId, e.buttons, event => this.onDidChangeTop(event.pageY - origin.top), () => null);
+        const pointerUpListener = addDisposableListener(e.target.ownerDocument, EventType.POINTER_UP, () => {
+            this._onColorFlushed.fire();
+            pointerUpListener.dispose();
+            monitor.stopMonitoring(true);
+            this.domNode.classList.remove('grabbing');
+        }, true);
     }
     onDidChangeTop(top) {
         const value = Math.max(0, Math.min(1, 1 - (top / this.height)));

package/vscode/src/vs/platform/secrets/common/secrets.d.ts

@@ -1,3 +1,6 @@
+import { ServiceIdentifier } from '../../instantiation/common/instantiation.js';
+import { Event } from '../../../base/common/event.js';
+
 interface ISecretStorageProvider {
     type: 'in-memory' | 'persisted' | 'unknown';
     get(key: string): Promise<string | undefined>;
@@ -5,4 +8,10 @@ interface ISecretStorageProvider {
     delete(key: string): Promise<void>;
 }
 
-export type { ISecretStorageProvider };
+declare const ISecretStorageService: ServiceIdentifier<ISecretStorageService>;
+interface ISecretStorageService extends ISecretStorageProvider {
+    readonly _serviceBrand: undefined;
+    onDidChangeSecret: Event<string>;
+}
+
+export { type ISecretStorageProvider, ISecretStorageService };

package/vscode/src/vs/platform/secrets/common/secrets.js

@@ -1,8 +1,127 @@
-import '../../../base/common/async.js';
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { SequencerByKey } from '../../../base/common/async.js';
+import { IEncryptionService } from '../../encryption/common/encryptionService.js';
 import { createDecorator } from '../../instantiation/common/instantiation.js';
-import '../../storage/common/storage.js';
-import '../../../base/common/event.js';
-import '../../log/common/log.js';
-import '../../../base/common/lifecycle.js';
+import { InMemoryStorageService, IStorageService } from '../../storage/common/storage.js';
+import { Emitter } from '../../../base/common/event.js';
+import { ILogService } from '../../log/common/log.js';
+import { Disposable, DisposableStore } from '../../../base/common/lifecycle.js';
+import { Lazy } from '../../../base/common/lazy.js';
 const ISecretStorageService = ( createDecorator('secretStorageService'));
-export { ISecretStorageService };
+let BaseSecretStorageService = class BaseSecretStorageService extends Disposable {
+    constructor(_useInMemoryStorage, _storageService, _encryptionService, _logService) {
+        super();
+        this._useInMemoryStorage = _useInMemoryStorage;
+        this._storageService = _storageService;
+        this._encryptionService = _encryptionService;
+        this._logService = _logService;
+        this._storagePrefix = 'secret://';
+        this.onDidChangeSecretEmitter = this._register(( new Emitter()));
+        this.onDidChangeSecret = this.onDidChangeSecretEmitter.event;
+        this._sequencer = ( new SequencerByKey());
+        this._type = 'unknown';
+        this._onDidChangeValueDisposable = this._register(( new DisposableStore()));
+        this._lazyStorageService = ( new Lazy(() => this.initialize()));
+    }
+    get type() {
+        return this._type;
+    }
+    get resolvedStorageService() {
+        return this._lazyStorageService.value;
+    }
+    get(key) {
+        return this._sequencer.queue(key, async () => {
+            const storageService = await this.resolvedStorageService;
+            const fullKey = this.getKey(key);
+            this._logService.trace('[secrets] getting secret for key:', fullKey);
+            const encrypted = storageService.get(fullKey, -1 );
+            if (!encrypted) {
+                this._logService.trace('[secrets] no secret found for key:', fullKey);
+                return undefined;
+            }
+            try {
+                this._logService.trace('[secrets] decrypting gotten secret for key:', fullKey);
+                const result = this._type === 'in-memory'
+                    ? encrypted
+                    : await this._encryptionService.decrypt(encrypted);
+                this._logService.trace('[secrets] decrypted secret for key:', fullKey);
+                return result;
+            }
+            catch (e) {
+                this._logService.error(e);
+                this.delete(key);
+                return undefined;
+            }
+        });
+    }
+    set(key, value) {
+        return this._sequencer.queue(key, async () => {
+            const storageService = await this.resolvedStorageService;
+            this._logService.trace('[secrets] encrypting secret for key:', key);
+            let encrypted;
+            try {
+                encrypted = this._type === 'in-memory'
+                    ? value
+                    : await this._encryptionService.encrypt(value);
+            }
+            catch (e) {
+                this._logService.error(e);
+                throw e;
+            }
+            const fullKey = this.getKey(key);
+            this._logService.trace('[secrets] storing encrypted secret for key:', fullKey);
+            storageService.store(fullKey, encrypted, -1 , 1 );
+            this._logService.trace('[secrets] stored encrypted secret for key:', fullKey);
+        });
+    }
+    delete(key) {
+        return this._sequencer.queue(key, async () => {
+            const storageService = await this.resolvedStorageService;
+            const fullKey = this.getKey(key);
+            this._logService.trace('[secrets] deleting secret for key:', fullKey);
+            storageService.remove(fullKey, -1 );
+            this._logService.trace('[secrets] deleted secret for key:', fullKey);
+        });
+    }
+    async initialize() {
+        let storageService;
+        if (!this._useInMemoryStorage && (await this._encryptionService.isEncryptionAvailable())) {
+            this._logService.trace(`[SecretStorageService] Encryption is available, using persisted storage`);
+            this._type = 'persisted';
+            storageService = this._storageService;
+        }
+        else {
+            if (this._type === 'in-memory') {
+                return this._storageService;
+            }
+            this._logService.trace('[SecretStorageService] Encryption is not available, falling back to in-memory storage');
+            this._type = 'in-memory';
+            storageService = this._register(( new InMemoryStorageService()));
+        }
+        this._onDidChangeValueDisposable.clear();
+        this._onDidChangeValueDisposable.add(storageService.onDidChangeValue(-1 , undefined, this._onDidChangeValueDisposable)(e => {
+            this.onDidChangeValue(e.key);
+        }));
+        return storageService;
+    }
+    reinitialize() {
+        this._lazyStorageService = ( new Lazy(() => this.initialize()));
+    }
+    onDidChangeValue(key) {
+        if (!key.startsWith(this._storagePrefix)) {
+            return;
+        }
+        const secretKey = key.slice(this._storagePrefix.length);
+        this._logService.trace(`[SecretStorageService] Notifying change in value for secret: ${secretKey}`);
+        this.onDidChangeSecretEmitter.fire(secretKey);
+    }
+    getKey(key) {
+        return `${this._storagePrefix}${key}`;
+    }
+};
+BaseSecretStorageService = ( __decorate([
+    ( __param(1, IStorageService)),
+    ( __param(2, IEncryptionService)),
+    ( __param(3, ILogService))
+], BaseSecretStorageService));
+export { BaseSecretStorageService, ISecretStorageService };